@tangle-network/agent-eval 0.123.1 → 0.123.3

package/dist/campaign/index.d.ts

@@ -81,9 +81,16 @@ interface CostReceiptInput extends CostUsage {
     costUnknown?: boolean;
     usageUnknown?: boolean;
 }
+/** Per-million token rates for a model or endpoint not covered by package pricing. */
+interface CustomTokenPricing {
+    inputUsdPerMillion: number;
+    outputUsdPerMillion: number;
+}
 type MaximumCharge = {
     externallyEnforcedMaximumUsd: number;
 } | ({
+    customTokenPricing: CustomTokenPricing;
+} & Pick<CostUsage, 'inputTokens' | 'outputTokens'>) | ({
     model: string;
 } & CostUsage);
 interface RunPaidCallInput<T> {
@@ -95,7 +102,7 @@ interface RunPaidCallInput<T> {
     model?: string;
     tags?: Record<string, string>;
     signal?: AbortSignal;
-    /** Provider-enforced dollar maximum, or maximum priced token usage. Required when capped. */
+    /** Provider-enforced dollar maximum, or maximum token usage with known pricing. Required when capped. */
     maximumCharge?: MaximumCharge;
     /** `callId` can be forwarded as the provider's idempotency key. */
     execute(signal: AbortSignal, callId: string): Promise<T>;
@@ -517,9 +524,10 @@ interface RunLineageResult {
 declare function runLineage(opts: RunLineageOptions): Promise<RunLineageResult>;
 
 type AgentProfileCellSchemaVersion = 'agent-profile-cell/v1';
-type AgentProfileJson = string | number | boolean | null | AgentProfileJson[] | {
+type AgentProfileJsonObject = {
     [key: string]: AgentProfileJson;
 };
+type AgentProfileJson = string | number | boolean | null | AgentProfileJson[] | AgentProfileJsonObject;
 type AgentProfileDimensionValue = string | number | boolean | null;
 interface AgentProfileSource {
     /** Runtime/profile contract being fingerprinted, e.g. `agent-interface-profile`. */
@@ -1134,8 +1142,8 @@ interface LlmCallResult {
     content: string;
     usage: LlmUsage;
     /**
-     * Cost in USD. Pulled from proxy's `_response_cost` field when present;
-     * `null` when neither the proxy nor the caller can derive it.
+     * Cost in USD. Uses the provider's reported cost when present, otherwise
+     * caller-supplied token pricing. `null` when neither is available.
      */
     costUsd: number | null;
     /** Model name actually used (echoed from response). */
@@ -1194,6 +1202,21 @@ interface LlmClientOptions {
     deadlineMs?: number;
     /** Total provider attempts. Legacy option name; default 3 (1 initial + 2 retries). */
     maxRetries?: number;
+    /** Token rates used when the provider omits cost or package pricing does not cover the model. */
+    customTokenPricing?: CustomTokenPricing;
+    /**
+     * Transport for requests that declare `jsonSchema`. `native` sends
+     * `response_format: json_schema`; `json-object` sends the broadly supported
+     * JSON mode and relies on the caller to include the schema in model-visible
+     * instructions. Default: `native`.
+     */
+    jsonSchemaTransport?: 'native' | 'json-object';
+    /**
+     * JSON payload parsing policy. `extract` accepts fenced or prose-prefixed JSON.
+     * `exact` requires the complete response content to be one JSON value.
+     * Default: `extract`.
+     */
+    jsonPayloadMode?: 'extract' | 'exact';
     /** Fetch implementation — defaults to global `fetch`. Override for custom transport (e.g. tests). */
     fetch?: typeof fetch;
     /**
@@ -2366,35 +2389,18 @@ interface AnalyzeTracesOptions {
 }
 
 /**
- * Make the trace-analyst's OWN prompt a GEPA-optimizable surface.
- *
- * The analyst that drives self-improvement is itself a prompt — and a
- * hand-tuned one (a hardcoded, hand-versioned `const`). This module lets the
- * loop optimize it: the analyst `actorDescription` becomes a `MutableSurface`
- * that `gepaProposer` / `haloProposer` / any `SurfaceProposer` can mutate inside
- * `runImprovementLoop` or `compareProposers`. That is the second-order loop —
- * optimizing the optimizer's eyes, not just the agent's prompt.
+ * Treat the trace analyst's instructions as an optimizable text surface.
  *
- * Two pieces, both deliberately small (the loop engine already exists — this
- * only supplies the analyst-shaped dispatch + an objective scorer):
+ * `buildAnalystSurfaceDispatch` analyzes a fixed trace corpus using the
+ * supplied surface as `actorDescription`. `failureModeRecallJudge` scores the
+ * findings against failure labels derived independently from the analyst output.
  *
- *  - `buildAnalystSurfaceDispatch` — `dispatchWithSurface(surface, scenario)`
- *    runs `analyzeTraces` with `surface` as the actorDescription over the
- *    scenario's fixed trace corpus, returning its findings.
- *  - `failureModeRecallJudge` — a DETERMINISTIC judge (no LLM, no opinion)
- *    that scores those findings against the scenario's GROUND-TRUTH failure
- *    modes. This is what keeps optimizing the analyst prompt ungameable: the
- *    labels come from objective signal (e.g. AppWorld `world.evaluate()` tells
- *    us which task failed and which API calls were wrong), so we reward an
- *    analyst for surfacing the failures that really happened — not for
- *    pleasing a judge that could be talked into anything (Goodhart).
- *
- * Wiring (the loop is unchanged; you only pass these in):
+ * Example:
  *
  *   const dispatchWithSurface = buildAnalystSurfaceDispatch({ analystOptions: { ai } })
  *   await runImprovementLoop({
- *     baselineSurface: TRACE_ANALYST_ACTOR_DESCRIPTION,  // the prompt under optimization
- *     scenarios: trainScenarios,                          // labeled trace corpora
+ *     baselineSurface: TRACE_ANALYST_ACTOR_DESCRIPTION,
+ *     scenarios: trainScenarios,
  *     holdoutScenarios: heldOutScenarios,
  *     dispatchWithSurface,
  *     judges: [failureModeRecallJudge()],
@@ -4188,6 +4194,152 @@ interface ParameterSweepProposerOptions {
 /** Config/parameter-level proposer for FAPO's middle escalation level. */
 declare function parameterSweepProposer(opts: ParameterSweepProposerOptions): SurfaceProposer;
 
+/**
+ * Compare optimization methods on shared train, selection, and test data.
+ * Optimizers receive only train and selection data. After every optimizer
+ * finishes, their selected surfaces are measured on the same untouched test
+ * data and compared with paired confidence intervals.
+ */
+
+/** Per-method campaign settings. Each method receives its own spend account. */
+type OptimizationMethodRunOptions<TScenario extends Scenario, TArtifact> = Omit<RunCampaignOptions<TScenario, TArtifact>, 'costLedger' | 'dispatch' | 'judges' | 'runDir' | 'scenarios' | 'seed'>;
+/** Cost reported by a method or by final test scoring. */
+interface ComparisonCost {
+    totalCostUsd: number;
+    accountingComplete: boolean;
+    incompleteReasons: string[];
+}
+/** Shared inputs for one optimization method. Final test data is absent. */
+interface OptimizationMethodInput<TScenario extends Scenario, TArtifact> {
+    /** Surface every method starts from. */
+    readonly baselineSurface: MutableSurface;
+    /** Evidence used to author or fit candidates. */
+    readonly trainScenarios: readonly TScenario[];
+    /** Data used for candidate acceptance, early stopping, and model selection. */
+    readonly selectionScenarios: readonly TScenario[];
+    /** Runs one scenario with a candidate surface. */
+    readonly dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+    /** Scores artifacts produced by `dispatchWithSurface`. */
+    readonly judges: readonly JudgeConfig<TArtifact, TScenario>[];
+    /** Method-specific artifacts are written below this directory. */
+    readonly runDir: string;
+    readonly seed: number;
+    /** Shared defaults for every method. A method may override them explicitly. */
+    readonly runOptions: Readonly<OptimizationMethodRunOptions<TScenario, TArtifact>>;
+}
+interface OptimizationMethodResult {
+    /** Surface selected without using the final test partition. */
+    winnerSurface: MutableSurface;
+    /** Optimization spend. Excludes final test scoring. */
+    cost: ComparisonCost;
+    /** Optimization duration. Excludes final test scoring. */
+    durationMs?: number;
+}
+/** A complete optimization method, including candidate generation and selection. */
+interface OptimizationMethod<TScenario extends Scenario = Scenario, TArtifact = unknown> {
+    /** Unique, trimmed display name. Its normalized form must also be unique. */
+    name: string;
+    optimize: (input: OptimizationMethodInput<TScenario, TArtifact>) => Promise<OptimizationMethodResult>;
+}
+interface OptimizationMethodScore {
+    name: string;
+    /** Mean final-test composite of the baseline (identical across methods). */
+    baselineComposite: number;
+    /** Mean final-test composite of this method's selected surface. */
+    winnerComposite: number;
+    /** Mean per-scenario final-test lift (winner minus baseline). */
+    lift: number;
+    /** Simultaneous paired-bootstrap interval for per-scenario lift.
+     *  `low > 0` excludes zero after adjustment for all reported contrasts. */
+    liftCi: {
+        low: number;
+        high: number;
+    };
+    /** Optimization spend reported by the method. Excludes final test scoring. */
+    optimizationCost: ComparisonCost;
+    /** Optimization duration reported by the method. Excludes final test scoring. */
+    durationMs?: number;
+    /** Paired final-test values used to compute lift and its interval. */
+    scenarioScores: Array<{
+        scenarioId: string;
+        baselineComposite: number;
+        winnerComposite: number;
+        lift: number;
+    }>;
+    winnerSurface: MutableSurface;
+    /** 1-based, by descending lift. */
+    rank: number;
+}
+interface OptimizationMethodPairwise {
+    /** Higher-ranked method. */
+    a: string;
+    b: string;
+    /** Mean per-scenario untouched-test delta (a − b). */
+    deltaMean: number;
+    low: number;
+    high: number;
+    /** `a` if the CI clears 0, `b` if it is entirely negative, else `'tie'`. */
+    favored: string;
+}
+interface OptimizationMethodComparison {
+    /** Sorted by descending lift; `rank` set accordingly. */
+    scores: OptimizationMethodScore[];
+    best: OptimizationMethodScore;
+    /** Best vs each other method, using simultaneous paired-bootstrap intervals. */
+    pairwise: OptimizationMethodPairwise[];
+    testScenarioIds: string[];
+    /** Sum of the costs reported by every optimization method. */
+    optimizationCost: ComparisonCost;
+    /** Baseline and distinct winner scoring on the final test partition. */
+    testCost: ComparisonCost;
+    /** Optimization plus final test scoring. */
+    totalCost: ComparisonCost;
+    /** Caller-requested simultaneous coverage across all reported contrasts. */
+    confidence: number;
+    /** Bonferroni-adjusted confidence used for each bootstrap interval. */
+    intervalConfidence: number;
+    /** Method-vs-baseline plus all possible method-vs-method contrasts. */
+    comparisonCount: number;
+    /** Deterministic bootstrap and campaign seed. */
+    seed: number;
+    /** Bootstrap draws used for each interval. */
+    resamples: number;
+    /** Agent runs averaged within each test scenario before resampling scenarios. */
+    reps: number;
+}
+interface CompareOptimizationMethodsOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'judges' | 'scenarios'> {
+    methods: OptimizationMethod<TScenario, TArtifact>[];
+    baselineSurface: MutableSurface;
+    /** Evidence used by every optimizer to author or fit candidates. */
+    trainScenarios: TScenario[];
+    /** Candidate acceptance, early-stopping, and optimizer-selection data. */
+    selectionScenarios: TScenario[];
+    /** Untouched final comparison data. Never passed to an optimization method. */
+    testScenarios: TScenario[];
+    /** Scores a surface on a scenario. The methods and final test share this function. */
+    dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+    judges: JudgeConfig<TArtifact, TScenario>[];
+    /** Bootstrap resamples for the lift intervals. Default is at least 2000 and
+     *  rises when the requested simultaneous confidence needs finer tails. */
+    resamples?: number;
+    /** Shared defaults for each method's train and selection campaigns. */
+    optimizationRunOptions?: OptimizationMethodRunOptions<TScenario, TArtifact>;
+    /** Number of optimization methods to run concurrently. Default 1. */
+    optimizationConcurrency?: number;
+    /** Simultaneous confidence across method-vs-baseline and method-vs-method contrasts.
+     *  Each bootstrap interval is Bonferroni-adjusted. Default 0.95. */
+    confidence?: number;
+    /** Shared spend limit across baseline and winner scoring on the final test partition.
+     *  Each method owns its optimization budget through `optimizationRunOptions.costCeiling`. */
+    costCeiling?: number;
+}
+/**
+ * Compare complete optimization methods on disjoint train, selection, and final test data.
+ */
+declare function compareOptimizationMethods<TScenario extends Scenario, TArtifact>(opts: CompareOptimizationMethodsOptions<TScenario, TArtifact>): Promise<OptimizationMethodComparison>;
+/** Keep the cost fields a custom optimization method must report. */
+declare function costFromLedgerSummary(summary: CostLedgerSummary): ComparisonCost;
+
 /**
  * `runOptimization` — the improvement loop body. Runs N generations: the
  * `SurfaceProposer` proposes K candidate surfaces per generation, each
@@ -4390,100 +4542,13 @@ interface RunImprovementLoopResult<TArtifact, TScenario extends Scenario> extend
  */
 declare function runImprovementLoop<TScenario extends Scenario, TArtifact>(opts: RunImprovementLoopOptions<TScenario, TArtifact>): Promise<RunImprovementLoopResult<TArtifact, TScenario>>;
 
-/**
- * `compareProposers` — a head-to-head lift benchmark across surface proposers
- * on ONE corpus. This is the forcing function: optimizer quality (GEPA
- * reflection vs GEPA+Pareto vs SkillOpt) becomes a NUMBER with a confidence
- * interval, so a proposer regression — or shipping a simplified proposer and
- * calling it the real one — turns a build red instead of going
- * measurement-invisible.
- *
- * Every entrant is scored the SAME way: each proposer returns the surface it
- * promoted, then the benchmark scores the baseline + every winner on the
- * SAME held-out scenarios with the SAME judges. Apples-to-apples by
- * construction — the comparison never depends on how a proposer measured itself.
- * The per-scenario held-out composites feed a paired bootstrap (`statistics.ts`)
- * for each proposer's lift CI and for the pairwise "which proposer wins" CI.
- */
-
-/** What an optimizer produced: the surface it promoted + what it cost to get
- *  there. The comparison does the held-out scoring itself, so an entry only
- *  needs to run its loop and hand back the winner. */
-interface ProposerEntry {
-    name: string;
-    optimize: () => Promise<{
-        winnerSurface: MutableSurface;
-        costUsd: number;
-        durationMs?: number;
-    }>;
-}
-interface ProposerScore {
-    name: string;
-    /** Mean held-out composite of the baseline (identical across proposers). */
-    baselineComposite: number;
-    /** Mean held-out composite of this proposer's promoted surface. */
-    winnerComposite: number;
-    /** Mean per-scenario held-out lift (winner − baseline). */
-    lift: number;
-    /** Paired-bootstrap CI of the per-scenario lift. `low > 0` ⇒ a real gain. */
-    liftCi: {
-        low: number;
-        high: number;
-    };
-    costUsd: number;
-    durationMs?: number;
-    winnerSurface: MutableSurface;
-    /** 1-based, by descending lift. */
-    rank: number;
-}
-interface ProposerPairwise {
-    /** Higher-ranked proposer. */
-    a: string;
-    b: string;
-    /** Mean per-scenario held-out delta (a − b). */
-    deltaMean: number;
-    low: number;
-    high: number;
-    /** `a` if the CI clears 0, `b` if it is entirely negative, else `'tie'`. */
-    favored: string;
-}
-interface ProposerComparison {
-    /** Sorted by descending lift; `rank` set accordingly. */
-    scores: ProposerScore[];
-    best: ProposerScore;
-    /** Best vs each other proposer, paired-bootstrap on the held-out winners. */
-    pairwise: ProposerPairwise[];
-    holdoutScenarioIds: string[];
-}
-interface CompareProposersOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'scenarios'> {
-    proposers: ProposerEntry[];
-    baselineSurface: MutableSurface;
-    /** The held-out scenarios every winner is scored on. */
-    holdoutScenarios: TScenario[];
-    /** Scores a surface on a scenario — the same dispatcher the proposers used. */
-    dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
-    /** Bootstrap resamples for the lift CIs. Default 2000. */
-    resamples?: number;
-    /** CI confidence. Default 0.95. */
-    confidence?: number;
-}
-/**
- * Run a head-to-head lift benchmark across surface proposers on a shared holdout, returning per-proposer lift CIs and pairwise "who wins" verdicts.
- */
-declare function compareProposers<TScenario extends Scenario, TArtifact>(opts: CompareProposersOptions<TScenario, TArtifact>): Promise<ProposerComparison>;
-/** Shared corpus + transport for the three built-in optimizer entries. */
-interface OptimizerEntryConfig<TScenario extends Scenario, TArtifact> {
-    baselineSurface: string;
-    /** Training scenarios the proposers reflect on. */
-    trainScenarios: TScenario[];
-    /** Held-out scenarios (the gate axis + the benchmark scoring axis). */
-    holdoutScenarios: TScenario[];
-    dispatchWithSurface: (surface: MutableSurface, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
-    judges: JudgeConfig<TArtifact, TScenario>[];
+interface BuiltinOptimizationMethodConfig<TScenario extends Scenario = Scenario, TArtifact = unknown> {
     llm: LlmClientOptions;
     model: string;
     target: string;
-    runDir: string;
+    /** Override shared method-run settings for this method only. */
+    runOptions?: OptimizationMethodRunOptions<TScenario, TArtifact>;
+    /** Override the comparison seed for this method only. */
     seed?: number;
     /** GEPA population per generation. Default 2. */
     populationSize?: number;
@@ -4492,51 +4557,33 @@ interface OptimizerEntryConfig<TScenario extends Scenario, TArtifact> {
     /** SkillOpt epochs. Default 6. */
     maxEpochs?: number;
     mutationPrimitives?: string[];
-    /** Static findings seed forwarded to each GEPA proposer's `propose()` as
-     *  `ctx.findings`. Forwarded by `gepaReflectionEntry` / `gepaParetoEntry`;
-     *  `skillOptEntry` runs without findings (see its doc). */
+    /** Static findings passed to each GEPA candidate-generation call. */
     findings?: unknown[];
-    /** Per-generation findings producer: after each generation scores, this
-     *  re-diagnoses and REPLACES `ctx.findings` for the
-     *  next generation's `propose()`. Reuses the `runOptimization` field type so
-     *  it cannot drift. GEPA entries only. */
+    /** Recompute findings after each GEPA generation. */
     analyzeGeneration?: RunImprovementLoopOptions<TScenario, TArtifact>['analyzeGeneration'];
-    /** Optional analysis report forwarded to `propose()` as `ctx.report`. */
+    /** Optional analysis report passed to candidate generation. */
     report?: unknown;
 }
 /** GEPA, reflection-only (single-parent, no Pareto combine). */
-declare function gepaReflectionEntry<TScenario extends Scenario, TArtifact>(config: OptimizerEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
-/** GEPA with the Pareto frontier + combine-complementary-lessons. */
-declare function gepaParetoEntry<TScenario extends Scenario, TArtifact>(config: OptimizerEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
-/** SkillOpt patch-mode hill-climb. Runs findings-BLIND: `runSkillOpt` owns its
- *  own epoch acceptance/budget loop and does not thread `analyzeGeneration`, so
- *  `config.findings` is intentionally NOT forwarded here. In a findings-fed
- *  comparison this entry is the blind control — do not read its result as
- *  findings-fed. (Threading findings into the SkillOpt epoch loop is a separate
- *  refactor, deferred not faked.) */
-declare function skillOptEntry<TScenario extends Scenario, TArtifact>(config: OptimizerEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
-/** FAPO reviewed-escalation policy. This is an orchestration layer over
- * level-specific proposers, not a new mutation operator:
- * prompt -> parameter -> structural, with scope + reviewer + plateau rules in
- * `fapoProposer`. The prompt proposer defaults to GEPA+Pareto because that is
- * the package's strongest prompt-tier proposer; parameter/structural proposers
- * are opt-in so we do not fake code-generation inside agent-eval. */
-interface FapoEntryConfig<TScenario extends Scenario, TArtifact> extends OptimizerEntryConfig<TScenario, TArtifact> {
-    /** Override the prompt-level proposer. Default: `gepaProposer({ combineParents: true })`. */
+declare function gepaReflectionMethod<TScenario extends Scenario, TArtifact>(config: BuiltinOptimizationMethodConfig<TScenario, TArtifact>, name?: string): OptimizationMethod<TScenario, TArtifact>;
+/** GEPA with the Pareto frontier and complementary-parent combination. */
+declare function gepaParetoMethod<TScenario extends Scenario, TArtifact>(config: BuiltinOptimizationMethodConfig<TScenario, TArtifact>, name?: string): OptimizationMethod<TScenario, TArtifact>;
+/** SkillOpt patch-mode hill climb. */
+declare function skillOptMethod<TScenario extends Scenario, TArtifact>(config: BuiltinOptimizationMethodConfig<TScenario, TArtifact>, name?: string): OptimizationMethod<TScenario, TArtifact>;
+interface FapoOptimizationMethodConfig<TScenario extends Scenario, TArtifact> extends BuiltinOptimizationMethodConfig<TScenario, TArtifact> {
+    /** Override the prompt-level proposer. Default: GEPA with Pareto parents. */
     promptProposer?: SurfaceProposer;
     /** Parameter/config-level proposer. If omitted, `parameterCandidates` builds one. */
     parameterProposer?: SurfaceProposer;
     /** Structural/code-level proposer, typically supplied by agent-runtime. */
     structuralProposer?: SurfaceProposer;
-    /** Convenience: build a `parameterSweepProposer` from these candidates. */
+    /** Convenience: build a parameter sweep from these candidates. */
     parameterCandidates?: readonly ParameterCandidate[];
-    /** FAPO policy knobs: scope, reviewer, plateau thresholds. */
+    /** FAPO policy settings: scope, reviewer, and plateau thresholds. */
     fapo?: Omit<FapoProposerOptions, 'proposers' | 'promptProposer' | 'parameterProposer' | 'structuralProposer'>;
 }
-/**
- * Build a `ProposerEntry` that runs the full FAPO escalation policy (prompt → parameter → structural) as a single comparable optimizer entry.
- */
-declare function fapoEscalationEntry<TScenario extends Scenario, TArtifact>(config: FapoEntryConfig<TScenario, TArtifact>, name?: string): ProposerEntry;
+/** Build one method that runs the complete FAPO escalation policy. */
+declare function fapoEscalationMethod<TScenario extends Scenario, TArtifact>(config: FapoOptimizationMethodConfig<TScenario, TArtifact>, name?: string): OptimizationMethod<TScenario, TArtifact>;
 
 /**
  * Artifact validators.
@@ -5278,17 +5325,17 @@ declare function patchEditCount(patch: SkillPatch): number;
  * meta-note steer the optimizer away from dead ends.
  *
  * This module is the PROPOSER — the LLM call that turns evidence into
- * structured patches. The accept-only-if-held-out-improves loop, the budget
+ * structured patches. The accept-only-if-selection-improves loop, the budget
  * annealing, and the rejected buffer live in the `runSkillOpt` preset, which
  * owns the epoch hill-climb. The proposer also conforms to `SurfaceProposer`
  * (`propose` applies its patches to the current surface and returns the
  * candidate surfaces) so it is a drop-in for `runOptimization` and a fair
- * entrant in `compareProposers`.
+ * entrant in `compareOptimizationMethods`.
  */
 
 /** Evidence the optimizer reflects on: where the current surface is weakest.
  *  Computed by the caller (the preset uses a TRAIN campaign so proposals never
- *  see the held-out split; the generic loop derives it from history). */
+ *  see the selection split; the generic loop derives it from history). */
 interface SkillOptEvidence {
     /** Lowest-scoring scenarios (drives WHICH behavior to patch). */
     weakScenarios: Array<{
@@ -5365,28 +5412,14 @@ declare class SkillPatchParseError extends Error {
 declare function parseSkillPatchResponse(raw: string, maxPatches: number, editBudget: number): SkillPatch[];
 
 /**
- * `runSkillOpt` — the SkillOpt epoch hill-climb (Microsoft, arXiv:2605.23904).
- * Unlike `runOptimization`'s population search around one global incumbent,
- * SkillOpt is a sequential, held-out-gated hill-climb on ONE skill document:
- *
- *   each epoch:
- *     1. reflect on the CURRENT surface's weakest TRAIN scenarios/dimensions
- *        (never the held-out split — proposals must not see the acceptance axis)
- *     2. propose ≤ `patchesPerEpoch` bounded patches (≤ `editBudget` ops each)
- *     3. apply each; score the candidate on the HELD-OUT split
- *     4. ACCEPT the first patch that STRICTLY improves the held-out composite;
- *        otherwise push it to the rejected-edit buffer (fed back so the model
- *        does not re-propose dead ends)
- *     5. anneal the edit budget down after consecutive rejections (the
- *        "textual learning rate" decay); refresh the slow-update meta note
- *     6. stop at `maxEpochs` or after `patience` epochs with no acceptance
+ * Optimize one skill document with the repeated selection method from SkillOpt
+ * (Microsoft, arXiv:2605.23904).
  *
- * The accept-only-if-held-out-improves rule is the same discipline as
- * `HeldOutGate`/`defaultProductionGate`, applied per edit instead of once at
- * the end — which is why the held-out composite is monotonically
- * non-decreasing and a regression can never ship. `runCampaign` is the
- * measurement; `applySkillPatch` applies the edits; `skillOptProposer` proposes
- * them.
+ * Each round proposes bounded patches from item-level training evidence, then
+ * accepts the first patch that improves the selection score. Later rounds see
+ * aggregate acceptance feedback and prior rejected edits, so selection data is
+ * adaptively reused. It is not a final test. Use `compareOptimizationMethods` when you
+ * need a separate test partition.
  */
 
 interface RunSkillOptOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'scenarios'> {
@@ -5395,18 +5428,17 @@ interface RunSkillOptOptions<TScenario extends Scenario, TArtifact> extends Omit
     /** Dispatcher taking the CURRENT skill surface + scenario → artifact. */
     dispatchWithSurface: (surface: string, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
     proposer: SkillOptProposer;
-    /** Scenarios the optimizer reflects on for evidence. MUST be disjoint from
-     *  `holdoutScenarios` — proposals never see the acceptance axis. */
+    /** Item-level evidence shown to the proposer. Must be disjoint from selection. */
     trainScenarios: TScenario[];
-    /** Held-out scenarios. An edit is accepted ONLY if it strictly improves the
-     *  mean composite here. */
-    holdoutScenarios: TScenario[];
+    /** Adaptively reused candidate-selection scenarios. An edit is accepted ONLY
+     *  if it strictly improves the mean composite here. This is not a final test. */
+    selectionScenarios: TScenario[];
     maxEpochs: number;
     /** Candidate patches proposed per epoch. Default 2. */
     patchesPerEpoch?: number;
     /** Initial ops-per-patch cap (the textual learning rate). Default 3. */
     editBudget?: number;
-    /** Strict acceptance margin: accept iff the held-out composite improves by
+    /** Strict acceptance margin: accept iff the selection composite improves by
      *  MORE than this. Default 0 (any strict improvement). */
     minImprovement?: number;
     /** Stop after this many consecutive epochs with no acceptance. Default =
@@ -5428,8 +5460,8 @@ interface AcceptedEdit {
     epoch: number;
     label: string;
     rationale: string;
-    /** Held-out composite improvement vs the surface before this edit. */
-    holdoutDelta: number;
+    /** Selection composite improvement vs the surface before this edit. */
+    selectionDelta: number;
 }
 interface SkillOptEpochRecord {
     epoch: number;
@@ -5438,28 +5470,27 @@ interface SkillOptEpochRecord {
     /** The accepted edit this epoch, or null if every proposal was rejected. */
     accepted: AcceptedEdit | null;
     rejected: RejectedEdit[];
-    /** Held-out composite of the CURRENT surface at the END of the epoch. */
-    holdoutComposite: number;
+    /** Selection composite of the CURRENT surface at the END of the epoch. */
+    selectionComposite: number;
 }
 interface RunSkillOptResult {
     winnerSurface: string;
-    baselineHoldoutComposite: number;
-    winnerHoldoutComposite: number;
-    /** `winnerHoldoutComposite - baselineHoldoutComposite` — monotonically ≥ 0
-     *  by construction (only strictly-improving edits are accepted). */
-    lift: number;
+    baselineSelectionComposite: number;
+    winnerSelectionComposite: number;
+    /** `winnerSelectionComposite - baselineSelectionComposite`. This is not test lift. */
+    selectionLift: number;
     acceptedEdits: AcceptedEdit[];
     rejectedEdits: RejectedEdit[];
     epochsRun: number;
     history: SkillOptEpochRecord[];
-    /** Total cost across every scoring campaign (train evidence + holdout
-     *  acceptance) the hill-climb ran. */
+    /** Full run spend. Alias of `cost.totalCostUsd`; includes scoring, proposals,
+     *  and judges. */
     totalCostUsd: number;
     /** Run-wide spend, including scoring, proposals, and judges. */
     cost: CostLedgerSummary;
 }
 /**
- * SkillOpt sequential hill-climb: each epoch reflects on train-scenario weaknesses, proposes bounded patches, accepts the first patch that strictly improves the held-out composite, and anneals the edit budget on consecutive rejections.
+ * SkillOpt sequential hill-climb: each epoch reflects on train-scenario weaknesses, proposes bounded patches, accepts the first patch that strictly improves the selection composite, and anneals the edit budget on consecutive rejections.
  */
 declare function runSkillOpt<TScenario extends Scenario, TArtifact>(opts: RunSkillOptOptions<TScenario, TArtifact>): Promise<RunSkillOptResult>;
 
@@ -5500,36 +5531,11 @@ interface AceProposerOptions {
 declare function aceProposer(opts?: AceProposerOptions): SurfaceProposer;
 
 /**
- * `compositeProposer` — run N proposers TOGETHER on the same surface.
- *
- * The question this answers ("why can't we combine GEPA + skillOpt + ACE + a
- * trace-analyst?"): nothing in the loop cares where candidates come from — the
- * generation's population is one pool and the Pareto frontier / promotion logic
- * evaluates every candidate identically. The only missing piece was a proposer
- * that fans the population budget out across members and merges their proposals.
- * This is that piece.
- *
- * Semantics:
- *   - Budget: each member is asked for a share of `populationSize`
- *     (near-equal split by default, or explicit `weights`). Members may return
- *     fewer; the pool is topped up round-robin from members that can offer more
- *     is NOT attempted — proposers are not obligated to be re-entrant.
- *   - Provenance: every candidate's `label` is prefixed with its member's kind
- *     (`gepa:...`, `skill-opt:...`) so generation records and the promotion
- *     provenance attribute each winner to the proposer family that made it —
- *     the cheap, honest version of proposer-level credit assignment.
- *   - Dedup: identical surfaces from different members collapse to the first.
- *   - Failure isolation: one member throwing does not sink the generation; its
- *     error is logged into the surviving candidates' generation via a warning
- *     and the pool proceeds (a generation with zero candidates from all members
- *     failing still throws — that is a real failure).
- *   - Early stop: the composite stops only when EVERY member with a `decide`
- *     votes stop (a member without `decide` never votes stop).
- *
- * This is deliberately NOT joint multi-surface mutation: every member mutates
- * the SAME `MutableSurface`. Joint profile-patch surfaces (prompt+skills+tools
- * in one candidate) require the composite-surface contract and measured
- * component attribution — see the experiment-optimal research brief.
+ * Split one generation's candidate budget across independent proposers.
+ * Candidate labels retain the originating proposer kind, duplicate surfaces
+ * collapse to the first result, and one failed proposer does not discard the
+ * other results. The composite stops only when every member with `decide`
+ * votes to stop.
  */
 
 interface CompositeProposerOptions<TFindings = unknown> {
@@ -5658,20 +5664,11 @@ declare function extractH2Sections(text: string): string[];
 declare function countSentenceEdits(baseline: string, candidate: string): number;
 
 /**
- * `haloProposer` — wraps the REAL halo-engine (Inference.net's hierarchical
- * agentic trace analyzer, `pip install halo-engine`, repo context-labs/halo)
- * as an agent-eval `SurfaceProposer`, so HALO competes head-to-head with
- * `gepaProposer` — and with our own `traceAnalystProposer` — inside `compareProposers`
- * on identical traces / scenarios / held-out scoring.
+ * Adapt the published `halo-engine` CLI to `SurfaceProposer`.
  *
- * It PRESERVES halo's actual working usage — `analyze` shells out to the
- * published CLI (`halo <traces.jsonl> -p <prompt> -m <model>`) and uses its real
- * RLM findings verbatim. We do NOT reimplement its analysis; that would make the
- * benchmark meaningless. The materialize/apply pipeline is the shared
- * `analysisEditProposer` — identical to `traceAnalystProposer`, which is what makes
- * the comparison apples-to-apples.
- *
- * Fail-loud: no traces → throw; halo errors → throw; empty findings → throw.
+ * The proposer runs `halo <traces.jsonl> -p <prompt> -m <model>` and passes its
+ * findings to the shared edit step also used by `traceAnalystProposer`. It
+ * rejects missing traces, CLI errors, and empty findings.
  */
 
 interface HaloProposerOptions {
@@ -5829,7 +5826,7 @@ interface LlmPolicyEditProposerOptions {
     targetSurface: JsonPolicyEditTargetSurface;
     /** Exact JSON paths the author may change. Prefix or fuzzy matches are not accepted. */
     allowedJsonPaths: readonly string[];
-    /** Exact search objectives forecasts may name. Unknown keys or mismatched directions fail. */
+    /** Caller-owned search objective bound into every authored forecast. */
     objectives: readonly PolicyEditObjective[];
     /** Default: evidence-only, so uncertain edits are measured rather than
      *  suppressed by their own model-authored predictions. */
@@ -5852,6 +5849,13 @@ interface LlmPolicyEditProposerOptions {
     maxAuthorContextChars?: number;
     /** Optional one-to-one pseudonymizer applied to every author-visible evidence field. */
     scenarioIdTransform?: (scenarioId: string) => string;
+    /**
+     * Remove credentials or unrelated fields from the current surface before it
+     * is sent to the model. The callback receives a clone and must preserve every
+     * editable path unchanged. Validated edits apply to the complete original.
+     * This callback does not redact findings or scored history.
+     */
+    redactCurrentSurfaceForModel?: (surface: AgentProfileJsonObject) => AgentProfileJsonObject;
     onAdmission?: (admission: PolicyEditAdmission) => void;
 }
 /**
@@ -6176,23 +6180,29 @@ interface RegistryRunOpts {
 }
 
 /**
- * `traceAnalystProposer` — wraps agent-eval's OWN trace-analyst engine
- * (`AnalystRegistry` over the agentic OTLP reader) as a `SurfaceProposer`.
- * It is the symmetric opponent to `haloProposer`: both run the SAME shared
- * `analysisEditProposer` pipeline (materialize identical traces → apply via one
- * identical LLM edit), so a `compareProposers` lift delta isolates a single
- * variable — ANALYSIS QUALITY. The benchmark answers "is our HALO clone as good
- * as the real HALO?" as a held-out lift CI, not a vibe.
- *
- * Findings come from the REGISTRY (structured `AnalystFinding[]` carrying
- * area / severity / recommended_action), rendered into the report the shared
- * apply step consumes.
+ * Adapt the built-in analyst registry to `SurfaceProposer`.
  *
- * Fail-loud: no traces → throw; analyst run errors → throw; zero findings →
- * throw. Never fabricate a candidate.
+ * The proposer produces structured findings from OTLP traces, then uses the
+ * same edit step as `haloProposer`. It rejects missing traces, analysis errors,
+ * and empty findings instead of returning a fabricated candidate.
  */
 
 type TraceAnalystPriorFindings = NonNullable<RegistryRunOpts['priorFindings']>;
+interface AnalyzeOtlpTraceFileOptions {
+    tracePath: string;
+    runId: string;
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+    provider?: AxAIArgs<unknown>['name'];
+    kinds?: readonly TraceAnalystKindSpec[];
+    signal?: AbortSignal;
+    costLedger?: CostLedgerHandle;
+    costPhase?: string;
+    priorFindings?: TraceAnalystPriorFindings;
+}
+/** Run the built-in analyst registry against one OTLP JSONL file. */
+declare function analyzeOtlpTraceFile(opts: AnalyzeOtlpTraceFileOptions): Promise<AnalystFinding[]>;
 interface TraceAnalystProposerOptions<TFindings = unknown> {
     /** OpenAI-compatible base URL for BOTH the analyst's agentic reads and the
      *  apply step (e.g. `https://api.deepseek.com/v1` or the Tangle router). */
@@ -6500,9 +6510,15 @@ interface InterRaterInsight {
     raters: number;
     /** Number of runs every rater scored. */
     jointlyRated: number;
-    /** Cohen's κ averaged across rater pairs. */
+    /** Multi-rater weighted kappa over the jointly rated runs. */
     kappa: number;
-    /** Pairwise κ per rater pair (key = `"raterA::raterB"`). */
+    /** Absolute agreement across raters, using ICC(2,1). */
+    icc: number;
+    /** Mean pairwise Pearson correlation. Correlation is not agreement. */
+    pearson: number;
+    /** Mean pairwise Spearman rank correlation. */
+    spearman: number;
+    /** Pairwise weighted kappa per rater pair (key = `"raterA::raterB"`). */
     perPair: Record<string, number>;
     /** Run ids where raters disagree the most — the high-value triage list. */
     disagreementCases: Array<{
@@ -7138,7 +7154,7 @@ declare function selectDiscriminative(signals: ScenarioSignal[], k: number, opts
 
 /**
  * Shared campaign-score reductions used by every optimizer preset
- * (`runOptimization`, `runSkillOpt`, `compareProposers`). ONE definition of
+ * (`runOptimization`, `runSkillOpt`, `compareOptimizationMethods`). ONE definition of
  * "composite of a campaign" and "per-scenario / per-dimension breakdown" so
  * the optimizers cannot drift on how a surface's score is computed.
  */
@@ -7662,4 +7678,4 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 
-export { type AcceptedEdit, type AceProposerOptions, type AnalystArtifact, type AnalystScenario, type AnalyzeCrossSurfaceInteractionsInput, type ApplySkillPatchResult, type AxisEvidence, type AxisVerdict, type BuildAnalystSurfaceDispatchOptions, type BuildEvidenceVectorOptions, type BuildLoopProvenanceArgs, type CampaignAggregates, type CampaignArtifactWriter, type CampaignBreakdown, type CampaignCellResult, type CampaignCostMeter, type CampaignResult, type CampaignRunPlan, type CampaignRunPlanCell, type CampaignScenarioIdentity, type CampaignStorage, type CampaignTokenUsage, type CampaignTraceWriter, type CodeSurface, type CodeSurfaceVerification, type CompareProposersOptions, type CompositeProposerOptions, type CostLedgerHandle, type CrossSurfaceAdditionDecision, type CrossSurfaceAdditionRejectionReason, type CrossSurfaceAttemptCompleteness, type CrossSurfaceBestSingleSelection, type CrossSurfaceBootstrapPolicy, type CrossSurfaceCandidate, type CrossSurfaceCandidateComparison, type CrossSurfaceCandidateEvidence, type CrossSurfaceCandidateOutcome, type CrossSurfaceCandidateSummary, type CrossSurfaceComponent, type CrossSurfaceComponentEvidence, type CrossSurfaceCompositionStep, type CrossSurfaceDistribution, type CrossSurfaceEligibility, type CrossSurfaceEvidenceBreakdown, type CrossSurfaceIneligibilityReason, type CrossSurfaceInteractionAwareSelection, type CrossSurfaceInteractionEffect, type CrossSurfaceInteractionPath, type CrossSurfaceInteractionReport, type CrossSurfaceInteractionTask, type CrossSurfaceNaiveStackSelection, type CrossSurfacePairCompatibility, type CrossSurfacePairEvidence, type CrossSurfacePairIncompatibilityReason, type CrossSurfacePairwiseEntry, type CrossSurfaceRankedSingle, type CrossSurfaceRelativeCost, type CrossSurfaceSelectionPolicy, type CrossSurfaceSelections, type CrossSurfaceTaskRow, DEFAULT_POLICY_EDIT_HISTORY_LIMITS, type DefaultProductionGateOptions, type DimensionRegression, type DiscriminationScore, type DispatchContext, type DispatchFn, type EmitLoopProvenanceArgs, type EmitLoopProvenanceResult, type EvalFixture, type EvalFixtureFile, type EvalFixtureLoadOptions, type EvalFixtureRunPlan, type EvalFixtureScenario, type EvalFixtureValidationMode, type EvidenceVector, type EvolutionaryProposerOptions, type FailureModeRecallJudgeOptions, type FapoAttributionSignals, type FapoEntryConfig, type FapoFailureCluster, type FapoOptimizationLevel, type FapoProposerOptions, type FapoReviewInput, type FapoReviewIssue, type FapoReviewResult, type FapoScopeContract, FileSearchLedger, FsLabeledScenarioStore, type FsLabeledScenarioStoreOptions, type Gate, type GateContext, type GateDecision, type GateResult, type GenerationCandidate, type GenerationRecord, type GepaProposerConstraints, type GepaProposerOptions, type GitWorktreeAdapterOptions, type Governor, type GovernorContext, type GovernorOp, type HaloProposerOptions, type HeldOutGateOptions, type HeldoutSignificance, type HeldoutSignificanceOptions, type HeuristicGovernorOptions, type JsonPolicyEditTargetSurface, type JsonPrimitive, type JsonValue, type JudgeAggregate, type JudgeConfig, type JudgeDimension, type JudgeScore, type LabelTrust, type LabeledScenarioRecord, type LabeledScenarioSampleArgs, type LabeledScenarioSource, type LabeledScenarioStore, LabeledScenarioStoreError, type LabeledScenarioWrite, Lineage, type LineageEdge, type LineageGraph, type LineageNode, type LineageNodeInput, type LineageStore, LineageStoreConflictError, type LlmJudgeDimension, type LlmJudgeOptions, type LlmPolicyEditProposerOptions, type LoadEvalFixtureScenariosOptions, type LoopProvenanceArgsFromResult, type LoopProvenanceBackend, type LoopProvenanceCandidate, type LoopProvenanceEvidence, type LoopProvenanceRecord, type MemoryCurationProposerOptions, type MutableSurface, type Mutator, type NeutralizationGateOptions, type ObjectiveSource, type OpenAutoPrOptions, type OpenAutoPrResult, type OpenSearchLedgerOptions, type OptimizationProposer, type OptimizerConfig, type OptimizerEntryConfig, POLICY_EDIT_CANDIDATE_RECORD_SCHEMA, type PairedHoldout, type ParameterCandidate, type ParameterChange, type ParameterSweepProposerOptions, type ParetoParent, type ParetoSignificanceGateOptions, type PendingCostCallView, type PlanCampaignRunOptions, type PlanEvalFixtureRunOptions, type PlaybackContext, type PlaybackDriver, type PlaybackStep, type PolicyEditAuthorScenarioRow, type PolicyEditCandidateRecord, type PolicyEditCandidateSummary, type PolicyEditFindingInput, type PolicyEditFindingSource, type PolicyEditHistoryCandidateContext, type PolicyEditHistoryGenerationContext, type PolicyEditHistoryProjectionOptions, type PolicyEditObjective, type PolicyEditOutcomeContext, type PolicyEditProposerOptions, type PowerPreflight, type PowerPreflightOptions, type PremeasuredOptimizationBaseline, type ProfileDispatchFn, ProfileMatrixError, type ProfileSummary, type PromotionObjective, type PromotionPolicy, type ProposalTrackContext, type ProposeContext, type ProposePatchesArgs, type ProposedCandidate, type ProposerComparison, type ProposerEntry, type ProposerPairwise, type ProposerScore, type RedactionStatus, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceScenario, type RejectedEdit, type RolloutArgumentDiff, type RolloutArgumentDiffOptions, type RolloutCall, type RunCampaignOptions, type RunEvalOptions, type RunImprovementLoopOptions, type RunImprovementLoopResult, type RunLineageLoopOptions, type RunLineageLoopResult, type RunLineageLoopSeed, type RunLineageOptions, type RunLineageResult, type RunLineageSeed, type RunLineageStepResult, type RunOptimizationOptions, type RunOptimizationResult, type RunProfileMatrixOptions, type RunProfileMatrixResult, type RunSkillOptOptions, type RunSkillOptResult, SEARCH_LEDGER_SCHEMA, type Scenario, type ScenarioAggregate, type ScenarioRollup, type ScenarioSignal, type ScoreboardRenderOptions, type ScoreboardRow, type ScoreboardSummary, type ScoredRollout, type ScoredSurfaceOutcome, type SearchAccountingAudit, type SearchArtifactRef, type SearchAttemptAccounting, type SearchCandidateDecidedEvent, type SearchCandidateLineage, type SearchCandidateRegisteredEvent, type SearchCandidateSlot, type SearchCandidateSlotClosedEvent, type SearchCandidateSurface, type SearchCompletedEvent, type SearchCostAccounting, type SearchFailureReason, type SearchLedger, type SearchLedgerAppendResult, SearchLedgerConflictError, type SearchLedgerEntry, SearchLedgerError, type SearchLedgerEvent, type SearchLedgerHash, SearchLedgerIntegrityError, type SearchLedgerReplay, type SearchModelIdentity, type SearchOperationKind, type SearchOperationRecordedEvent, type SearchPlan, type SearchPlannedEvent, type SearchPlannedOperation, type SearchPlannedTask, type SearchSourceRef, type SearchSurfaceEffect, type SearchSurfaceEvidence, type SearchSurfaceKind, type SearchTaskAttemptedEvent, type SearchTaskOutcome, type SearchTokenAccounting, type SelectPolicyEditAuthorRowsOptions, type SequentialDecideFn, type SequentialDecideOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SerializedJsonBudget, type SessionScript, type SingleRunLock, type SingleRunLockOptions, type SkillOptEpochRecord, type SkillOptEvidence, type SkillOptProposer, type SkillOptProposerOptions, type SkillPatch, type SkillPatchOp, SkillPatchParseError, type SkillPatchRejection, type SurfaceProposer, type SurfaceScore, type TraceAnalystPriorFindings, type TraceAnalystProposerOptions, type TraceSpan, type TransientFailureOptions, type UngroundedLiteralReport, type UserStory, type UserStoryVerdict, type Worktree, type WorktreeAdapter, WorktreeAdapterError, aceProposer, acquireSingleRunLock, analyzeCrossSurfaceInteractions, applySkillPatch, assertCampaignDesign, assertCampaignSplitIdentity, assertCodeSurfaceIdentity, assertPolicyEditAuthorContextBudget, buildAnalystSurfaceDispatch, buildEvidenceVector, buildLoopProvenanceRecord, callbackGovernor, campaignBreakdown, campaignLineageStore, campaignMeanComposite, campaignMeasurementDigest, campaignScenarioIdentity, campaignSplitDigest, campaignSplitDigestFromIdentities, canonicalDigest, classifyUngroundedLiterals, codeSurfaceIdentityMaterial, compareProposers, composeGate, compositeProposer, countSentenceEdits, createReferenceEquivalenceJudge, createRunCostLedger, defaultProductionGate, detectScale, dimensionRegressions, discoverEvalFixtures, emitLoopProvenance, evolutionaryProposer, extractFapoAttributionSignals, extractH2Sections, failureModeRecallJudge, fapoEscalationEntry, fapoProposer, fsCampaignStorage, fsLineageStore, gepaParetoEntry, gepaProposer, gepaReflectionEntry, gitWorktreeAdapter, haloProposer, heldOutGate, heldoutSignificance, heuristicGovernor, inMemoryCampaignStorage, isProposedCandidate, isTransientTransportFailure, labelTrustRank, lineageNodeId, llmJudge, llmPolicyEditProposer, loadEvalFixture, loadEvalFixtureScenarios, loopProvenanceArgsFromResult, loopProvenanceSpans, makePlaybackDispatch, memLineageStore, memoryCurationProposer, neutralizationGate, neutralizeText, openAutoPr, openSearchLedger, pairHoldout, parameterSweepProposer, paretoPolicy, paretoSignificanceGate, parseSkillPatchResponse, patchEditCount, planCampaignRun, planEvalFixtureRun, policyEditProposer, powerPreflight, projectPolicyEditHistory, provenanceRecordPath, provenanceSpansPath, renderScoreboardMarkdown, renderSurfaceDiff, resolveRunDir, resolveWorktreePath, rolloutArgumentDiff, runCampaign, runEval, runImprovementLoop, runLineage, runLineageLoop, runOptimization, runProfileMatrix, runSkillOpt, scoreDiscrimination, scoreUserStory, scoreboardSummary, selectDiscriminative, selectPolicyEditAuthorRows, sequentialDecide, sequentialPairedGate, skillOptEntry, skillOptProposer, surfaceContentHash, surfaceHash, tangleTracesRoot, traceAnalystProposer, userStoryScoreboard, validatePolicyEditCandidateRecord, validateSearchLedgerEvent, verifyCodeSurface, verifyLoopProvenanceRecord };
+export { type AcceptedEdit, type AceProposerOptions, type AnalystArtifact, type AnalystScenario, type AnalyzeCrossSurfaceInteractionsInput, type AnalyzeOtlpTraceFileOptions, type ApplySkillPatchResult, type AxisEvidence, type AxisVerdict, type BuildAnalystSurfaceDispatchOptions, type BuildEvidenceVectorOptions, type BuildLoopProvenanceArgs, type BuiltinOptimizationMethodConfig, type CampaignAggregates, type CampaignArtifactWriter, type CampaignBreakdown, type CampaignCellResult, type CampaignCostMeter, type CampaignResult, type CampaignRunPlan, type CampaignRunPlanCell, type CampaignScenarioIdentity, type CampaignStorage, type CampaignTokenUsage, type CampaignTraceWriter, type CodeSurface, type CodeSurfaceVerification, type CompareOptimizationMethodsOptions, type ComparisonCost, type CompositeProposerOptions, type CostLedgerHandle, type CrossSurfaceAdditionDecision, type CrossSurfaceAdditionRejectionReason, type CrossSurfaceAttemptCompleteness, type CrossSurfaceBestSingleSelection, type CrossSurfaceBootstrapPolicy, type CrossSurfaceCandidate, type CrossSurfaceCandidateComparison, type CrossSurfaceCandidateEvidence, type CrossSurfaceCandidateOutcome, type CrossSurfaceCandidateSummary, type CrossSurfaceComponent, type CrossSurfaceComponentEvidence, type CrossSurfaceCompositionStep, type CrossSurfaceDistribution, type CrossSurfaceEligibility, type CrossSurfaceEvidenceBreakdown, type CrossSurfaceIneligibilityReason, type CrossSurfaceInteractionAwareSelection, type CrossSurfaceInteractionEffect, type CrossSurfaceInteractionPath, type CrossSurfaceInteractionReport, type CrossSurfaceInteractionTask, type CrossSurfaceNaiveStackSelection, type CrossSurfacePairCompatibility, type CrossSurfacePairEvidence, type CrossSurfacePairIncompatibilityReason, type CrossSurfacePairwiseEntry, type CrossSurfaceRankedSingle, type CrossSurfaceRelativeCost, type CrossSurfaceSelectionPolicy, type CrossSurfaceSelections, type CrossSurfaceTaskRow, DEFAULT_POLICY_EDIT_HISTORY_LIMITS, type DefaultProductionGateOptions, type DimensionRegression, type DiscriminationScore, type DispatchContext, type DispatchFn, type EmitLoopProvenanceArgs, type EmitLoopProvenanceResult, type EvalFixture, type EvalFixtureFile, type EvalFixtureLoadOptions, type EvalFixtureRunPlan, type EvalFixtureScenario, type EvalFixtureValidationMode, type EvidenceVector, type EvolutionaryProposerOptions, type FailureModeRecallJudgeOptions, type FapoAttributionSignals, type FapoFailureCluster, type FapoOptimizationLevel, type FapoOptimizationMethodConfig, type FapoProposerOptions, type FapoReviewInput, type FapoReviewIssue, type FapoReviewResult, type FapoScopeContract, FileSearchLedger, FsLabeledScenarioStore, type FsLabeledScenarioStoreOptions, type Gate, type GateContext, type GateDecision, type GateResult, type GenerationCandidate, type GenerationRecord, type GepaProposerConstraints, type GepaProposerOptions, type GitWorktreeAdapterOptions, type Governor, type GovernorContext, type GovernorOp, type HaloProposerOptions, type HeldOutGateOptions, type HeldoutSignificance, type HeldoutSignificanceOptions, type HeuristicGovernorOptions, type JsonPolicyEditTargetSurface, type JsonPrimitive, type JsonValue, type JudgeAggregate, type JudgeConfig, type JudgeDimension, type JudgeScore, type LabelTrust, type LabeledScenarioRecord, type LabeledScenarioSampleArgs, type LabeledScenarioSource, type LabeledScenarioStore, LabeledScenarioStoreError, type LabeledScenarioWrite, Lineage, type LineageEdge, type LineageGraph, type LineageNode, type LineageNodeInput, type LineageStore, LineageStoreConflictError, type LlmJudgeDimension, type LlmJudgeOptions, type LlmPolicyEditProposerOptions, type LoadEvalFixtureScenariosOptions, type LoopProvenanceArgsFromResult, type LoopProvenanceBackend, type LoopProvenanceCandidate, type LoopProvenanceEvidence, type LoopProvenanceRecord, type MemoryCurationProposerOptions, type MutableSurface, type Mutator, type NeutralizationGateOptions, type ObjectiveSource, type OpenAutoPrOptions, type OpenAutoPrResult, type OpenSearchLedgerOptions, type OptimizationMethod, type OptimizationMethodComparison, type OptimizationMethodInput, type OptimizationMethodPairwise, type OptimizationMethodResult, type OptimizationMethodRunOptions, type OptimizationMethodScore, type OptimizationProposer, type OptimizerConfig, POLICY_EDIT_CANDIDATE_RECORD_SCHEMA, type PairedHoldout, type ParameterCandidate, type ParameterChange, type ParameterSweepProposerOptions, type ParetoParent, type ParetoSignificanceGateOptions, type PendingCostCallView, type PlanCampaignRunOptions, type PlanEvalFixtureRunOptions, type PlaybackContext, type PlaybackDriver, type PlaybackStep, type PolicyEditAuthorScenarioRow, type PolicyEditCandidateRecord, type PolicyEditCandidateSummary, type PolicyEditFindingInput, type PolicyEditFindingSource, type PolicyEditHistoryCandidateContext, type PolicyEditHistoryGenerationContext, type PolicyEditHistoryProjectionOptions, type PolicyEditObjective, type PolicyEditOutcomeContext, type PolicyEditProposerOptions, type PowerPreflight, type PowerPreflightOptions, type PremeasuredOptimizationBaseline, type ProfileDispatchFn, ProfileMatrixError, type ProfileSummary, type PromotionObjective, type PromotionPolicy, type ProposalTrackContext, type ProposeContext, type ProposePatchesArgs, type ProposedCandidate, type RedactionStatus, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceScenario, type RejectedEdit, type RolloutArgumentDiff, type RolloutArgumentDiffOptions, type RolloutCall, type RunCampaignOptions, type RunEvalOptions, type RunImprovementLoopOptions, type RunImprovementLoopResult, type RunLineageLoopOptions, type RunLineageLoopResult, type RunLineageLoopSeed, type RunLineageOptions, type RunLineageResult, type RunLineageSeed, type RunLineageStepResult, type RunOptimizationOptions, type RunOptimizationResult, type RunProfileMatrixOptions, type RunProfileMatrixResult, type RunSkillOptOptions, type RunSkillOptResult, SEARCH_LEDGER_SCHEMA, type Scenario, type ScenarioAggregate, type ScenarioRollup, type ScenarioSignal, type ScoreboardRenderOptions, type ScoreboardRow, type ScoreboardSummary, type ScoredRollout, type ScoredSurfaceOutcome, type SearchAccountingAudit, type SearchArtifactRef, type SearchAttemptAccounting, type SearchCandidateDecidedEvent, type SearchCandidateLineage, type SearchCandidateRegisteredEvent, type SearchCandidateSlot, type SearchCandidateSlotClosedEvent, type SearchCandidateSurface, type SearchCompletedEvent, type SearchCostAccounting, type SearchFailureReason, type SearchLedger, type SearchLedgerAppendResult, SearchLedgerConflictError, type SearchLedgerEntry, SearchLedgerError, type SearchLedgerEvent, type SearchLedgerHash, SearchLedgerIntegrityError, type SearchLedgerReplay, type SearchModelIdentity, type SearchOperationKind, type SearchOperationRecordedEvent, type SearchPlan, type SearchPlannedEvent, type SearchPlannedOperation, type SearchPlannedTask, type SearchSourceRef, type SearchSurfaceEffect, type SearchSurfaceEvidence, type SearchSurfaceKind, type SearchTaskAttemptedEvent, type SearchTaskOutcome, type SearchTokenAccounting, type SelectPolicyEditAuthorRowsOptions, type SequentialDecideFn, type SequentialDecideOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SerializedJsonBudget, type SessionScript, type SingleRunLock, type SingleRunLockOptions, type SkillOptEpochRecord, type SkillOptEvidence, type SkillOptProposer, type SkillOptProposerOptions, type SkillPatch, type SkillPatchOp, SkillPatchParseError, type SkillPatchRejection, type SurfaceProposer, type SurfaceScore, type TraceAnalystPriorFindings, type TraceAnalystProposerOptions, type TraceSpan, type TransientFailureOptions, type UngroundedLiteralReport, type UserStory, type UserStoryVerdict, type Worktree, type WorktreeAdapter, WorktreeAdapterError, aceProposer, acquireSingleRunLock, analyzeCrossSurfaceInteractions, analyzeOtlpTraceFile, applySkillPatch, assertCampaignDesign, assertCampaignSplitIdentity, assertCodeSurfaceIdentity, assertPolicyEditAuthorContextBudget, buildAnalystSurfaceDispatch, buildEvidenceVector, buildLoopProvenanceRecord, callbackGovernor, campaignBreakdown, campaignLineageStore, campaignMeanComposite, campaignMeasurementDigest, campaignScenarioIdentity, campaignSplitDigest, campaignSplitDigestFromIdentities, canonicalDigest, classifyUngroundedLiterals, codeSurfaceIdentityMaterial, compareOptimizationMethods, composeGate, compositeProposer, costFromLedgerSummary, countSentenceEdits, createReferenceEquivalenceJudge, createRunCostLedger, defaultProductionGate, detectScale, dimensionRegressions, discoverEvalFixtures, emitLoopProvenance, evolutionaryProposer, extractFapoAttributionSignals, extractH2Sections, failureModeRecallJudge, fapoEscalationMethod, fapoProposer, fsCampaignStorage, fsLineageStore, gepaParetoMethod, gepaProposer, gepaReflectionMethod, gitWorktreeAdapter, haloProposer, heldOutGate, heldoutSignificance, heuristicGovernor, inMemoryCampaignStorage, isProposedCandidate, isTransientTransportFailure, labelTrustRank, lineageNodeId, llmJudge, llmPolicyEditProposer, loadEvalFixture, loadEvalFixtureScenarios, loopProvenanceArgsFromResult, loopProvenanceSpans, makePlaybackDispatch, memLineageStore, memoryCurationProposer, neutralizationGate, neutralizeText, openAutoPr, openSearchLedger, pairHoldout, parameterSweepProposer, paretoPolicy, paretoSignificanceGate, parseSkillPatchResponse, patchEditCount, planCampaignRun, planEvalFixtureRun, policyEditProposer, powerPreflight, projectPolicyEditHistory, provenanceRecordPath, provenanceSpansPath, renderScoreboardMarkdown, renderSurfaceDiff, resolveRunDir, resolveWorktreePath, rolloutArgumentDiff, runCampaign, runEval, runImprovementLoop, runLineage, runLineageLoop, runOptimization, runProfileMatrix, runSkillOpt, scoreDiscrimination, scoreUserStory, scoreboardSummary, selectDiscriminative, selectPolicyEditAuthorRows, sequentialDecide, sequentialPairedGate, skillOptMethod, skillOptProposer, surfaceContentHash, surfaceHash, tangleTracesRoot, traceAnalystProposer, userStoryScoreboard, validatePolicyEditCandidateRecord, validateSearchLedgerEvent, verifyCodeSurface, verifyLoopProvenanceRecord };