/**
 * STRATEGY ARMS — interchangeable per-step experiment proposers for the portfolio brain.
 *
 * The No-Free-Lunch theorem is the production reality: no single optimiser is best across all landscapes
 * (smooth, rugged, low-D, high-D). So Melete does not bet on one algorithm — it runs a PORTFOLIO of arms
 * and lets a bandit (portfolio.ts) allocate each expensive experiment to whichever arm is winning ON THIS
 * problem. An arm is a stateful proposer: given the history so far, propose the next experiment.
 *
 * Arms shipped:
 *   • kernel-ucb  — Gaussian-kernel surrogate + UCB (the strong low-D Bayesian-lite core)
 *   • cmaes       — a (1+1) self-adaptive evolution strategy (robust in higher-D and on rugged surfaces,
 *                   where the kernel surrogate degrades — fixes the high-D failure of a pure-BO engine)
 *   • resonance   — the wave-interference field (a diversity/exploration hedge; earns budget only when it
 *                   actually helps — honest: it is not strong alone, but a portfolio loses nothing by
 *                   holding a hedge that the bandit can ignore)
 *   • random      — uniform exploration (the escape hatch / baseline)
 *
 * Each arm is created fresh per run via a factory (closure-held state), so a discovery is deterministic
 * and reproducible. Proposers avoid already-seen experiments.
 */
import { type Space, type Experiment } from "./space.js";
import { type Goal, type Observation } from "./engine.js";
export interface ArmContext {
    space: Space;
    obs: Observation[];
    t: number;
    budget: number;
    rnd: () => number;
    goal: Goal;
}
export interface Arm {
    name: string;
    propose: (ctx: ArmContext) => Experiment;
}
/** kernel-UCB: dense grid + local cloud candidates; pick argmax(surrogate mean + annealed·uncertainty). */
export declare function armKernelUCB(bandwidth?: number, kappa0?: number): Arm;
/** (1+1) self-adaptive evolution strategy — sample N(best, σ); σ grows when stuck, shrinks on success. */
export declare function armCMAES(sigma0?: number): Arm;
/** Wave-interference field (diversity hedge). Honest: weak alone; the bandit only funds it when it helps. */
export declare function armResonance(sigma?: number, k0?: number, rho?: number): Arm;
export declare function armRandom(): Arm;
/** Real GP surrogate + Expected Improvement — the gold-standard sample-efficient acquisition. */
export declare function armGP(lengthscale?: number, noise?: number): Arm;
/** Simulated annealing arm — temperature-annealed random walk from the best; escapes via occasional far jumps. */
export declare function armSimAnneal(temp0?: number): Arm;
/** Trust-region arm — coordinate steps within a region around the best; region tightens as the run progresses. */
export declare function armTrustRegion(radius0?: number): Arm;
/** Maximin space-filler — propose the point FARTHEST from every prior experiment. Pure global coverage;
 * measured to materially help on rugged/multimodal surfaces (finds un-sampled basins the others miss). */
export declare function armMaximin(pool?: number): Arm;
/** Basin-hopping — restart from a fresh random anchor every few calls, then refine locally around it.
 * Escapes the global-best trap by deliberately exploring OTHER basins of a multimodal surface. */
export declare function armBasinHop(restartEvery?: number, radius?: number): Arm;
/** Differential Evolution arm — DE/rand/1: combine three past experiments (a + F·(b−c)) + crossover with
 * the best. A population-based global optimiser that is strong on rugged/multimodal surfaces. */
export declare function armDiffEvolution(F?: number, CR?: number): Arm;
/** The production portfolio. Curated by MEASURED robustness (see bench.robustnessBench): the strong
 * convergers (gp, cmaes, kernel-ucb) + a local refiner (trust-region) + escape/diversity (anneal, random).
 * resonance stays available as an arm but is not in the default set (measured weakest; keep the bandit lean). */
export declare function defaultArms(): Arm[];
export declare function allArms(): Arm[];
export declare function armsGauntlet(): {
    score: 0 | 100;
    checks: Array<{
        name: string;
        pass: boolean;
        detail: string;
    }>;
};
//# sourceMappingURL=arms.d.ts.map