@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/{index-NvGBiO8H.d.ts → index-ZuWx52WG.d.ts}

@@ -1,21 +1,27 @@
+import { a as CostLedgerHandle, c as CostLedgerSummary, l as CostProvenance, u as CostReceipt } from "./cost-ledger-Jk62OBfF.js";
 import { c as ValidationError, t as AgentEvalError } from "./errors-DEE6u6ot.js";
-import { T as RunPaidCallInput, c as CostLedgerHandle, f as CostLedgerSummary, m as CostReceipt, p as CostProvenance } from "./cost-ledger-CO7UyEcQ.js";
-import { a as RunRecord, c as RunSplitTag } from "./run-record-D1Hw-Jml.js";
-import { X as TraceAnalysisStore, a as AnalystFinding, b as ProposalFinding, d as AnalystRunResult, m as AnalystUsageReceipt } from "./types-oKRhQAde.js";
-import { M as LlmCallMetadata, ft as ServedModelPolicy, rt as RawProviderSink, x as ChatClient } from "./types-DBZ7keha.js";
-import { Dt as FinalEvidenceRecord, P as PairedArmsComparison, dt as EvidenceReceipt, it as CampaignEvidenceContext, wt as FinalEvidenceLedger } from "./statistical-heldout-BeR4bOdg.js";
-import { a as PairedPromotionDecision, d as PairedBootstrapResult } from "./paired-promotion-decision-DPKz8ZnF.js";
+import { a as RunRecord, c as RunSplitTag } from "./run-record-CaxbLq6Y.js";
+import { W as TraceAnalysisStore, i as AnalystFinding, p as AnalystUsageReceipt, u as AnalystRunResult, v as ProposalFinding } from "./types-CW8ewATZ.js";
+import { X as RawProviderSink, j as LlmCallMetadata, nt as ServedModelPolicy, x as ChatClient } from "./types-D-mgRzlh.js";
+import { M as PairedArmsComparison, ct as EvidenceReceipt, nt as CampaignEvidenceContext, wt as FinalEvidenceRecord, xt as FinalEvidenceLedger } from "./statistical-heldout-C9AbgREN.js";
+import { a as PairedPromotionDecision, u as PairedBootstrapResult } from "./paired-promotion-decision-CQMJ5xGN.js";
 import { E as SearchExecutionIdentity, G as SearchSplit, V as SearchProposer, a as SearchAttemptAccounting, i as SearchArtifactRef, j as SearchModelIdentity, nt as EvaluationClaim, rt as EvaluationUnitSummary, tt as SearchUnknown, z as SearchOperationRecordedEvent } from "./search-ledger-types-p2xKfiDJ.js";
 import { r as LedgerHash } from "./canonical-CFpojCN5.js";
-import { A as LabeledScenarioWrite, C as JudgeDimension, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, H as SurfaceProposer, N as ParetoParent, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, u as ComponentSurface, v as GateResult, y as GenerationCandidate } from "./types-B4C5nFw6.js";
-import { Pt as SearchHistoryReceipt, R as SearchPolicy, St as SearchRunIdentity, Zt as CampaignStorage, _t as RegisterSearchNodeInput, bt as SearchRecorder, i as SearchCellResult, jt as SearchHistoryCoverage, kt as SearchHistoryAdmissionOptions, vt as SearchLedgerBinding } from "./search-kernel-CpcKH5Ih.js";
-import { B as ExternalOptimizerModelBudget, E as AnalystIssueExpectation, F as ExternalOptimizerCallbackLimits, J as ExternalOptimizerWireCounts, K as ExternalOptimizerResumeMode, R as ExternalOptimizerEvaluationObservation, V as ExternalOptimizerModelCall, X as ExternalTextEvaluationRequest, Y as ExternalTextCandidate, m as AnalystBenchmarkLabelState, q as ExternalOptimizerRunnerCommand, t as AgentProfile$1, u as AnalystBenchmarkCase } from "./agent-profile-CIA2Atnt.js";
+import { C as JudgeDimension, H as SurfaceProposer, N as ParetoParent, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, _ as GateDecision, a as CampaignResult, b as GenerationRecord, c as CampaignTraceWriter, d as DispatchContext, f as DispatchFn, g as GateContribution, i as CampaignCostMeter, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, o as CampaignScenarioIdentity, p as Gate, r as CampaignCellResult, u as ComponentSurface, v as GateResult, y as GenerationCandidate } from "./types-D8GhJoHk.js";
+import { At as SearchHistoryReceipt, Dt as SearchHistoryCoverage, I as SearchPolicy, Tt as SearchHistoryAdmissionOptions, Wt as CampaignStorage, gt as SearchRecorder, mt as SearchLedgerBinding, o as SearchCellResult, pt as RegisterSearchNodeInput, vt as SearchRunIdentity } from "./search-kernel-DxqjBxA-.js";
+import { E as AnalystIssueExpectation, G as ExternalOptimizerRunnerCommand, I as ExternalOptimizerEvaluationObservation, J as ExternalTextEvaluationRequest, K as ExternalOptimizerWireCounts, N as ExternalOptimizerCallbackLimits, R as ExternalOptimizerModelBudget, W as ExternalOptimizerResumeMode, m as AnalystBenchmarkLabelState, q as ExternalTextCandidate, t as AgentProfile$1, u as AnalystBenchmarkCase, z as ExternalOptimizerModelCall } from "./agent-profile-DTt8uGP9.js";
 import { r as DatasetScenario, t as Dataset } from "./dataset-DQqhOCPt.js";
-import { a as CheckerIdentity, n as VerdictCertification, t as DefaultVerdict, x as VerificationStrategySource } from "./verdict-E4eRNf7-.js";
-import { t as DetectRewardHackingInput } from "./reward-hacking-DHA7c1l8.js";
-import { p as TraceSpanEvent, t as HostedClient } from "./client-BzL9niqi.js";
+import { a as CheckerIdentity, n as VerdictCertification, t as DefaultVerdict, x as VerificationStrategySource } from "./verdict-C24NELtN.js";
+import { t as DetectRewardHackingInput } from "./reward-hacking-E52wq86n.js";
+import { f as TraceSpanEvent, t as HostedClient } from "./client-hwo3cJjR.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 import { z } from "zod";
+//#region src/campaign/search-ledger-errors.d.ts
+/** Base error for invalid search-ledger input or operations. */
+declare class SearchLedgerError extends ValidationError {}
+/** Error raised when durable search-ledger data fails an integrity check. */
+declare class SearchLedgerIntegrityError extends SearchLedgerError {}
+//#endregion
 //#region src/campaign/coverage.d.ts
 interface CampaignCoverage {
   complete: boolean;
@@ -34,8 +40,6 @@ declare function campaignScenarioIdentity<TScenario extends Scenario>(scenario:
 declare function campaignSplitDigestFromIdentities(scenarios: readonly CampaignScenarioIdentity[], reps: number): `sha256:${string}`;
 /** Canonical identity of the exact scenario payloads and replicate count. */
 declare function campaignSplitDigest<TScenario extends Scenario>(scenarios: readonly TScenario[], reps: number): `sha256:${string}`;
-/** Refuse a campaign whose retained task identities contradict its split digest. */
-declare function assertCampaignSplitIdentity(scenarios: readonly CampaignScenarioIdentity[], reps: number, splitDigest: string): void;
 /** Exact designed-denominator receipt for one campaign. */
 declare function campaignCoverage<TArtifact, TScenario extends Scenario>(cells: readonly CampaignCellResult<TArtifact>[], scenarios: readonly TScenario[], reps: number, requireJudgeScore: boolean): CampaignCoverage;
 //#endregion
@@ -70,12 +74,6 @@ type CacheRead<TArtifact> = {
   status: 'miss';
   reason: CacheIssueReason;
 };
-declare function readCachedCell<TArtifact>(args: {
-  storage: CampaignStorage;
-  cachePath: string;
-  cellId: string;
-  manifestHash: string;
-}): CacheRead<TArtifact>;
 //#endregion
 //#region src/campaign/plan-campaign-run.d.ts
 interface CampaignRunPlanCell {
@@ -350,22 +348,18 @@ interface OpenAutoPrResult {
  */
 declare function openAutoPr<TArtifact, TScenario extends Scenario>(options: OpenAutoPrOptions<TArtifact, TScenario>): OpenAutoPrResult;
 //#endregion
-//#region src/campaign/search-ledger-errors.d.ts
-/** Base error for invalid search-ledger input or operations. */
-declare class SearchLedgerError extends ValidationError {}
-/** Error raised when durable search-ledger data fails an integrity check. */
-declare class SearchLedgerIntegrityError extends SearchLedgerError {}
-/** Error raised when an event identifier is reused with different content. */
-declare class SearchLedgerConflictError extends SearchLedgerError {}
-//#endregion
 //#region src/campaign/presets/run-optimization.d.ts
+/** Compose the optimization proposer and cell executor on the shared search kernel. */
+/** Improve a surface as a search on the kernel; see the module comment. */
+declare function runOptimization<TScenario extends Scenario, TArtifact>(opts: RunOptimizationOptions<TScenario, TArtifact>): Promise<RunOptimizationResult<TArtifact, TScenario>>;
+/** Optimization inputs, immutable proposal snapshots, and imported baseline validation. */
 interface PremeasuredOptimizationBaseline<TArtifact, TScenario extends Scenario> {
   /** Hash of the exact surface that produced `campaign`. */
   surfaceHash: string;
   /** Complete prior measurement reused by identity, including artifactsByPath. */
   campaign: CampaignResult<TArtifact, TScenario>;
 }
-interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch'> {
+interface RunOptimizationOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch'> {
   /** Initial mutable surface (typically system prompt or addendum). */
   baselineSurface: MutableSurface;
   /**
@@ -426,7 +420,6 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
    *  digests. */
   searchLedger?: SearchLedgerBinding;
 }
-type RunOptimizationOptions<TScenario extends Scenario, TArtifact> = RunOptimizationBaseOptions<TScenario, TArtifact>;
 interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
   /** One entry per proposal, with the candidates it registered. */
   generations: Array<{
@@ -454,8 +447,6 @@ interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
   /** The non-dominated set of measured surfaces by per-scenario composite. */
   paretoFrontier: ParetoParent[];
 }
-/** Improve a surface as a search on the kernel; see the module comment. */
-declare function runOptimization<TScenario extends Scenario, TArtifact>(opts: RunOptimizationOptions<TScenario, TArtifact>): Promise<RunOptimizationResult<TArtifact, TScenario>>;
 //#endregion
 //#region src/campaign/presets/run-improvement-loop.d.ts
 type RunImprovementLoopOptions<TScenario extends Scenario, TArtifact> = RunOptimizationOptions<TScenario, TArtifact> & {
@@ -535,29 +526,6 @@ interface TransientFailureOptions {
    */
   readonly now?: number;
 }
-/**
- * The instant a provider says a spent quota works again, or null when the text states none.
- *
- * MEASURED (2026-09-01, discovery lab). The codex/ChatGPT backend answered
- * `You've hit your usage limit. Visit https://chatgpt.com/codex/settings/usage to purchase more
- * credits or try again at Sep 6th, 2026 8:29 PM.` — a refusal SIX DAYS out. 25 supervised runs met
- * it. 21 of them retried it 12 times over about 31 minutes and settled with zero children, zero
- * tokens and zero claims: about 11 hours of one subscription's capacity spent on a wall that had
- * already told the caller when it would come down.
- *
- * The distinction this draws is not "quota" versus "not quota". It is "the provider named a
- * release time" versus "it did not". A bare 429, or z.ai's `您的账户已达到速率限制`, recovers on
- * its own in seconds and SHOULD be retried; those return null here and keep their existing
- * treatment. Only a stated release is terminal, and only until that instant.
- *
- * A date with no zone is read in the host's zone, because a CLI renders it in the host's zone.
- * An unparseable date returns null rather than a guess: a caller that stops dispatching must
- * never do so on a misread string.
- *
- * @param message the provider's error text
- * @returns the stated release time, or null when the text names none
- */
-declare function quotaExhaustedUntil(message: string | null | undefined): Date | null;
 /**
  * True when the error text describes an infrastructure hiccup that should be
  * retried rather than scored. Empty/undefined input is not transient.
@@ -651,12 +619,6 @@ interface LlmJudgeOptions<TArtifact, TScenario extends Scenario = Scenario> {
 declare function llmJudge<TArtifact = unknown, TScenario extends Scenario = Scenario>(name: string, prompt: string, opts: LlmJudgeOptions<TArtifact, TScenario>): JudgeConfig<TArtifact, TScenario>;
 //#endregion
 //#region src/reference-equivalence-judge.d.ts
-declare const REFERENCE_EQUIVALENCE_JUDGE_VERSION = "reference-equivalence-judge-v1-2026-07-13";
-declare const REFERENCE_EQUIVALENCE_INPUT_LIMITS: {
-  readonly userRequest: 8000;
-  readonly expectedAnswer: 32000;
-  readonly candidateOutput: 32000;
-};
 interface ReferenceEquivalenceScenario extends Scenario {
   userRequest: string;
   expectedAnswer: string;
@@ -682,10 +644,6 @@ interface ReferenceEquivalenceJudgeResult extends LlmCallMetadata {
   score: number;
   rationale: string;
 }
-/** Build the campaign-native expected-answer judge. */
-declare function createReferenceEquivalenceJudge(options: ReferenceEquivalenceJudgeOptions): JudgeConfig<string, ReferenceEquivalenceScenario>;
-/** Direct-call adapter over the campaign judge for product callers. */
-declare function runReferenceEquivalenceJudge(input: ReferenceEquivalenceJudgeInput, options: ReferenceEquivalenceJudgeOptions): Promise<ReferenceEquivalenceJudgeResult>;
 //#endregion
 //#region src/campaign/external-optimizer-observations.d.ts
 interface ExternalOptimizerObservationSummary {
@@ -798,13 +756,21 @@ interface ComparisonCost {
 }
 /** Keep the cost fields a custom optimization method must report. */
 declare function costFromLedgerSummary(summary: CostLedgerSummary): ComparisonCost;
-/** Combine method costs without turning one unknown bill into a known total. */
-declare function combineComparisonCosts(entries: ReadonlyArray<{
-  label: string;
-  cost: ComparisonCost;
-}>): ComparisonCost;
+interface OptimizationTokenUsage {
+  /** All input tokens, including cache reads and cache creation. */
+  inputTokens: number;
+  /** Input tokens served from a provider cache. */
+  cachedInputTokens?: number;
+  /** Input tokens used to create or write a provider cache entry. */
+  cacheWriteInputTokens?: number;
+  outputTokens: number;
+  /** Reasoning tokens included in `outputTokens`. */
+  reasoningTokens?: number;
+  totalTokens: number;
+  calls: number;
+}
 //#endregion
-//#region src/campaign/presets/compare-optimization-methods.d.ts
+//#region src/campaign/optimization-method.d.ts
 /** Shared campaign settings applied to every optimization method. */
 type OptimizationMethodRunOptions<TScenario extends Scenario, TArtifact> = Omit<RunCampaignOptions<TScenario, TArtifact>, 'costCeiling' | 'costLedger' | 'dispatch' | 'judges' | 'runDir' | 'scenarios' | 'seed'>;
 interface OptimizationPackageSource {
@@ -826,19 +792,6 @@ interface OptimizationPythonRuntime {
   implementation: string;
   version: string;
 }
-interface OptimizationTokenUsage {
-  /** All input tokens, including cache reads and cache creation. */
-  inputTokens: number;
-  /** Input tokens served from a provider cache. */
-  cachedInputTokens?: number;
-  /** Input tokens used to create or write a provider cache entry. */
-  cacheWriteInputTokens?: number;
-  outputTokens: number;
-  /** Reasoning tokens included in `outputTokens`. */
-  reasoningTokens?: number;
-  totalTokens: number;
-  calls: number;
-}
 interface OptimizationMethodProvenance {
   /** External optimizer package. */
   source: OptimizationPackageSource;
@@ -930,131 +883,6 @@ interface OptimizationMethod<TScenario extends Scenario = Scenario, TArtifact =
   name: string;
   optimize: (input: OptimizationMethodInput<TScenario, TArtifact>) => Promise<OptimizationMethodResult>;
 }
-interface OptimizationMethodScore {
-  evidence?: {
-    baseline: EvidenceReceipt;
-    winner: EvidenceReceipt;
-  };
-  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 final-test lift across independent units (winner minus baseline). */
-  lift: number;
-  /** Deciding interval, adjusted for every registered contrast. */
-  liftCi: {
-    low: number;
-    high: number;
-  };
-  decision: PairedPromotionDecision;
-  /** Search spend reconciled with recorded method calls. Excludes final test scoring. */
-  optimizationCost: ComparisonCost;
-  /** Optimization duration reported by the method. Excludes final test scoring. */
-  durationMs?: number;
-  /** Exact external implementation and run identity, when reported by the method. */
-  provenance?: OptimizationMethodProvenance;
-  /** Paired final-test values used to compute lift and its interval. */
-  scenarioScores: Array<{
-    scenarioId: string;
-    baselineComposite: number;
-    winnerComposite: number;
-    lift: number;
-  }>;
-  /** Scenario means averaged within each registered source unit before inference. */
-  unitScores: Array<{
-    unitId: string;
-    scenarios: number;
-    baselineComposite: number;
-    winnerComposite: number;
-    lift: number;
-  }>;
-  winnerSurface: MutableSurface;
-  composition?: OptimizationMethodComposition;
-  /** 1-based, by descending lift. */
-  rank: number;
-}
-interface OptimizationMethodPairwise {
-  /** Higher-ranked method. */
-  a: string;
-  b: string;
-  /** Mean final-test delta across independent units (a − b). */
-  deltaMean: number;
-  low: number;
-  high: number;
-  /** Favored only when the full paired decision clears the registered effect; null is inconclusive. */
-  favored: string | null;
-  decision: PairedPromotionDecision;
-}
-interface OptimizationMethodComparison {
-  claim?: EvaluationClaim;
-  finalEvidence?: FinalEvidenceUse;
-  /** Sorted by descending lift; `rank` set accordingly. */
-  scores: OptimizationMethodScore[];
-  best: OptimizationMethodScore;
-  /** Best observed method versus each alternative, with simultaneous paired decisions. */
-  pairwise: OptimizationMethodPairwise[];
-  testScenarioIds: string[];
-  units: EvaluationUnitSummary;
-  observationUnit: 'scenario' | 'registered';
-  /** Complete scenario-replicate pairs per contrast, before unit aggregation. */
-  pairedCellN: number;
-  /** Sum of method reports reconciled against each method's recorded calls. */
-  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;
-  /** Coverage of every method's canonical search history. */
-  searchHistory: SearchHistoryCoverage;
-}
-interface CompareOptimizationMethodsOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'judges' | 'scenarios'>, SearchHistoryAdmissionOptions {
-  /** Explicit caller authority and environment for receipts over actual final measurements. */
-  evidence?: CampaignEvidenceContext;
-  claim?: EvaluationClaim;
-  finalEvidence?: FinalEvidencePolicy;
-  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 every method's optimizer and evaluation calls plus final scoring. */
-  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>;
-/** Preserve every optimizer token class while keeping total input and output explicit. */
-declare function optimizationTokenUsageFromSummary(summary: CostLedgerSummary, receipts: readonly CostReceipt[]): OptimizationTokenUsage | undefined;
 //#endregion
 //#region src/campaign/external-text-evaluation.d.ts
 interface ExternalOptimizationExample {
@@ -1301,7 +1129,132 @@ interface GepaOptimizationMethodConfig<TScenario extends Scenario, TArtifact = u
     path?: string;
   };
 }
-declare function gepaOptimizationMethod<TScenario extends Scenario, TArtifact>(config: GepaOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
+declare function gepaOptimizationMethod<TScenario extends Scenario, TArtifact>(config: GepaOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
+//#endregion
+//#region src/campaign/presets/compare-optimization-methods.d.ts
+interface OptimizationMethodScore {
+  evidence?: {
+    baseline: EvidenceReceipt;
+    winner: EvidenceReceipt;
+  };
+  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 final-test lift across independent units (winner minus baseline). */
+  lift: number;
+  /** Deciding interval, adjusted for every registered contrast. */
+  liftCi: {
+    low: number;
+    high: number;
+  };
+  decision: PairedPromotionDecision;
+  /** Search spend reconciled with recorded method calls. Excludes final test scoring. */
+  optimizationCost: ComparisonCost;
+  /** Optimization duration reported by the method. Excludes final test scoring. */
+  durationMs?: number;
+  /** Exact external implementation and run identity, when reported by the method. */
+  provenance?: OptimizationMethodProvenance;
+  /** Paired final-test values used to compute lift and its interval. */
+  scenarioScores: Array<{
+    scenarioId: string;
+    baselineComposite: number;
+    winnerComposite: number;
+    lift: number;
+  }>;
+  /** Scenario means averaged within each registered source unit before inference. */
+  unitScores: Array<{
+    unitId: string;
+    scenarios: number;
+    baselineComposite: number;
+    winnerComposite: number;
+    lift: number;
+  }>;
+  winnerSurface: MutableSurface;
+  composition?: OptimizationMethodComposition;
+  /** 1-based, by descending lift. */
+  rank: number;
+}
+interface OptimizationMethodPairwise {
+  /** Higher-ranked method. */
+  a: string;
+  b: string;
+  /** Mean final-test delta across independent units (a − b). */
+  deltaMean: number;
+  low: number;
+  high: number;
+  /** Favored only when the full paired decision clears the registered effect; null is inconclusive. */
+  favored: string | null;
+  decision: PairedPromotionDecision;
+}
+interface OptimizationMethodComparison {
+  claim?: EvaluationClaim;
+  finalEvidence?: FinalEvidenceUse;
+  /** Sorted by descending lift; `rank` set accordingly. */
+  scores: OptimizationMethodScore[];
+  best: OptimizationMethodScore;
+  /** Best observed method versus each alternative, with simultaneous paired decisions. */
+  pairwise: OptimizationMethodPairwise[];
+  testScenarioIds: string[];
+  units: EvaluationUnitSummary;
+  observationUnit: 'scenario' | 'registered';
+  /** Complete scenario-replicate pairs per contrast, before unit aggregation. */
+  pairedCellN: number;
+  /** Sum of method reports reconciled against each method's recorded calls. */
+  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;
+  /** Coverage of every method's canonical search history. */
+  searchHistory: SearchHistoryCoverage;
+}
+interface CompareOptimizationMethodsOptions<TScenario extends Scenario, TArtifact> extends Omit<RunCampaignOptions<TScenario, TArtifact>, 'dispatch' | 'judges' | 'scenarios'>, SearchHistoryAdmissionOptions {
+  /** Explicit caller authority and environment for receipts over actual final measurements. */
+  evidence?: CampaignEvidenceContext;
+  claim?: EvaluationClaim;
+  finalEvidence?: FinalEvidencePolicy;
+  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 every method's optimizer and evaluation calls plus final scoring. */
+  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>;
 //#endregion
 //#region src/campaign/skillopt-optimization-method.d.ts
 interface SkillOptTrainerConfig {
@@ -1792,37 +1745,9 @@ interface LoopProvenanceArgsFromResult<TArtifact, TScenario extends Scenario> {
   totalDurationMs: number;
   independentUnitByScenarioId?: ReadonlyMap<string, string>;
 }
-/** One translation from a completed improvement loop into durable evidence. */
-declare function loopProvenanceArgsFromResult<TArtifact, TScenario extends Scenario>(input: LoopProvenanceArgsFromResult<TArtifact, TScenario>): BuildLoopProvenanceArgs<TArtifact, TScenario>;
-/** Build the durable provenance record from a completed loop result. */
-declare function buildLoopProvenanceRecord<TArtifact, TScenario extends Scenario>(args: BuildLoopProvenanceArgs<TArtifact, TScenario>): LoopProvenanceRecord;
-/** Digest the exact campaign fields that can affect a measured comparison. */
-declare function campaignMeasurementDigest<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): `sha256:${string}`;
-/** Recompute and validate the self-addressed durable record. */
-declare function verifyLoopProvenanceRecord(record: LoopProvenanceRecord): LoopProvenanceRecord;
 /** SHA-256 over the RFC 8785 canonical JSON of `value`. Throws
  * `LedgerCanonicalizationError` for a value with no canonical form. */
 declare function canonicalDigest(value: unknown): `sha256:${string}`;
-/**
- * Build the loop's OTLP-ingestable spans from a provenance record. One root
- * span per loop (`tangle.runId`), one span per generation, one span per
- * candidate (carrying its surfaceHash + label), and one span for the gate
- * decision (carrying reasons + delta + lift). Candidate + gate spans pivot on
- * the same `tangle.runId` / `tangle.generation` attributes `/adapters/otel`
- * reads, so the hosted collector reconstructs the full tree.
- *
- * Times are synthesized monotonically off a single base so the span tree is
- * orderable; the substrate does not retain per-candidate wall-clock starts.
- */
-declare function loopProvenanceSpans(record: LoopProvenanceRecord, opts?: {
-  baseTimeMs?: number;
-}): TraceSpanEvent[];
-/** Canonical durable paths under the run dir. */
-declare function provenanceRecordPath(runDir: string): string;
-/**
- * Canonical path for the durable OTLP spans JSONL file under a loop run directory.
- */
-declare function provenanceSpansPath(runDir: string): string;
 interface EmitLoopProvenanceResult {
   record: LoopProvenanceRecord;
   spans: TraceSpanEvent[];
@@ -1870,8 +1795,6 @@ interface BuildTraceAnalystSurfaceDispatchOptions {
     signal: AbortSignal;
   }): Promise<TraceAnalystArtifact>;
 }
-declare function buildTraceAnalystSurfaceDispatch(options: BuildTraceAnalystSurfaceDispatchOptions): (surface: MutableSurface, scenario: TraceAnalystScenario, context: DispatchContext) => Promise<TraceAnalystArtifact>;
-declare function traceAnalystQualityJudge(): JudgeConfig<TraceAnalystArtifact, TraceAnalystScenario>;
 //#endregion
 //#region src/campaign/cross-surface-types.d.ts
 /** Whether one candidate attempt produced a usable executable outcome. */
@@ -2269,49 +2192,6 @@ declare function importExternalEvaluations(input: {
 }): Promise<GepaEvaluationImport>;
 /** An optimizer candidate as the mutable surface it represents. */
 declare function externalSurface(candidate: ExternalTextCandidate): MutableSurface;
-/** What `recordGepaSearch` and `recordSkillOptSearch` share. */
-interface ExternalSearchRecordInput {
-  name: string;
-  path: string;
-  searchId: string;
-  identity: SearchRunIdentity;
-  storage: CampaignStorage;
-  seed: number;
-  baselineSurface: MutableSurface;
-  trainScenarios: readonly Scenario[];
-  selectionScenarios: readonly Scenario[];
-  evaluationLimit: number;
-  observations: ExternalOptimizerObservationArtifact;
-  generationAccounting: SearchAttemptAccounting;
-}
-/**
- * Write GEPA's finished search into its ledger: the baseline as the seeded
- * root, the population as nodes with `correlated` edges, every callback
- * evaluation as an `external` cell, GEPA's proposer spend as one operation,
- * GEPA's choice as the selected node, and the close. GEPA's own selection is a
- * budget decision, so the ledger carries no claim; the final comparison runs
- * outside this search.
- *
- * A composed recipe reports no population: pass `population: null` and GEPA's
- * returned best as `selected`, and every evaluated candidate enters with an
- * `unknown` edge, as SkillOpt's do.
- */
-declare function recordGepaSearch(input: ExternalSearchRecordInput & ({
-  population: GepaCandidatePopulationArtifact;
-} | {
-  population: null;
-  selected: MutableSurface;
-})): Promise<SearchHistoryReceipt>;
-/**
- * Write SkillOpt's finished search into its ledger: the baseline as the seeded
- * root, every candidate SkillOpt evaluated as a node with an `unknown` edge
- * (SkillOpt reports no parents), every callback evaluation as an `external`
- * cell, SkillOpt's optimizer spend as one operation, SkillOpt's choice as the
- * selected node, and the close. Like GEPA's, the ledger carries no claim.
- */
-declare function recordSkillOptSearch(input: ExternalSearchRecordInput & {
-  selected: MutableSurface;
-}): Promise<SearchHistoryReceipt>;
 //#endregion
 //#region src/campaign/grounded-reflection.d.ts
 /**
@@ -2366,27 +2246,12 @@ interface RolloutArgumentDiff {
   /** Lowercased stringified argument values seen in failing rollouts. */
   readonly failingValues: ReadonlySet<string>;
 }
-/**
- * Deterministic per-field diff of call arguments between passing and failing
- * rollouts. A field set by failing rollouts but left unset by passing ones is
- * the classic poison-input signature; a field whose values differ across the
- * split points at the correct value. Feed `text` to the reviser verbatim.
- */
-declare function rolloutArgumentDiff(rollouts: readonly ScoredRollout[], opts?: RolloutArgumentDiffOptions): RolloutArgumentDiff;
 interface UngroundedLiteralReport {
   /** Quoted single-word literals in the text that no passing rollout used. */
   readonly ungrounded: readonly string[];
   /** The subset failing rollouts actually used - prescribing these is proven harmful. */
   readonly harmful: readonly string[];
 }
-/**
- * Scan revised artifact text for single-quoted single-word literals (the
- * "use exactly 'new'" pattern) that appear in no passing rollout's argument
- * values. Multi-word quotes pass (they are prose, not prescriptions).
- * Callers should reject on `harmful` (with a bounded retry) and at most log
- * `ungrounded` - see the module header for why the severities differ.
- */
-declare function classifyUngroundedLiterals(text: string, diff: Pick<RolloutArgumentDiff, 'passingValues' | 'failingValues'>): UngroundedLiteralReport;
 //#endregion
 //#region src/campaign/labeled-store/fs-adapter.d.ts
 interface FsLabeledScenarioStoreOptions {
@@ -2398,33 +2263,6 @@ interface FsLabeledScenarioStoreOptions {
   /** Test seam — override `Date.now()` for deterministic tests. */
   now?: () => number;
 }
-/** Typed rejection from a labeled-scenario store (bad provenance, rate limit, invalid sample args) — carries a stable string `code`. */
-declare class LabeledScenarioStoreError extends Error {
-  readonly code: string;
-  constructor(code: string, message: string);
-}
-/**
- * Filesystem `LabeledScenarioStore`: appends one JSONL file per source with provenance and
- * rate-limit guards. For tests, local dev, and small workloads — high-throughput lands in Turso.
- */
-declare class FsLabeledScenarioStore implements LabeledScenarioStore {
-  private readonly options;
-  private readonly now;
-  private readonly rateLimits;
-  constructor(options: FsLabeledScenarioStoreOptions);
-  observe(write: LabeledScenarioWrite): Promise<void>;
-  sample(args: LabeledScenarioSampleArgs): Promise<LabeledScenarioRecord[]>;
-  size(): Promise<{
-    train: number;
-    test: number;
-    bySource: Record<string, number>;
-    byTrust: Record<LabelTrust, number>;
-  }>;
-  private assertProvenance;
-  private assertRateLimit;
-  private toRecord;
-  private pathForSource;
-}
 //#endregion
 //#region src/campaign/neutralize.d.ts
 /**
@@ -2471,7 +2309,7 @@ declare function sequentialOptimizationMethod<S extends Scenario, A>(options: {
 //#endregion
 //#region src/artifact-validator.d.ts
 /** An artifact an agent produced, as completion and produced-state checks read it. */
-interface Artifact {
+interface ValidatedArtifact {
   /** Logical kind — validators type-guard on this */
   kind: 'file' | 'json' | 'text' | 'binary' | string;
   /** Filesystem-style path, optional */
@@ -2510,8 +2348,8 @@ interface ProducedProposal {
 }
 /** Everything observable about what a run actually produced. */
 interface ProducedState {
-  /** Persisted vault artifacts. Reuses the shared `Artifact` shape. */
-  artifacts: Artifact[];
+  /** Persisted vault artifacts. Reuses the shared `ValidatedArtifact` shape. */
+  artifacts: ValidatedArtifact[];
   /** Proposals / filings the agent created. */
   proposals: ProducedProposal[];
   /** Names of tools the agent invoked. */
@@ -2687,6 +2525,104 @@ type RuntimeEventLike = ToolCallEventLike | ArtifactEventLike | ProposalEventLik
  */
 declare function extractProducedState(events: readonly RuntimeEventLike[]): ProducedState;
 //#endregion
+//#region src/campaign/presets/playback.d.ts
+/** One step of a user story — what the user does. The driver interprets
+ *  `payload` (a Playwright selector + action, or a sandbox chat turn). */
+interface PlaybackStep {
+  /** Human-readable action, captured verbatim in the UX narrative. */
+  action: string;
+  /** Driver-specific payload (e.g. `{ selector, fill }` or `{ turn }`). */
+  payload?: Record<string, unknown>;
+}
+/**
+ * A user story = a runnable product journey plus the requirements that define
+ * "this story works". Each requirement is one Jira ticket line. Extends
+ * `Scenario` so a catalog drops straight into `runProfileMatrix({ scenarios })`.
+ */
+interface UserStory extends Scenario {
+  /** Human-readable story title (the ticket headline). */
+  title: string;
+  /** Ordered steps the driver executes. */
+  steps: PlaybackStep[];
+  /** What must hold in the produced state for the story to pass. */
+  requirements: CompletionRequirement[];
+}
+/** Dispatch context plus the profile under test (which cheap model, etc.). */
+interface PlaybackContext extends DispatchContext {
+  profile: AgentProfile;
+}
+/**
+ * Drives the real product through a story and returns the runtime event stream
+ * `extractProducedState` consumes. Implemented by CONSUMERS —
+ * `SandboxPlaybackDriver` (real API / sandbox workspace) and
+ * `PlaywrightPlaybackDriver` (real UI) — because they depend on runtime /
+ * browser infra the substrate must not import. The driver MUST report LLM
+ * usage through `ctx.cost.runPaidCall` so the backend-integrity check sees real
+ * tokens (a run that never reports tokens reads as a stub).
+ */
+interface PlaybackDriver<TStory extends UserStory = UserStory> {
+  run(story: TStory, ctx: PlaybackContext): Promise<readonly RuntimeEventLike[]>;
+}
+/** A scored user story — the completion verdict plus its human title. */
+interface UserStoryVerdict extends CompletionVerdict {
+  title: string;
+}
+/**
+ * Score one story's produced state against its requirements. Thin wrapper over
+ * `verifyCompletion` that builds the gold from the story and returns a
+ * per-requirement PASS/FAIL verdict. `checkCorrectness` is injected — a
+ * deterministic stub in tests, `createLlmCorrectnessChecker` in production.
+ */
+declare function scoreUserStory(story: UserStory, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<UserStoryVerdict>;
+/** One row of the launch scoreboard — story × requirement → PASS/FAIL. */
+interface ScoreboardRow {
+  storyId: string;
+  storyTitle: string;
+  reqId: string;
+  reqTitle: string;
+  status: 'PASS' | 'FAIL';
+  evidence: string[];
+}
+/**
+ * Flatten story verdicts into the per-requirement scoreboard — the literal
+ * Jira tick-off: one row per (story, requirement) with PASS/FAIL and the
+ * evidence behind the verdict.
+ */
+declare function userStoryScoreboard(verdicts: readonly UserStoryVerdict[]): ScoreboardRow[];
+/** Launch-readiness headline counts rolled up from the per-requirement rows. */
+interface ScoreboardSummary {
+  /** Distinct user stories on the board. */
+  stories: number;
+  /** Stories whose every requirement passed. */
+  storiesFullyComplete: number;
+  /** Total (story, requirement) rows. */
+  requirements: number;
+  /** Rows with status PASS. */
+  passed: number;
+  /** Rows with status FAIL. */
+  failed: number;
+  /** passed / requirements; 0 when there are no rows. */
+  passRate: number;
+}
+/** Roll the per-requirement rows up into the launch headline counts. */
+declare function scoreboardSummary(rows: readonly ScoreboardRow[]): ScoreboardSummary;
+interface ScoreboardRenderOptions {
+  /** Document H1. Defaults to a generic playback title. */
+  title?: string;
+  /** Key/value run metadata rendered under the headline (runId, backend, model, date). */
+  meta?: Record<string, string>;
+  /** Max chars of joined evidence shown per row. Default 160. */
+  maxEvidenceChars?: number;
+}
+/**
+ * Render the scoreboard as a launch-readiness Markdown document — the literal
+ * "tick off every user story" artifact: a headline roll-up, the open tickets
+ * (FAIL rows) up top as the launch blockers, then a per-story table of
+ * requirement → PASS/FAIL with the evidence behind each verdict. Pure: same
+ * rows in, same bytes out (no clock/random), so it is safe to snapshot.
+ */
+declare function renderScoreboardMarkdown(rows: readonly ScoreboardRow[], opts?: ScoreboardRenderOptions): string;
+//#endregion
 //#region src/integrity/backend-integrity.d.ts
 interface BackendIntegrityReport {
   /** Total records inspected. */
@@ -2735,12 +2671,6 @@ declare function assertRealBackend(records: ReadonlyArray<RunRecord>, opts?: {
 }): BackendIntegrityReport;
 //#endregion
 //#region src/campaign/presets/run-profile-matrix.d.ts
-/** Thrown when the matrix is misconfigured (no profiles, missing resolved model evidence,
- *  etc.). Distinct from `BackendIntegrityError`,
- *  which signals a stub backend at run time. */
-declare class ProfileMatrixError extends AgentEvalError {
-  constructor(message: string);
-}
 /** Dispatch for one cell: render `profile` against `scenario`, returning the
  *  artifact the judges score. Run LLM work through `ctx.cost.runPaidCall` —
  *  the integrity check depends on its receipt. */
@@ -2871,110 +2801,6 @@ interface RunProfileMatrixResult<TArtifact, TScenario extends Scenario> {
  */
 declare function runProfileMatrix<TScenario extends Scenario, TArtifact>(opts: RunProfileMatrixOptions<TScenario, TArtifact>): Promise<RunProfileMatrixResult<TArtifact, TScenario>>;
 //#endregion
-//#region src/campaign/presets/playback.d.ts
-/** One step of a user story — what the user does. The driver interprets
- *  `payload` (a Playwright selector + action, or a sandbox chat turn). */
-interface PlaybackStep {
-  /** Human-readable action, captured verbatim in the UX narrative. */
-  action: string;
-  /** Driver-specific payload (e.g. `{ selector, fill }` or `{ turn }`). */
-  payload?: Record<string, unknown>;
-}
-/**
- * A user story = a runnable product journey plus the requirements that define
- * "this story works". Each requirement is one Jira ticket line. Extends
- * `Scenario` so a catalog drops straight into `runProfileMatrix({ scenarios })`.
- */
-interface UserStory extends Scenario {
-  /** Human-readable story title (the ticket headline). */
-  title: string;
-  /** Ordered steps the driver executes. */
-  steps: PlaybackStep[];
-  /** What must hold in the produced state for the story to pass. */
-  requirements: CompletionRequirement[];
-}
-/** Dispatch context plus the profile under test (which cheap model, etc.). */
-interface PlaybackContext extends DispatchContext {
-  profile: AgentProfile;
-}
-/**
- * Drives the real product through a story and returns the runtime event stream
- * `extractProducedState` consumes. Implemented by CONSUMERS —
- * `SandboxPlaybackDriver` (real API / sandbox workspace) and
- * `PlaywrightPlaybackDriver` (real UI) — because they depend on runtime /
- * browser infra the substrate must not import. The driver MUST report LLM
- * usage through `ctx.cost.runPaidCall` so the backend-integrity check sees real
- * tokens (a run that never reports tokens reads as a stub).
- */
-interface PlaybackDriver<TStory extends UserStory = UserStory> {
-  run(story: TStory, ctx: PlaybackContext): Promise<readonly RuntimeEventLike[]>;
-}
-/**
- * Adapt a `PlaybackDriver` into a `runProfileMatrix` dispatch. The artifact the
- * matrix scores is the `ProducedState` extracted from the driver's event
- * stream — grade it with `scoreUserStory` (or a judge wrapping it).
- */
-declare function makePlaybackDispatch<TStory extends UserStory>(driver: PlaybackDriver<TStory>): ProfileDispatchFn<TStory, ProducedState>;
-/** A scored user story — the completion verdict plus its human title. */
-interface UserStoryVerdict extends CompletionVerdict {
-  title: string;
-}
-/**
- * Score one story's produced state against its requirements. Thin wrapper over
- * `verifyCompletion` that builds the gold from the story and returns a
- * per-requirement PASS/FAIL verdict. `checkCorrectness` is injected — a
- * deterministic stub in tests, `createLlmCorrectnessChecker` in production.
- */
-declare function scoreUserStory(story: UserStory, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<UserStoryVerdict>;
-/** One row of the launch scoreboard — story × requirement → PASS/FAIL. */
-interface ScoreboardRow {
-  storyId: string;
-  storyTitle: string;
-  reqId: string;
-  reqTitle: string;
-  status: 'PASS' | 'FAIL';
-  evidence: string[];
-}
-/**
- * Flatten story verdicts into the per-requirement scoreboard — the literal
- * Jira tick-off: one row per (story, requirement) with PASS/FAIL and the
- * evidence behind the verdict.
- */
-declare function userStoryScoreboard(verdicts: readonly UserStoryVerdict[]): ScoreboardRow[];
-/** Launch-readiness headline counts rolled up from the per-requirement rows. */
-interface ScoreboardSummary {
-  /** Distinct user stories on the board. */
-  stories: number;
-  /** Stories whose every requirement passed. */
-  storiesFullyComplete: number;
-  /** Total (story, requirement) rows. */
-  requirements: number;
-  /** Rows with status PASS. */
-  passed: number;
-  /** Rows with status FAIL. */
-  failed: number;
-  /** passed / requirements; 0 when there are no rows. */
-  passRate: number;
-}
-/** Roll the per-requirement rows up into the launch headline counts. */
-declare function scoreboardSummary(rows: readonly ScoreboardRow[]): ScoreboardSummary;
-interface ScoreboardRenderOptions {
-  /** Document H1. Defaults to a generic playback title. */
-  title?: string;
-  /** Key/value run metadata rendered under the headline (runId, backend, model, date). */
-  meta?: Record<string, string>;
-  /** Max chars of joined evidence shown per row. Default 160. */
-  maxEvidenceChars?: number;
-}
-/**
- * Render the scoreboard as a launch-readiness Markdown document — the literal
- * "tick off every user story" artifact: a headline roll-up, the open tickets
- * (FAIL rows) up top as the launch blockers, then a per-story table of
- * requirement → PASS/FAIL with the evidence behind each verdict. Pure: same
- * rows in, same bytes out (no clock/random), so it is safe to snapshot.
- */
-declare function renderScoreboardMarkdown(rows: readonly ScoreboardRow[], opts?: ScoreboardRenderOptions): string;
-//#endregion
 //#region src/campaign/presets/segmented-profile-matrix.d.ts
 interface ProfileMatrixRow {
   rowId: string;
@@ -3105,12 +2931,6 @@ declare function createRetainedDispatch<Lane extends string, T>(options: Retaine
 };
 //#endregion
 //#region src/campaign/run-dir.d.ts
-/** The shared, out-of-repo root for campaign/benchmark run bundles. Keeping run
- *  outputs here means they never land in a repo working tree (no per-repo
- *  gitignore, no clutter, no accidental commits). Layout:
- *    ~/.tangle/traces/<repo>/runs/<runName>/
- *  where <repo> disambiguates runs across repos in one place. */
-declare function tangleTracesRoot(): string;
 /** Resolve a campaign `runDir`. An absolute path is honored as-is (the caller
  *  chose an explicit location). A bare name is placed under the shared home root
  *  so bundles never pollute a repo working tree — the default the harness should
@@ -3158,19 +2978,6 @@ interface DiscriminationScore {
 declare function scoreDiscrimination(signals: ScenarioSignal[], opts?: {
   saturationCeiling?: number;
 }): DiscriminationScore[];
-/**
- * Select the top-`k` most discriminative scenario ids for a holdout, EXCLUDING
- * fully saturated ties when enough non-tied scenarios exist (a tie in the
- * holdout wastes a paired cell).
- *
- * Prefers non-tied scenarios; if fewer than `k` non-tied exist, fills with the
- * least-saturated tied ones (tied scenarios are already ordered least-saturated
- * first by `meanScore` asc). Deterministic. Throws if `k < 1`. If
- * `signals.length <= k`, returns all ids in discrimination order.
- */
-declare function selectDiscriminative(signals: ScenarioSignal[], k: number, opts?: {
-  saturationCeiling?: number;
-}): string[];
 //#endregion
 //#region src/campaign/search-campaign-cell.d.ts
 /**
@@ -3278,37 +3085,6 @@ interface UpstreamEvaluationContext {
   readonly signal: AbortSignal;
   readonly callId?: string;
 }
-type PaidEvaluationOptions<TResult> = Pick<RunPaidCallInput<TResult>, 'maximumCharge' | 'receipt' | 'receiptFromError'> & {
-  model: string;
-};
-interface UpstreamJudgeOptions<TScenario extends Scenario> {
-  name?: string;
-  dimension?: string;
-  judgeVersion?: string;
-  appliesTo?: (scenario: TScenario) => boolean;
-  /** Convert the upstream score when its native scale is not higher-is-better. */
-  toComposite?: (score: number) => number;
-}
-declare function phoenixEvaluatorJudge<TRecord extends Record<string, unknown>, TArtifact, TScenario extends Scenario = Scenario>(evaluator: PhoenixEvaluatorLike<TRecord>, options: UpstreamJudgeOptions<TScenario> & {
-  mapInput(input: {
-    artifact: TArtifact;
-    scenario: TScenario;
-  }): TRecord;
-  paidCall?: PaidEvaluationOptions<PhoenixEvaluationResultLike>;
-}): JudgeConfig<TArtifact, TScenario>;
-declare function autoevalsScorerJudge<TInput extends Record<string, unknown>, TArtifact, TScenario extends Scenario = Scenario>(scorer: AutoevalsScorerLike<TInput>, options: UpstreamJudgeOptions<TScenario> & {
-  name: string;
-  mapInput(input: {
-    artifact: TArtifact;
-    scenario: TScenario;
-  }): TInput;
-} & ({
-  kind: 'CODE';
-  paidCall?: never;
-} | {
-  kind: 'LLM';
-  paidCall: PaidEvaluationOptions<AutoevalsScoreLike>;
-})): JudgeConfig<TArtifact, TScenario>;
 //#endregion
 //#region src/campaign/worktree/index.d.ts
 type GitOutput = string | Uint8Array;
@@ -3338,11 +3114,6 @@ interface WorktreeAdapter {
   /** Idempotently remove the worktree and branch. Safe to retry after partial cleanup. */
   discard(worktree: Worktree): Promise<void>;
 }
-/** Typed failure from a `WorktreeAdapter` operation (create/finalize/discard) — wraps the underlying git error as `cause`. */
-declare class WorktreeAdapterError extends Error {
-  readonly cause?: unknown;
-  constructor(message: string, cause?: unknown);
-}
 interface GitWorktreeAdapterOptions {
   /** Repo root the worktrees fork from. */
   repoRoot: string;
@@ -3378,5 +3149,5 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 //#endregion
-export { ScoreboardRow as $, RunImprovementLoopOptions as $i, TraceAnalystScenario as $n, GepaOptimizationRecipe as $r, importExternalEvaluations as $t, ScenarioSignal as A, CampaignCoverage as Aa, GepaCandidatePopulationSummary as Ai, CrossSurfaceComponentEvidence as An, DEFAULT_RED_TEAM_CORPUS as Ar, RequirementCheck as At, FinalizedProfileMatrixResult as B, ReferenceEquivalenceJudgeInput as Bi, CrossSurfaceInteractionTask as Bn, CanaryKind as Br, FsLabeledScenarioStoreOptions as Bt, SingleRunLockOptions as C, CacheRead as Ca, compareOptimizationMethods as Ci, CrossSurfaceBootstrapPolicy as Cn, campaignMeanComposite as Cr, extractProducedState as Ct, searchProposalExecution as D, cellCachePath as Da, costFromLedgerSummary as Di, CrossSurfaceCandidateOutcome as Dn, DefaultProductionGateOptions as Dr, LlmCorrectnessCheckerOpts as Dt, searchModelIdentity as E, buildCellSchedule as Ea, combineComparisonCosts as Ei, CrossSurfaceCandidateEvidence as En, DefaultProductionGateCheck as Er, CorrectnessChecker as Et, RetainedDispatchOptions as F, campaignSplitDigest as Fa, ExternalOptimizerObservationSummary as Fi, CrossSurfaceIneligibilityReason as Fn, redTeamDataset as Fr, verifyCompletion as Ft, RunProfileMatrixSegmentOptions as G, runReferenceEquivalenceJudge as Gi, CrossSurfacePairwiseEntry as Gn, SkillOptOptimizationMethodConfig as Gr, ScoredRollout as Gt, ProfileMatrixPlan as H, ReferenceEquivalenceJudgeResult as Hi, CrossSurfacePairCompatibility as Hn, CanaryReport as Hr, RolloutArgumentDiff as Ht, RetainedDispatchOutcome as I, campaignSplitDigestFromIdentities as Ia, ExternalOptimizerSubmittedCandidate as Ii, CrossSurfaceInteractionAwareSelection as In, redTeamReport as Ir, scopedOptimizationMethod as It, runProfileMatrixSegment as J, llmJudge as Ji, CrossSurfaceSelectionPolicy as Jn, skillOptOptimizationMethod as Jr, rolloutArgumentDiff as Jt, createProfileMatrixPlan as K, LlmJudgeDimension as Ki, CrossSurfaceRankedSingle as Kn, SkillOptRunnerCommand as Kr, UngroundedLiteralReport as Kt, createRetainedDispatch as L, readExternalOptimizerObservationArtifact as Li, CrossSurfaceInteractionEffect as Ln, scoreRedTeamOutput as Lr, sequentialOptimizationMethod as Lt, selectDiscriminative as M, assertCampaignSplitIdentity as Ma, readGepaCandidatePopulationArtifact as Mi, CrossSurfaceDistribution as Mn, RedTeamCategory as Mr, TaskGold as Mt, resolveRunDir as N, campaignCoverage as Na, ExternalOptimizerExecutionSummary as Ni, CrossSurfaceEligibility as Nn, RedTeamFinding as Nr, completionVerdict as Nt, searchReceiptAccounting as O, FinalEvidencePolicy as Oa, GepaCandidatePopulationArtifact as Oi, CrossSurfaceCandidateSummary as On, DefaultProductionRewardHackingOptions as Or, ProducedProposal as Ot, tangleTracesRoot as P, campaignScenarioIdentity as Pa, ExternalOptimizerObservationArtifact as Pi, CrossSurfaceEvidenceBreakdown as Pn, RedTeamReport as Pr, createLlmCorrectnessChecker as Pt, ScoreboardRenderOptions as Q, transientDispatchFailure as Qi, TraceAnalystArtifact as Qn, GepaOptimizationMethodConfig as Qr, externalSurface as Qt, CreateProfileMatrixPlanOptions as R, REFERENCE_EQUIVALENCE_INPUT_LIMITS as Ri, CrossSurfaceInteractionPath as Rn, CanaryAlert as Rr, neutralizeText as Rt, SingleRunLock as S, CacheIssueReason as Sa, OptimizationTokenUsage as Si, CrossSurfaceBestSingleSelection as Sn, campaignBreakdown as Sr, ToolCallEventLike as St, campaignCellSearchResult as T, CellScheduleSlot as Ta, ComparisonCost as Ti, CrossSurfaceCandidateComparison as Tn, heldOutGate as Tr, CompletionVerdict as Tt, ProfileMatrixRow as U, ReferenceEquivalenceScenario as Ui, CrossSurfacePairEvidence as Un, runCanaries as Ur, RolloutArgumentDiffOptions as Ut, ProfileMatrixCoverage as V, ReferenceEquivalenceJudgeOptions as Vi, CrossSurfaceNaiveStackSelection as Vn, CanaryOptions as Vr, LabeledScenarioStoreError as Vt, ProfileMatrixSegmentResult as W, createReferenceEquivalenceJudge as Wi, CrossSurfacePairIncompatibilityReason as Wn, composeGate as Wr, RolloutCall as Wt, PlaybackDriver as X, isTransientTransportFailure as Xi, CrossSurfaceTaskRow as Xn, GepaEngineOptions as Xr, GepaEvaluationImport as Xt, PlaybackContext as Y, TransientFailureOptions as Yi, CrossSurfaceSelections as Yn, GepaAdaptiveEngineRun as Yr, ExternalSearchOptimizer as Yt, PlaybackStep as Z, quotaExhaustedUntil as Zi, BuildTraceAnalystSurfaceDispatchOptions as Zn, GepaEngineRun as Zr, GepaPopulationImport as Zt, componentSurfaceIdentityMaterial as _, runCampaign as _a, OptimizationMethodProvenance as _i, analyzeCrossSurfaceInteractions as _n, provenanceRecordPath as _r, assertRealBackend as _t, WorktreeAdapterError as a, runOptimization as aa, ExternalTextOptimizationMethodConfig as ai, EvalFixture as an, LoopProvenanceArgsFromResult as ar, scoreUserStory as at, surfaceDispatchRef as b, PlanCampaignRunOptions as ba, OptimizationMethodScore as bi, CrossSurfaceAdditionRejectionReason as bn, CampaignBreakdown as br, ProposalEventLike as bt, verifyCodeSurface as c, SearchLedgerIntegrityError as ca, ExternalOptimizationExample as ci, EvalFixtureRunPlan as cn, LoopProvenanceEvidence as cr, ProfileDispatchFn as ct, PhoenixEvaluationResultLike as d, openAutoPr as da, CompareOptimizationMethodsOptions as di, LoadEvalFixtureScenariosOptions as dn, buildLoopProvenanceRecord as dr, RunProfileMatrixOptions as dt, RunImprovementLoopResult as ea, GepaRunnerCommand as ei, importGepaPopulation as en, buildTraceAnalystSurfaceDispatch as er, ScoreboardSummary as et, PhoenixEvaluatorLike as f, RunEvalOptions as fa, OptimizationMethod as fi, PlanEvalFixtureRunOptions as fn, campaignMeasurementDigest as fr, RunProfileMatrixResult as ft, codeSurfaceIdentityMaterial as g, RunCampaignOptions as ga, OptimizationMethodPairwise as gi, planEvalFixtureRun as gn, loopProvenanceSpans as gr, BackendIntegrityReport as gt, assertCodeSurfaceIdentity as h, CampaignCellRetryPolicy as ha, OptimizationMethodInput as hi, loadEvalFixtureScenarios as hn, loopProvenanceArgsFromResult as hr, BackendIntegrityError as ht, WorktreeAdapter as i, RunOptimizationResult as ia, externalTextOptimizationMethod as ii, neutralizationGate as in, EmitLoopProvenanceResult as ir, renderScoreboardMarkdown as it, scoreDiscrimination as j, assertCampaignDesign as ja, GepaCandidateSelectionScore as ji, CrossSurfaceCompositionStep as jn, RedTeamCase as jr, SatisfiedBy as jt, DiscriminationScore as k, FinalEvidenceUse as ka, GepaCandidatePopulationCandidate as ki, CrossSurfaceComponent as kn, defaultProductionGate as kr, ProducedState as kt, AutoevalsScoreLike as l, OpenAutoPrOptions as la, ExternalTextEvaluationResponse as li, EvalFixtureScenario as ln, LoopProvenanceOptimizationMethod as lr, ProfileMatrixError as lt, phoenixEvaluatorJudge as m, CampaignCellFailureReceipt as ma, OptimizationMethodComposition as mi, loadEvalFixture as mn, emitLoopProvenance as mr, runProfileMatrix as mt, GitWorktreeAdapterOptions as n, PremeasuredOptimizationBaseline as na, OpenAICompatibleOptimizerModel as ni, recordSkillOptSearch as nn, BuildLoopProvenanceArgs as nr, UserStoryVerdict as nt, gitWorktreeAdapter as o, SearchLedgerConflictError as oa, ExternalTextOptimizerContext as oi, EvalFixtureFile as on, LoopProvenanceBackend as or, scoreboardSummary as ot, autoevalsScorerJudge as p, runEval as pa, OptimizationMethodComparison as pi, discoverEvalFixtures as pn, canonicalDigest as pr, ScenarioRollup as pt, finalizeProfileMatrix as q, LlmJudgeOptions as qi, CrossSurfaceRelativeCost as qn, SkillOptTrainerConfig as qr, classifyUngroundedLiterals as qt, Worktree as r, RunOptimizationOptions as ra, OptimizerModelBudget as ri, NeutralizationGateOptions as rn, EmitLoopProvenanceArgs as rr, makePlaybackDispatch as rt, resolveWorktreePath as s, SearchLedgerError as sa, ExternalTextOptimizerResult as si, EvalFixtureLoadOptions as sn, LoopProvenanceCandidate as sr, userStoryScoreboard as st, CodeSurfaceVerification as t, runImprovementLoop as ta, gepaOptimizationMethod as ti, recordGepaSearch as tn, traceAnalystQualityJudge as tr, UserStory as tt, AutoevalsScorerLike as u, OpenAutoPrResult as ua, decodeExternalTextCandidate as ui, EvalFixtureValidationMode as un, LoopProvenanceRecord as ur, ProfileSummary as ut, renderSurfaceDiff as v, CampaignRunPlan as va, OptimizationMethodResult as vi, AnalyzeCrossSurfaceInteractionsInput as vn, provenanceSpansPath as vr, summarizeBackendIntegrity as vt, acquireSingleRunLock as w, readCachedCell as wa, optimizationTokenUsageFromSummary as wi, CrossSurfaceCandidate as wn, HeldOutGateOptions as wr, CompletionRequirement as wt, surfaceHash as x, planCampaignRun as xa, OptimizationPackageSource as xi, CrossSurfaceAttemptCompleteness as xn, CampaignComparisonUnits as xr, RuntimeEventLike as xt, surfaceContentHash as y, CampaignRunPlanCell as ya, OptimizationMethodRunOptions as yi, CrossSurfaceAdditionDecision as yn, verifyLoopProvenanceRecord as yr, ArtifactEventLike as yt, FinalizeProfileMatrixOptions as z, REFERENCE_EQUIVALENCE_JUDGE_VERSION as zi, CrossSurfaceInteractionReport as zn, CanaryEvaluation as zr, FsLabeledScenarioStore as zt };
-//# sourceMappingURL=index-NvGBiO8H.d.ts.map
+export { summarizeBackendIntegrity as $, campaignCoverage as $i, CampaignComparisonUnits as $n, OptimizationMethodRunOptions as $r, PlanEvalFixtureRunOptions as $t, RetainedDispatchOptions as A, runOptimization as Ai, CrossSurfacePairEvidence as An, OptimizationMethodScore as Ar, sequentialOptimizationMethod as At, RunProfileMatrixSegmentOptions as B, CampaignRunPlan as Bi, TraceAnalystScenario as Bn, OptimizerModelBudget as Br, GepaPopulationImport as Bt, searchModelIdentity as C, transientDispatchFailure as Ci, CrossSurfaceInteractionAwareSelection as Cn, SkillOptOptimizationMethodConfig as Cr, RequirementCheck as Ct, ScenarioSignal as D, PremeasuredOptimizationBaseline as Di, CrossSurfaceInteractionTask as Dn, CompareOptimizationMethodsOptions as Dr, createLlmCorrectnessChecker as Dt, DiscriminationScore as E, runImprovementLoop as Ei, CrossSurfaceInteractionReport as En, skillOptOptimizationMethod as Er, completionVerdict as Et, FinalizedProfileMatrixResult as F, runEval as Fi, CrossSurfaceSelectionPolicy as Fn, GepaOptimizationMethodConfig as Fr, RolloutCall as Ft, ProfileSummary as G, CacheRead as Gi, LoopProvenanceBackend as Gn, ExternalOptimizationExample as Gr, neutralizationGate as Gt, finalizeProfileMatrix as H, PlanCampaignRunOptions as Hi, EmitLoopProvenanceArgs as Hn, ExternalTextOptimizationMethodConfig as Hr, importExternalEvaluations as Ht, ProfileMatrixCoverage as I, CampaignCellFailureReceipt as Ii, CrossSurfaceSelections as In, GepaOptimizationRecipe as Ir, ScoredRollout as It, ScenarioRollup as J, cellCachePath as Ji, LoopProvenanceOptimizationMethod as Jn, OptimizationMethod as Jr, EvalFixtureLoadOptions as Jt, RunProfileMatrixOptions as K, CellScheduleSlot as Ki, LoopProvenanceCandidate as Kn, ExternalTextEvaluationResponse as Kr, EvalFixture as Kt, ProfileMatrixPlan as L, CampaignCellRetryPolicy as Li, CrossSurfaceTaskRow as Ln, GepaRunnerCommand as Lr, UngroundedLiteralReport as Lt, createRetainedDispatch as M, OpenAutoPrResult as Mi, CrossSurfacePairwiseEntry as Mn, GepaAdaptiveEngineRun as Mr, FsLabeledScenarioStoreOptions as Mt, CreateProfileMatrixPlanOptions as N, openAutoPr as Ni, CrossSurfaceRankedSingle as Nn, GepaEngineOptions as Nr, RolloutArgumentDiff as Nt, scoreDiscrimination as O, RunOptimizationOptions as Oi, CrossSurfaceNaiveStackSelection as On, OptimizationMethodComparison as Or, verifyCompletion as Ot, FinalizeProfileMatrixOptions as P, RunEvalOptions as Pi, CrossSurfaceRelativeCost as Pn, GepaEngineRun as Pr, RolloutArgumentDiffOptions as Pt, assertRealBackend as Q, assertCampaignDesign as Qi, CampaignBreakdown as Qn, OptimizationMethodResult as Qr, LoadEvalFixtureScenariosOptions as Qt, ProfileMatrixRow as R, RunCampaignOptions as Ri, BuildTraceAnalystSurfaceDispatchOptions as Rn, gepaOptimizationMethod as Rr, ExternalSearchOptimizer as Rt, campaignCellSearchResult as S, isTransientTransportFailure as Si, CrossSurfaceIneligibilityReason as Sn, composeGate as Sr, ProducedState as St, searchReceiptAccounting as T, RunImprovementLoopResult as Ti, CrossSurfaceInteractionPath as Tn, SkillOptTrainerConfig as Tr, TaskGold as Tt, runProfileMatrixSegment as U, planCampaignRun as Ui, EmitLoopProvenanceResult as Un, ExternalTextOptimizerContext as Ur, importGepaPopulation as Ut, createProfileMatrixPlan as V, CampaignRunPlanCell as Vi, BuildLoopProvenanceArgs as Vn, externalTextOptimizationMethod as Vr, externalSurface as Vt, ProfileDispatchFn as W, CacheIssueReason as Wi, LoopProvenanceArgsFromResult as Wn, ExternalTextOptimizerResult as Wr, NeutralizationGateOptions as Wt, BackendIntegrityError as X, FinalEvidenceUse as Xi, canonicalDigest as Xn, OptimizationMethodInput as Xr, EvalFixtureScenario as Xt, runProfileMatrix as Y, FinalEvidencePolicy as Yi, LoopProvenanceRecord as Yn, OptimizationMethodComposition as Yr, EvalFixtureRunPlan as Yt, BackendIntegrityReport as Z, CampaignCoverage as Zi, emitLoopProvenance as Zn, OptimizationMethodProvenance as Zr, EvalFixtureValidationMode as Zt, surfaceDispatchRef as _, ReferenceEquivalenceScenario as _i, CrossSurfaceComponentEvidence as _n, CanaryEvaluation as _r, CompletionRequirement as _t, gitWorktreeAdapter as a, GepaCandidatePopulationCandidate as ai, AnalyzeCrossSurfaceInteractionsInput as an, DefaultProductionGateOptions as ar, ScoreboardSummary as at, SingleRunLockOptions as b, llmJudge as bi, CrossSurfaceEligibility as bn, CanaryReport as br, LlmCorrectnessCheckerOpts as bt, AutoevalsScoreLike as c, readGepaCandidatePopulationArtifact as ci, CrossSurfaceAttemptCompleteness as cn, DEFAULT_RED_TEAM_CORPUS as cr, renderScoreboardMarkdown as ct, PhoenixEvaluatorLike as d, ExternalOptimizerObservationSummary as di, CrossSurfaceCandidate as dn, RedTeamFinding as dr, userStoryScoreboard as dt, campaignScenarioIdentity as ea, OptimizationPackageSource as ei, discoverEvalFixtures as en, campaignBreakdown as er, PlaybackContext as et, assertCodeSurfaceIdentity as f, ExternalOptimizerSubmittedCandidate as fi, CrossSurfaceCandidateComparison as fn, RedTeamReport as fr, ArtifactEventLike as ft, surfaceContentHash as g, ReferenceEquivalenceJudgeResult as gi, CrossSurfaceComponent as gn, CanaryAlert as gr, extractProducedState as gt, renderSurfaceDiff as h, ReferenceEquivalenceJudgeOptions as hi, CrossSurfaceCandidateSummary as hn, scoreRedTeamOutput as hr, ToolCallEventLike as ht, WorktreeAdapter as i, SearchLedgerIntegrityError as ia, GepaCandidatePopulationArtifact as ii, analyzeCrossSurfaceInteractions as in, DefaultProductionGateCheck as ir, ScoreboardRow as it, RetainedDispatchOutcome as j, OpenAutoPrOptions as ji, CrossSurfacePairIncompatibilityReason as jn, compareOptimizationMethods as jr, neutralizeText as jt, resolveRunDir as k, RunOptimizationResult as ki, CrossSurfacePairCompatibility as kn, OptimizationMethodPairwise as kr, scopedOptimizationMethod as kt, AutoevalsScorerLike as l, ExternalOptimizerExecutionSummary as li, CrossSurfaceBestSingleSelection as ln, RedTeamCase as lr, scoreUserStory as lt, componentSurfaceIdentityMaterial as m, ReferenceEquivalenceJudgeInput as mi, CrossSurfaceCandidateOutcome as mn, redTeamReport as mr, RuntimeEventLike as mt, GitWorktreeAdapterOptions as n, campaignSplitDigestFromIdentities as na, OptimizationTokenUsage as ni, loadEvalFixtureScenarios as nn, HeldOutGateOptions as nr, PlaybackStep as nt, resolveWorktreePath as o, GepaCandidatePopulationSummary as oi, CrossSurfaceAdditionDecision as on, DefaultProductionRewardHackingOptions as or, UserStory as ot, codeSurfaceIdentityMaterial as p, readExternalOptimizerObservationArtifact as pi, CrossSurfaceCandidateEvidence as pn, redTeamDataset as pr, ProposalEventLike as pt, RunProfileMatrixResult as q, buildCellSchedule as qi, LoopProvenanceEvidence as qn, decodeExternalTextCandidate as qr, EvalFixtureFile as qt, Worktree as r, SearchLedgerError as ra, costFromLedgerSummary as ri, planEvalFixtureRun as rn, heldOutGate as rr, ScoreboardRenderOptions as rt, verifyCodeSurface as s, GepaCandidateSelectionScore as si, CrossSurfaceAdditionRejectionReason as sn, defaultProductionGate as sr, UserStoryVerdict as st, CodeSurfaceVerification as t, campaignSplitDigest as ta, ComparisonCost as ti, loadEvalFixture as tn, campaignMeanComposite as tr, PlaybackDriver as tt, PhoenixEvaluationResultLike as u, ExternalOptimizerObservationArtifact as ui, CrossSurfaceBootstrapPolicy as un, RedTeamCategory as ur, scoreboardSummary as ut, surfaceHash as v, LlmJudgeDimension as vi, CrossSurfaceCompositionStep as vn, CanaryKind as vr, CompletionVerdict as vt, searchProposalExecution as w, RunImprovementLoopOptions as wi, CrossSurfaceInteractionEffect as wn, SkillOptRunnerCommand as wr, SatisfiedBy as wt, acquireSingleRunLock as x, TransientFailureOptions as xi, CrossSurfaceEvidenceBreakdown as xn, runCanaries as xr, ProducedProposal as xt, SingleRunLock as y, LlmJudgeOptions as yi, CrossSurfaceDistribution as yn, CanaryOptions as yr, CorrectnessChecker as yt, ProfileMatrixSegmentResult as z, runCampaign as zi, TraceAnalystArtifact as zn, OpenAICompatibleOptimizerModel as zr, GepaEvaluationImport as zt };
+//# sourceMappingURL=index-ZuWx52WG.d.ts.map