@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/index-DE5fb3EC.d.ts

@@ -0,0 +1,2244 @@
+import { t as DefaultVerdict } from "./verdict-Dps8_okt.js";
+import { c as ValidationError, t as AgentEvalError } from "./errors-CEk209JS.js";
+import { a as RunRecord, s as RunSplitTag } from "./run-record-CnZu_gjl.js";
+import { l as RawProviderSink } from "./raw-provider-sink-BU29Sh8h.js";
+import { c as CostLedgerHandle, p as CostReceipt } from "./cost-ledger-Dye6jCgg.js";
+import { A as ChatClient } from "./types-DGsxbAEd.js";
+import { c as EProcessState, d as PairedBootstrapOptions, f as PairedBootstrapResult, h as RiskDifferenceResult, u as McNemarResult } from "./statistics-Cmj6nynr.js";
+import { A as LabeledScenarioWrite, D as LabeledScenarioSampleArgs, E as LabeledScenarioRecord, O as LabeledScenarioSource, R as Scenario, S as JudgeConfig, T as LabelTrust, a as CampaignResult, b as GenerationRecord, d as DispatchContext, j as MutableSurface, k as LabeledScenarioStore, l as CodeSurface, p as Gate, u as ComponentSurface, w as JudgeScore } from "./types-k9tZGKUg.js";
+import { rn as PlanCampaignRunOptions, sn as CampaignStorage, tn as CampaignRunPlan } from "./skillopt-optimization-method-B7wX7XkF.js";
+import { n as AnalyzeTracesOptions, r as AnalyzeTracesResult, t as AnalyzeTracesInput } from "./analyst-BkTS3C58.js";
+import { o as LedgerHash } from "./index-BAvgST_9.js";
+import { AgentProfile, AgentProfile as AgentProfile$1, HarnessType, HarnessType as HarnessType$1 } from "@tangle-network/agent-interface";
+//#region src/campaign/analyst-surface.d.ts
+/**
+ * A labeled trace scenario: a FIXED trace corpus plus the failure modes a
+ * competent analyst MUST surface from it. The labels are ground truth — the
+ * objective failures that actually occurred — which is what makes optimizing
+ * the analyst prompt against them meaningful rather than circular.
+ */
+interface AnalystScenario extends Scenario {
+  kind: 'analyst-surface';
+  /** OTLP-JSONL path or an in-memory store of the traces to analyze. */
+  source: AnalyzeTracesOptions['source'];
+  /** The domain question handed to the analyst (framing lives here, not in
+   *  the surface under optimization). */
+  question: string;
+  /**
+   * Ground-truth failure modes a good analyst must identify. A finding "hits"
+   * a mode when it contains ANY of the mode's case-insensitive cues. Derive
+   * these from objective signal (failed task + which step broke), never from
+   * the analyst's own prior output.
+   */
+  expectedFailureModes: Array<{
+    id: string;
+    cues: string[];
+  }>;
+  /**
+   * Cues that mark a finding as HALLUCINATED / out-of-scope for this corpus —
+   * naming a tool, error, or failure that did not occur. Presence penalizes
+   * precision. Optional; omit to score recall only.
+   */
+  forbiddenCues?: string[];
+}
+/** The analyst's output for one scenario — the artifact the judge scores. */
+interface AnalystArtifact {
+  answer: string;
+  findings: string[];
+  /** The hardcoded-prompt version the analyst reported (provenance only; the
+   *  optimized surface overrides the actual prompt text used). */
+  actorPromptVersion: string;
+}
+interface BuildAnalystSurfaceDispatchOptions {
+  /**
+   * Everything `analyzeTraces` needs EXCEPT `actorDescription` (supplied by the
+   * surface under optimization) and `source` (supplied by the scenario). `ai`
+   * (the AxAIService) is required for a live run.
+   */
+  analystOptions: Omit<AnalyzeTracesOptions, 'actorDescription' | 'source'>;
+  /** Test seam: defaults to the real `analyzeTraces`. */
+  analyze?: (input: AnalyzeTracesInput, options: AnalyzeTracesOptions) => Promise<AnalyzeTracesResult>;
+}
+/**
+ * Build the `dispatchWithSurface(surface, scenario, ctx)` the improvement loop
+ * calls: run the analyst with `surface` as its actorDescription over the
+ * scenario's trace corpus and return its findings.
+ */
+declare function buildAnalystSurfaceDispatch(opts: BuildAnalystSurfaceDispatchOptions): (surface: MutableSurface, scenario: AnalystScenario, ctx: DispatchContext) => Promise<AnalystArtifact>;
+interface FailureModeRecallJudgeOptions {
+  /** Weight on recall when precision is also scored (forbiddenCues present).
+   *  Default 0.5 (equal). Recall-only when no forbiddenCues exist. */
+  recallWeight?: number;
+}
+/**
+ * Deterministic, ground-truth judge for analyst findings. Composite =
+ * recall of the scenario's `expectedFailureModes` (optionally blended with a
+ * precision term that penalizes findings tripping `forbiddenCues`). No LLM —
+ * the score is a function of the labels, so the analyst prompt is optimized
+ * toward surfacing real failures, not toward a judge it can flatter.
+ */
+declare function failureModeRecallJudge(opts?: FailureModeRecallJudgeOptions): JudgeConfig<AnalystArtifact, AnalystScenario>;
+//#endregion
+//#region src/paired-arms.d.ts
+/** One arm observation of one work item. Structural on purpose: callers
+ *  project their own record type (e.g. a `RunRecord`) into this shape. */
+interface PairedArmRow {
+  /** Matching key — rows sharing a `pairKey` across both arms form pairs
+   *  (typically the task/scenario/seed identity). */
+  pairKey: string;
+  /** Rep identity within a `pairKey` (e.g. a seed or rep number). Required on
+   *  every row of a `pairKey` that has more than one rep in either arm; reps
+   *  then pair only on exact (`pairKey`, `repKey`) match, never on outcome
+   *  content. Optional when each arm has at most one rep of the item. */
+  repKey?: string;
+  /** Arm label this row was produced under. */
+  arm: string;
+  /** Binary outcome; omit when the comparison has no pass/fail notion. */
+  pass?: boolean;
+  /** Named numeric measurements (score, cost, latency, …). */
+  metrics?: Record<string, number>;
+}
+interface PairArmsOptions {
+  /** Arm treated as the control side of every pair. */
+  baselineArm: string;
+  /** Arm treated as the treatment side of every pair. */
+  treatmentArm: string;
+}
+/** One matched (baseline, treatment) observation of the same work item. */
+interface MatchedPair {
+  pairKey: string;
+  /** 0-based position of this pair within its `pairKey`, ordered by sorted
+   *  `repKey` (always 0 for a single-rep item). The rep identity itself is on
+   *  the rows (`baseline.repKey` / `treatment.repKey`). */
+  repIndex: number;
+  baseline: PairedArmRow;
+  treatment: PairedArmRow;
+}
+interface PairArmsResult {
+  /** Matched pairs, ordered by (`pairKey`, `repIndex`). */
+  pairs: MatchedPair[];
+  /** Baseline rows left without a treatment counterpart — reported, never
+   *  silently dropped. */
+  unpairedBaseline: PairedArmRow[];
+  /** Treatment rows left without a baseline counterpart. */
+  unpairedTreatment: PairedArmRow[];
+}
+/**
+ * Match rows across two arms into (baseline, treatment) pairs by `pairKey`.
+ *
+ * A `pairKey` with at most one row per arm pairs directly, no `repKey`
+ * needed. A `pairKey` with multiple reps in either arm requires `repKey` on
+ * every one of its rows, and reps pair only on exact (`pairKey`, `repKey`)
+ * match — pairing is keyed purely on row identity, never on outcome content
+ * (outcome-keyed matching deflates discordant counts and biases McNemar), and
+ * is therefore independent of input order. Reps whose `repKey` has no
+ * counterpart in the other arm, and items present in only one arm, land in
+ * the unpaired lists — reported, never truncated.
+ *
+ * Fail-loud: throws when either named arm has zero rows (an unknown arm
+ * name would otherwise read as "everything unpaired"), when the two arm
+ * names are equal, when a multi-rep `pairKey` has a row without `repKey`, or
+ * when a (`pairKey`, arm) group repeats a `repKey` (the match would be
+ * ambiguous).
+ */
+declare function pairArms(rows: readonly PairedArmRow[], opts: PairArmsOptions): PairArmsResult;
+/** Paired pass/fail comparison over the pairs where BOTH sides carry `pass`. */
+interface PairedCorrectness {
+  /** Discordant pairs where the treatment passed and the baseline failed. */
+  b10: number;
+  /** Discordant pairs where the baseline passed and the treatment failed. */
+  b01: number;
+  /** Exact McNemar significance over the paired outcomes (`b === b10`, `c === b01`). */
+  mcnemar: McNemarResult;
+  /** Paired effect size: p(treatment) − p(baseline) with a paired-variance CI. */
+  riskDifference: RiskDifferenceResult;
+}
+/** Paired delta summary for one named metric (delta = treatment − baseline). */
+interface PairedMetricDelta {
+  name: string;
+  /** Pairs where BOTH sides carry a finite value for this metric. */
+  n: number;
+  /** Pairs where at least one side does not carry the metric. */
+  nMissing: number;
+  /** Median paired delta, or null when `n === 0`. */
+  medianDelta: number | null;
+  /** Mean paired delta, or null when `n === 0`. */
+  meanDelta: number | null;
+  /** Bootstrap CI on the paired delta (`pairedBootstrap`); null when
+   *  `n === 0` — a zero-width [0, 0] interval on no data would read as a
+   *  measured tight null. */
+  bootstrapCi: PairedBootstrapResult | null;
+  /** Wilcoxon signed-rank test on the paired deltas; null when `n === 0`. */
+  wilcoxon: {
+    w: number;
+    p: number;
+  } | null;
+}
+interface ComparePairedArmsOptions extends PairArmsOptions {
+  /** Metrics to compare. Default: every metric name observed on any matched
+   *  pair, sorted. A name that appears on no pair is still reported (with
+   *  `n = 0`) so a misspelled metric is visible instead of vanishing. */
+  metricNames?: string[];
+  /** Passed through to `pairedBootstrap` — set `seed` for reproducible CIs. */
+  bootstrap?: PairedBootstrapOptions;
+}
+interface PairedArmsComparison {
+  nPairs: number;
+  nUnpairedBaseline: number;
+  nUnpairedTreatment: number;
+  /** null when no matched pair carries `pass` on both sides — a pass/fail
+   *  verdict over rows that never measured pass/fail would be fabricated. */
+  correctness: PairedCorrectness | null;
+  metricDeltas: PairedMetricDelta[];
+}
+/**
+ * Full matched-pair arm comparison: pair via {@link pairArms}, then compose
+ * the paired estimators from `statistics` over the matched pairs.
+ *
+ * Correctness uses only the pairs where both sides carry `pass` (`mcnemar.n`
+ * is that subset's size); each metric uses only the pairs where both sides
+ * carry a finite value for it, with the remainder counted in `nMissing`.
+ * Deltas are treatment − baseline throughout.
+ *
+ * Fail-loud: inherits {@link pairArms}'s unknown-arm throw, and throws on a
+ * non-finite metric value — silently treating corrupt telemetry as "metric
+ * absent" would misreport it as missing coverage.
+ */
+declare function comparePairedArms(rows: readonly PairedArmRow[], opts: ComparePairedArmsOptions): PairedArmsComparison;
+interface MatchedRunRecordPair {
+  pairKey: string;
+  repKey: string;
+  baseline: RunRecord;
+  treatment: RunRecord;
+}
+interface PairRunRecordsResult {
+  pairs: MatchedRunRecordPair[];
+  unpairedBaseline: RunRecord[];
+  unpairedTreatment: RunRecord[];
+}
+/**
+ * Pair two RunRecord arms by the identity of the evaluated work:
+ * `(experimentId, scenarioId, seed)`.
+ *
+ * Falling back to array order, candidate id, or experiment id can compare
+ * different tasks and fabricate lift. Duplicate identities throw.
+ */
+declare function pairRunRecords(baselineRuns: readonly RunRecord[], treatmentRuns: readonly RunRecord[]): PairRunRecordsResult;
+//#endregion
+//#region src/campaign/cross-surface-types.d.ts
+/** Whether one candidate attempt produced a usable executable outcome. */
+type CrossSurfaceAttemptCompleteness = 'complete' | 'missing' | 'invalid';
+/** One independently proposed change on one caller-defined surface. */
+interface CrossSurfaceComponent {
+  componentId: string;
+  surfaceId: string;
+  /** Explicitly controls whether this component may anchor the best-single arm. */
+  bestSingleEligible: boolean;
+}
+/** Immutable identity for a single candidate or a materialized composition. */
+interface CrossSurfaceCandidate {
+  candidateId: string;
+  componentIds: string[];
+  contentHash: string;
+  artifactBytes: number;
+}
+/** Per-component trace evidence captured during one task attempt. */
+interface CrossSurfaceComponentEvidence {
+  componentId: string;
+  /** null means the trace could not establish whether the component fired. */
+  fired: boolean | null;
+  /** null means the trace could not establish whether the component changed behavior. */
+  effectObserved: boolean | null;
+}
+/**
+ * Canonical per-task input row. Consumers may extend this interface with
+ * receipt, trace, retry, or failure details; the report preserves the original
+ * row object rather than projecting those details away.
+ */
+interface CrossSurfaceTaskRow {
+  taskId: string;
+  candidateId: string;
+  /** Repeated here so every persisted row remains self-describing. */
+  componentIds: string[];
+  completeness: CrossSurfaceAttemptCompleteness;
+  pass: boolean | null;
+  score: number | null;
+  /**
+   * Per-attempt deployment measurements. Every declared metric must have a
+   * known, non-negative value. Proposal, analysis, and selection spend belongs
+   * in the search ledger rather than being spread across task cells.
+   */
+  cost: Record<string, number | null>;
+  componentEvidence: CrossSurfaceComponentEvidence[];
+  /** Required for missing or invalid attempts; forbidden for complete attempts. */
+  rejectReason: string | null;
+}
+interface CrossSurfaceBootstrapPolicy {
+  seed: number;
+  resamples: number;
+  confidence: number;
+}
+/** Predeclared candidate eligibility and composition policy. */
+interface CrossSurfaceSelectionPolicy {
+  minimumFiringTasks: number;
+  minimumEffectTasks: number;
+  requireObservedFiring: boolean;
+  requireObservedEffect: boolean;
+  /** Only named metrics are constrained; all declared metrics are still reported. */
+  maximumMedianCostRatioToBaseline: Record<string, number>;
+  /** A smaller terminal bundle is reported but cannot become the selected arm. */
+  minimumBundleComponents: number;
+}
+interface AnalyzeCrossSurfaceInteractionsInput<TRow extends CrossSurfaceTaskRow = CrossSurfaceTaskRow> {
+  components: readonly CrossSurfaceComponent[];
+  candidates: readonly CrossSurfaceCandidate[];
+  rows: readonly TRow[];
+  baselineCandidateId: string;
+  /** Exact shared task axis and its canonical output order. */
+  taskOrder: readonly string[];
+  /** Canonical materialization order for component sets and the naive stack. */
+  componentOrder: readonly string[];
+  /** Final deterministic tie-break; lower index wins. */
+  candidateOrder: readonly string[];
+  /** Declares every cost key and the order used for cost tie-breaks. */
+  costMetricOrder: readonly string[];
+  bootstrap: CrossSurfaceBootstrapPolicy;
+  selection: CrossSurfaceSelectionPolicy;
+}
+interface CrossSurfaceDistribution {
+  n: number;
+  min: number;
+  median: number;
+  mean: number;
+  max: number;
+  total: number;
+}
+interface CrossSurfaceEvidenceBreakdown {
+  componentId: string;
+  observedTaskIds: string[];
+  notObservedTaskIds: string[];
+  unobservedTaskIds: string[];
+}
+interface CrossSurfaceCandidateEvidence {
+  byComponent: CrossSurfaceEvidenceBreakdown[];
+  allObservedTaskIds: string[];
+  someObservedTaskIds: string[];
+  noneObservedTaskIds: string[];
+  unobservedTaskIds: string[];
+}
+type CrossSurfaceIneligibilityReason = 'missing_attempt' | 'invalid_attempt' | 'baseline_outcome_missing' | 'benefit_not_greater_than_regression' | 'firing_below_minimum' | 'firing_unobserved' | 'effect_below_minimum' | 'effect_unobserved' | 'cost_limit_exceeded';
+interface CrossSurfaceEligibility {
+  eligible: boolean;
+  reasons: CrossSurfaceIneligibilityReason[];
+}
+interface CrossSurfaceCandidateOutcome {
+  resolvedTaskIds: string[];
+  failedTaskIds: string[];
+  missingTaskIds: string[];
+  invalidTaskIds: string[];
+  benefitTaskIds: string[];
+  regressionTaskIds: string[];
+  comparisonMissingTaskIds: string[];
+  netBenefit: number;
+}
+interface CrossSurfaceCandidateSummary {
+  candidate: CrossSurfaceCandidate;
+  outcome: CrossSurfaceCandidateOutcome;
+  score: CrossSurfaceDistribution | null;
+  costs: Record<string, CrossSurfaceDistribution>;
+  firing: CrossSurfaceCandidateEvidence;
+  effect: CrossSurfaceCandidateEvidence;
+  /** Reuses the package's paired McNemar/risk-difference/bootstrap statistics. */
+  comparisonToBaseline: PairedArmsComparison | null;
+  /** null only for the fixed baseline. */
+  eligibility: CrossSurfaceEligibility | null;
+}
+interface CrossSurfaceRelativeCost {
+  treatmentMedian: number;
+  comparatorMedian: number;
+  medianDelta: number;
+  /** null when the comparator median is zero but the treatment median is not. */
+  medianRatio: number | null;
+}
+interface CrossSurfaceCandidateComparison {
+  comparatorCandidateId: string;
+  treatmentCandidateId: string;
+  winsTaskIds: string[];
+  regressionTaskIds: string[];
+  missingTaskIds: string[];
+  paired: PairedArmsComparison;
+  relativeCost: Record<string, CrossSurfaceRelativeCost>;
+}
+interface CrossSurfacePairEvidence {
+  bothTaskIds: string[];
+  leftOnlyTaskIds: string[];
+  rightOnlyTaskIds: string[];
+  neitherTaskIds: string[];
+  unobservedTaskIds: string[];
+}
+interface CrossSurfaceInteractionTask {
+  taskId: string;
+  /** Composition minus the additive expectation from the baseline and singles. */
+  passInteraction: number | null;
+  scoreInteraction: number | null;
+}
+interface CrossSurfaceInteractionEffect {
+  perTask: CrossSurfaceInteractionTask[];
+  n: number;
+  nMissing: number;
+  meanPassInteraction: number | null;
+  meanScoreInteraction: number | null;
+  passBootstrap: PairedBootstrapResult | null;
+  scoreBootstrap: PairedBootstrapResult | null;
+}
+type CrossSurfacePairIncompatibilityReason = 'constituent_not_ready' | 'pair_incomplete' | 'baseline_regression' | 'interference' | 'no_incremental_resolution' | 'firing_below_minimum' | 'firing_unobserved' | 'effect_below_minimum' | 'effect_unobserved' | 'cost_limit_exceeded';
+interface CrossSurfacePairCompatibility {
+  compatible: boolean;
+  reasons: CrossSurfacePairIncompatibilityReason[];
+  betterSingleCandidateId: string;
+}
+interface CrossSurfacePairwiseEntry {
+  componentIds: [string, string];
+  singleCandidateIds: [string, string];
+  compositionCandidateId: string;
+  benefitTaskIds: string[];
+  regressionTaskIds: string[];
+  synergyTaskIds: string[];
+  interferenceTaskIds: string[];
+  incrementalVsConstituents: [CrossSurfaceCandidateComparison, CrossSurfaceCandidateComparison];
+  relativeCostToBaseline: Record<string, CrossSurfaceRelativeCost>;
+  firing: CrossSurfacePairEvidence;
+  effect: CrossSurfacePairEvidence;
+  interaction: CrossSurfaceInteractionEffect;
+  compatibility: CrossSurfacePairCompatibility;
+}
+interface CrossSurfaceRankedSingle {
+  rank: number;
+  candidateId: string;
+  componentId: string;
+}
+interface CrossSurfaceBestSingleSelection {
+  candidateId: string;
+  componentId: string;
+  ranking: CrossSurfaceRankedSingle[];
+}
+interface CrossSurfaceNaiveStackSelection {
+  /** Every individually eligible single, stacked in canonical component order. */
+  candidateId: string;
+  componentIds: string[];
+}
+type CrossSurfaceAdditionRejectionReason = 'pair_incompatible' | 'full_bundle_not_evaluated' | 'bundle_incomplete' | 'baseline_regression' | 'no_incremental_resolution' | 'incremental_regression' | 'firing_below_minimum' | 'firing_unobserved' | 'effect_below_minimum' | 'effect_unobserved' | 'cost_limit_exceeded';
+interface CrossSurfaceAdditionDecision {
+  additionCandidateId: string;
+  additionComponentId: string;
+  bundleCandidateId: string | null;
+  incrementalResolutionTaskIds: string[];
+  incrementalRegressionTaskIds: string[];
+  incrementalMedianCost: Record<string, number> | null;
+  eligible: boolean;
+  selected: boolean;
+  reasons: CrossSurfaceAdditionRejectionReason[];
+}
+interface CrossSurfaceCompositionStep {
+  fromCandidateId: string;
+  retainedComponentIds: string[];
+  considered: CrossSurfaceAdditionDecision[];
+  selectedCandidateId: string | null;
+}
+/** One deterministic growth path starting from a compatible two-surface seed. */
+interface CrossSurfaceInteractionPath {
+  seedCandidateId: string;
+  terminalCandidateId: string;
+  terminalComponentIds: string[];
+  qualified: boolean;
+  steps: CrossSurfaceCompositionStep[];
+}
+interface CrossSurfaceInteractionAwareSelection {
+  /** Compatible pair that seeded the selected deterministic growth path. */
+  seedCandidateId: string;
+  /** Candidate reached by the winning path, even if the minimum size is not met. */
+  terminalCandidateId: string;
+  terminalComponentIds: string[];
+  /** null when no path produced a qualifying multi-component bundle. */
+  selectedCandidateId: string | null;
+  qualified: boolean;
+  /** Every compatible pair seed is retained so seed choice cannot hide an interaction. */
+  evaluatedPaths: CrossSurfaceInteractionPath[];
+  /** Convenience alias for the winning path's steps. */
+  steps: CrossSurfaceCompositionStep[];
+}
+interface CrossSurfaceSelections {
+  bestSingle: CrossSurfaceBestSingleSelection | null;
+  naiveStack: CrossSurfaceNaiveStackSelection | null;
+  interactionAware: CrossSurfaceInteractionAwareSelection | null;
+}
+interface CrossSurfaceInteractionReport<TRow extends CrossSurfaceTaskRow = CrossSurfaceTaskRow> {
+  taskIds: string[];
+  componentIds: string[];
+  candidateIds: string[];
+  costMetrics: string[];
+  /** Canonical candidate × task order; no input row is dropped. */
+  rows: TRow[];
+  missingAttempts: TRow[];
+  invalidAttempts: TRow[];
+  candidates: CrossSurfaceCandidateSummary[];
+  pairwise: CrossSurfacePairwiseEntry[];
+  selections: CrossSurfaceSelections;
+}
+//#endregion
+//#region src/campaign/cross-surface-interaction.d.ts
+/**
+ * Build the complete cross-surface evidence matrix and derive all three frozen
+ * candidates. The task/candidate/component orders are part of the input so
+ * neither insertion order nor an after-the-fact tie-break can change a result.
+ */
+declare function analyzeCrossSurfaceInteractions<TRow extends CrossSurfaceTaskRow>(input: AnalyzeCrossSurfaceInteractionsInput<TRow>): CrossSurfaceInteractionReport<TRow>;
+//#endregion
+//#region src/campaign/fixtures.d.ts
+type EvalFixtureValidationMode = 'vitest' | 'none';
+interface EvalFixtureFile {
+  path: string;
+  sha256: string;
+  bytes: number;
+}
+interface EvalFixture {
+  name: string;
+  path: string;
+  promptPath: string;
+  evalPath?: string;
+  packageJsonPath?: string;
+  prompt: string;
+  files: EvalFixtureFile[];
+  fingerprint: string;
+}
+interface EvalFixtureScenario extends Scenario {
+  kind: 'eval-fixture';
+  fixtureName: string;
+  fixturePath: string;
+  promptPath: string;
+  evalPath?: string;
+  packageJsonPath?: string;
+  prompt: string;
+  fingerprint: string;
+}
+interface EvalFixtureLoadOptions {
+  /** `vitest` requires EVAL.ts/EVAL.tsx and package.json type=module. `none` only requires PROMPT.md. */
+  validation?: EvalFixtureValidationMode;
+  /** Extra caller-owned knobs that affect fixture behavior, folded into the fingerprint. */
+  fingerprintConfig?: unknown;
+}
+interface LoadEvalFixtureScenariosOptions extends EvalFixtureLoadOptions {
+  names?: string[];
+}
+interface PlanEvalFixtureRunOptions<TArtifact = unknown> extends Pick<PlanCampaignRunOptions<EvalFixtureScenario, TArtifact>, 'dispatchRef' | 'judges' | 'seed' | 'reps' | 'resumable' | 'runDir'> {
+  evalsDir: string;
+  validation?: EvalFixtureValidationMode;
+  fingerprintConfig?: unknown;
+  names?: string[];
+  storage?: CampaignStorage;
+}
+type EvalFixtureRunPlan = CampaignRunPlan & {
+  fixtures: Array<Pick<EvalFixtureScenario, 'fixtureName' | 'fixturePath' | 'fingerprint'>>;
+};
+/** Walk `evalsDir` and return the relative name of every fixture directory (one containing an exact-case `PROMPT.md`). */
+declare function discoverEvalFixtures(evalsDir: string): string[];
+/**
+ * Load ONE fixture by name: reads `PROMPT.md` (plus `EVAL.ts`/`EVAL.tsx` and `package.json` under
+ * `vitest` validation) and content-fingerprints the full file set for cache identity.
+ */
+declare function loadEvalFixture(evalsDir: string, name: string, options?: EvalFixtureLoadOptions): EvalFixture;
+/** Load fixtures (all discovered, or just `names`) as campaign `Scenario`s tagged `eval-fixture`. */
+declare function loadEvalFixtureScenarios(evalsDir: string, options?: LoadEvalFixtureScenariosOptions): EvalFixtureScenario[];
+/**
+ * Dry-run planner for a fixture campaign: loads the scenarios, delegates to `planCampaignRun`,
+ * and returns the plan plus each fixture's name/path/fingerprint.
+ */
+declare function planEvalFixtureRun<TArtifact = unknown>(options: PlanEvalFixtureRunOptions<TArtifact>): EvalFixtureRunPlan;
+//#endregion
+//#region src/campaign/gates/neutralization-gate.d.ts
+interface NeutralizationGateOptions<TScenario extends Scenario = Scenario> {
+  scenarios: TScenario[];
+  /** Reject when the neutralized (content-blanked, footprint-matched) variant
+   *  reproduces at least this fraction of the candidate's held-out lift. Default
+   *  0.5 — if blanking the content keeps half the lift, the content is decorative.
+   *  Equality rejects: a neutralized lift == threshold·candidateLift is decorative. */
+  maxDecorativeFraction?: number;
+}
+/**
+ * Composable placebo gate: ships only when the candidate's held-out lift is NOT
+ * mostly reproduced by a footprint-matched neutralized variant.
+ */
+declare function neutralizationGate<TArtifact, TScenario extends Scenario>(options: NeutralizationGateOptions<TScenario>): Gate<TArtifact, TScenario>;
+//#endregion
+//#region src/pre-registration.d.ts
+/**
+ * Pre-registered hypotheses — declare what you're testing BEFORE the
+ * run, check it AFTER. Prevents p-hacking, optional stopping, and the
+ * "we ran until it looked good" failure mode.
+ *
+ * Manifest is a plain JSON-friendly object. Sign it with a content hash
+ * + timestamp; the registered record becomes immutable. Post-run,
+ * evaluate the manifest against observed results — the library refuses
+ * to let you re-interpret a different metric as the declared one.
+ */
+interface HypothesisManifest {
+  id: string;
+  /** Human prose — goes into the audit trail. */
+  hypothesis: string;
+  /** Metric the hypothesis claims to move. */
+  metric: string;
+  /** 'increase' = candidate should score higher than baseline; 'decrease' = lower. */
+  direction: 'increase' | 'decrease';
+  /** Minimum effect size to count (same units as the metric). */
+  minEffect: number;
+  /** Alpha threshold. */
+  alpha: number;
+  /** Target statistical power at which sample size was pre-computed. */
+  power: number;
+  /** Declared N per arm before running. */
+  preRegisteredN: number;
+  /** ISO8601 timestamp the manifest was registered. */
+  registeredAt: string;
+  /** Optional identifiers to tie into the trace corpus. */
+  baselineLabel?: string;
+  candidateLabel?: string;
+}
+/**
+ * Identifier for the hashing scheme used to produce `contentHash`.
+ *
+ * `'sha256-content'` — sha256 hex over the canonicalized manifest with
+ * the `contentHash` and `algo` fields stripped. Held as a string union
+ * so future schemes can be added without breaking parsers; SignedManifest
+ * values without `algo` deserialize cleanly because the field is optional.
+ */
+type SignedManifestAlgo = 'sha256-content';
+interface SignedManifest extends HypothesisManifest {
+  /** sha256 hex of canonicalized manifest (everything except contentHash and algo). */
+  contentHash: string;
+  /**
+   * Algorithm string describing how `contentHash` was produced.
+   *
+   * Optional on the type so serialized manifests without it still parse,
+   * but ALWAYS populated by {@link signManifest}. Consumers that want to
+   * enforce a known algorithm should reject manifests where this field
+   * is missing or unrecognized.
+   */
+  algo?: SignedManifestAlgo;
+}
+interface HypothesisResult {
+  manifest: SignedManifest;
+  observedN: number;
+  observedEffect: number;
+  observedPValue: number;
+  /** True iff the observed effect hits the pre-declared direction with
+   *  magnitude ≥ minEffect AND p < alpha. */
+  confirmed: boolean;
+  /** Enumerated reasons the hypothesis was rejected (each a machine-tag). */
+  rejectionReasons: Array<'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'>;
+  notes?: string;
+}
+/**
+ * Deterministic JSON canonicalization — sort object keys recursively.
+ *
+ * Two semantically-equal objects produce byte-identical canonicalized output;
+ * this is what makes a content-hash stable across encoders, key insertion
+ * orders, and runtime versions. Exported for any consumer that needs the same
+ * canonicalization guarantee outside the manifest-signing path (e.g., signing
+ * an artifact bundle, hashing a dataset version, etc.).
+ */
+declare function canonicalize(v: unknown): unknown;
+/**
+ * SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.
+ *
+ * The same primitive `signManifest` and `verifyManifest` are built on, exposed
+ * directly so consumers signing arbitrary structured content (artifact bundles,
+ * production packets, dataset manifests, etc.) don't have to re-derive
+ * canonicalize+sha256 from scratch.
+ *
+ * Stable across:
+ *   - object key insertion order (canonicalization sorts keys recursively)
+ *   - encoder choice (UTF-8 via TextEncoder, fixed)
+ *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
+ *
+ * Named `hashJson` to disambiguate from `prompt-registry.ts`'s `hashContent`,
+ * which takes a string input and returns a truncated 12-char prompt id.
+ * Use `hashJson` when you mean "canonicalize then hash."
+ *
+ * @example
+ *   const hash = await hashJson({ id: '1', kind: 'spec' })
+ *   // 'a3f1...' (64 hex chars)
+ */
+declare function hashJson<T>(obj: T): Promise<string>;
+/**
+ * Sign a manifest with a SHA-256 content hash.
+ *
+ * The hash covers the canonicalized manifest with the `contentHash`
+ * and `algo` fields stripped; this lets verifiers re-sign the rest and
+ * compare. Returned manifest always carries `algo: 'sha256-content'`
+ * so downstream consumers can identify the scheme; manifests without
+ * `algo` still verify because it is stripped before hashing on both sides.
+ */
+declare function signManifest(m: HypothesisManifest): Promise<SignedManifest>;
+/**
+ * Verify that a signed manifest has not been tampered with.
+ *
+ * Strips `contentHash` and `algo` before re-signing so manifests without
+ * `algo` verify identically to ones that carry it.
+ */
+declare function verifyManifest(m: SignedManifest): Promise<boolean>;
+/**
+ * Evaluate a pre-registered hypothesis against observed results.
+ * Mechanical — no re-interpretation permitted.
+ */
+declare function evaluateHypothesis(manifest: SignedManifest, observed: {
+  n: number;
+  effect: number;
+  pValue: number;
+}): Promise<HypothesisResult>;
+//#endregion
+//#region src/campaign/gates/sequential.d.ts
+type SequentialDecision = 'promote' | 'continue' | 'undecided-at-maxN';
+interface SequentialObservation {
+  decision: SequentialDecision;
+  /** Current e-value (the betting wealth) against H0. */
+  eValue: number;
+  /** Paired deltas consumed so far. */
+  n: number;
+  /** Names the decision basis. For 'undecided-at-maxN' it states explicitly
+   *  that exhausting the budget is NOT evidence of no effect. */
+  reason: string;
+}
+interface SequentialPairedGateOptions {
+  /** Type-I budget. With `preRegistration` bound this MUST match
+   *  `manifest.alpha` (conflict throws). Default 0.05. */
+  alpha?: number;
+  /** Minimum paired deltas before a promote may fire. The stopping rule is
+   *  "first n ≥ minN with e-value ≥ 1/alpha" — still a valid stopping time.
+   *  Default 5. */
+  minN?: number;
+  /** Pre-registered observation budget. Required unless `preRegistration`
+   *  supplies it via `preRegisteredN` (conflict throws). */
+  maxN?: number;
+  /** Bet truncation forwarded to `eProcess`. Default 0.5. */
+  maxBet?: number;
+  /** Bound on |delta| in the judge's native scale; deltas are mapped to
+   *  x = (d/scale + 1)/2 ∈ [0,1]. A delta outside ±scale throws (use
+   *  `detectScale` to pick 1 vs 100 BEFORE streaming). Default 1. */
+  scale?: number;
+  /** Seed for the data-independent shuffle of paired deltas in `decide(ctx)`
+   *  (exchangeability guard). Default 1337. */
+  shuffleSeed?: number;
+  /** Bind the pre-registered hypothesis. Verified (content hash) at
+   *  construction; alpha/maxN/direction/minEffect come FROM the manifest. */
+  preRegistration?: SignedManifest;
+  /** Override the gate name in reports. */
+  name?: string;
+}
+interface SequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario> extends Gate<TArtifact, TScenario> {
+  /** Streaming entry point: feed one paired per-scenario delta
+   *  (candidate − baseline, native scale). Each gate instance carries ONE
+   *  observe-stream; `decide(ctx)` runs on its own fresh stream and never
+   *  consumes or advances this one. 'promote' is sticky; observing past the
+   *  pre-registered maxN throws (extending a finished stream after seeing
+   *  the result reopens optional stopping — start a NEW pre-registered
+   *  test). */
+  observe(delta: number): SequentialObservation;
+  /** Read-only snapshot of the observe-stream. */
+  state(): EProcessState & {
+    decision: SequentialDecision;
+  };
+}
+/**
+ * Anytime-valid sequential paired gate. Conforms to the existing `Gate`
+ * contract (`decide(ctx)` consumes candidate vs baseline judge scores via
+ * `pairHoldout` — same pairing granularity as the fixed-n gates: full cellId,
+ * never scenarioId) and adds a streaming `observe(delta)` entry for campaigns
+ * that score cells incrementally and want to stop mid-stream.
+ *
+ * Decision mapping onto the substrate's five-valued `GateDecision`:
+ *   - 'promote'            → 'ship'
+ *   - 'continue'           → 'need_more_work' (stream ended before maxN with
+ *                            the e-value undecided — more reps could decide)
+ *   - 'undecided-at-maxN'  → 'hold', with the reason stating it is NOT
+ *                            evidence of no effect (never a silent default)
+ */
+declare function sequentialPairedGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: SequentialPairedGateOptions): SequentialPairedGate<TArtifact, TScenario>;
+interface SequentialDecideOptions {
+  /** Type-I budget for the early-stop evidence. Default 0.05. */
+  alpha?: number;
+  /** Minimum paired deltas before a stop may fire. Default 5. */
+  minN?: number;
+  /** Bet truncation forwarded to `eProcess`. Default 0.5. */
+  maxBet?: number;
+  /** Bound on |per-scenario composite delta|. Default 1. */
+  scale?: number;
+}
+interface SequentialDecideFn {
+  (args: {
+    history: GenerationRecord[];
+  }): {
+    stop: boolean;
+    reason?: string;
+  };
+  /** Read-only snapshot of the accumulated e-process (observability + tests). */
+  state(): EProcessState;
+}
+/**
+ * `SurfaceProposer.decide` adapter — stops the optimization loop the moment
+ * the e-process decides the loop has produced a real improvement, instead of
+ * always running `maxGenerations`.
+ *
+ * Stream: for each generation g ≥ 1, the per-scenario composite deltas of
+ * generation g's top candidate vs the generation-0 top candidate (the
+ * incumbent the loop set out to beat), paired by scenarioId. H0: no proposed
+ * surface improves any scenario's expected composite over the incumbent —
+ * under it every delta has conditional mean ≤ 0 and the e-process is valid.
+ * Once wealth ≥ 1/alpha the loop stops and hands the winner to the promotion
+ * gate (which re-scores on HELD-OUT data — this adapter only spends the
+ * exploration budget, it never promotes).
+ *
+ * Honesty caveats: (1) the incumbent's scores are measured once and shared
+ * across all generations' deltas, so type-I control is exact only insofar as
+ * those scores approximate the incumbent's true per-scenario means (more reps
+ * → tighter); (2) an UNDECIDED process never stops the loop — absence of a
+ * crossing is NOT evidence of no effect, so the loop simply runs its normal
+ * course. Calling the adapter repeatedly with a growing history consumes each
+ * generation exactly once (re-feeding an already-seen record would double-count
+ * evidence).
+ */
+declare function sequentialDecide(options?: SequentialDecideOptions): SequentialDecideFn;
+//#endregion
+//#region src/campaign/gates/statistical-heldout.d.ts
+interface PairedHoldout {
+  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */
+  before: number[];
+  /** Candidate scalar per paired cell. */
+  after: number[];
+  /** The full cellIds (`scenario:rep`) that paired, in order. */
+  cellIds: string[];
+}
+/**
+ * Pair candidate vs baseline holdout observations by FULL cellId. `select`
+ * pulls the scalar from a cell's judge reports (composite, or a named
+ * dimension); a cell contributes the mean of `select` across its judges. Cells
+ * whose scenario is not in `scenarioIds`, or where `select` is undefined for
+ * every judge on either side, are skipped on BOTH sides so the arrays stay
+ * paired. Throws when the two maps disagree on which holdout cells exist — a
+ * load-bearing invariant: the baseline + winner holdout campaigns run the same
+ * scenarios with the same seed base, so their cellIds MUST align; a mismatch
+ * means a silent pairing bug, not a soft fallback.
+ */
+declare function pairHoldout(candidate: Map<string, Record<string, JudgeScore>>, baseline: Map<string, Record<string, JudgeScore>>, scenarioIds: Set<string>, select: (s: JudgeScore) => number | undefined): PairedHoldout;
+interface HeldoutSignificance {
+  paired: PairedHoldout;
+  /** The bootstrap the ship decision keys on — of the MEAN paired delta by
+   *  default (see the tie note on `heldoutSignificance`). */
+  bootstrap: PairedBootstrapResult;
+  /** The MEDIAN paired-delta bootstrap, reported as a diagnostic. When many
+   *  scenarios are tied (both sides solve them), the median is pinned near 0
+   *  regardless of the mean lift — comparing the two exposes tie-domination. */
+  medianBootstrap: PairedBootstrapResult;
+  /** Fraction of paired observations that are exact ties (|delta| < 1e-9). A
+   *  high tie fraction is WHY a median-based gate would have missed a real lift;
+   *  it is the observability the tie fix adds. */
+  tieFraction: number;
+  /** n paired observations. */
+  n: number;
+  /** True iff n >= minProductiveRuns AND the CI lower bound clears the threshold. */
+  significant: boolean;
+  /** Set when n < minProductiveRuns — too little evidence to claim significance. */
+  fewRuns: boolean;
+}
+interface HeldoutSignificanceOptions {
+  deltaThreshold?: number;
+  minProductiveRuns?: number;
+  confidence?: number;
+  resamples?: number;
+  /** Fixed by default for a deterministic, reproducible gate verdict. */
+  seed?: number;
+  statistic?: 'mean' | 'median';
+}
+/** Significance of the held-out composite lift: ship only when the paired
+ *  bootstrap CI lower bound on (candidate − baseline) exceeds `deltaThreshold`
+ *  (default 0 ⇒ "confidently positive"). Below `minProductiveRuns` paired
+ *  observations there is not enough evidence to claim significance → not
+ *  significant (`fewRuns`). Interpret `deltaThreshold` in the judge's native
+ *  composite scale. */
+declare function heldoutSignificance(paired: PairedHoldout, opts?: HeldoutSignificanceOptions): HeldoutSignificance;
+interface DimensionRegression {
+  dimension: string;
+  bootstrap: PairedBootstrapResult;
+  /** True iff the CI lower bound on (candidate − baseline) is below −tolerance:
+   *  the candidate may have regressed this dimension by more than tolerance. */
+  regressed: boolean;
+  tolerance: number;
+  n: number;
+}
+/** Detect the native scale of a set of scores: 0-100 when any magnitude clears
+ *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default
+ *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */
+declare function detectScale(values: number[]): 1 | 100;
+/** Per-critical-dimension regression guard. For each dimension, pair the
+ *  candidate vs baseline values by full cellId and bootstrap the paired delta;
+ *  a dimension is "regressed" when the CI lower bound < −tolerance (conservative
+ *  — blocks if the credible worst case exceeds tolerance, which is the right
+ *  posture for safety dimensions like `hallucination_free`). When `tolerance`
+ *  is omitted it auto-scales: 0.05 on [0,1], 5 on 0-100. */
+declare function dimensionRegressions(candidate: Map<string, Record<string, JudgeScore>>, baseline: Map<string, Record<string, JudgeScore>>, scenarioIds: Set<string>, criticalDimensions: string[], opts?: {
+  tolerance?: number;
+  confidence?: number;
+  resamples?: number;
+  seed?: number;
+}): DimensionRegression[];
+//#endregion
+//#region src/campaign/grounded-reflection.d.ts
+/**
+ * Evidence grounding for reflective optimizers (GEPA-style revise loops).
+ *
+ * Two failure modes recur when an LLM revises an artifact from raw rollout
+ * traces (first measured in agent-lab R358, where naive reflection REGRESSED
+ * the score 0.375 -> 0.125 before these helpers fixed it):
+ *
+ * 1. The environment often hides WHY a rollout failed - a tool call can
+ *    succeed while an invisible downstream check fails - so the reviser
+ *    cannot see the cause in the transcript. The only reliable signal is the
+ *    field-level difference between what passing and failing rollouts did.
+ *    `rolloutArgumentDiff` computes that difference deterministically so the
+ *    reviser is handed the diff instead of being trusted to derive it.
+ *
+ * 2. Revisers invent plausible-but-wrong literal values ("use 'new'",
+ *    "use 'sent'") that no passing rollout ever used, turning every rollout
+ *    into a failure. `classifyUngroundedLiterals` mechanically detects them,
+ *    separating HARMFUL literals (ones failing rollouts actually used -
+ *    proven damage) from benign illustrations (e.g. a name example like
+ *    'Doe'), so callers can hard-reject the former and merely log the latter.
+ *    Rejecting every ungrounded quoted word is too blunt: it killed a run
+ *    over a surname illustration before the severity split existed.
+ *
+ * Pure data in, data out: no LLM calls, no filesystem, no domain knowledge.
+ */
+/** One tool/action call observed in a rollout: a name plus its arguments. */
+interface RolloutCall {
+  readonly name: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+/** A scored rollout: its calls plus the scalar outcome used to split pass/fail. */
+interface ScoredRollout {
+  /** Caller-meaningful identifier (task id, cell id) used only for reporting. */
+  readonly id: string;
+  /** Scalar outcome in [0, 1]; `passThreshold` splits passing from failing. */
+  readonly score: number;
+  readonly calls: readonly RolloutCall[];
+}
+interface RolloutArgumentDiffOptions {
+  /** Rollouts with `score >= passThreshold` count as passing. Default 1. */
+  readonly passThreshold?: number;
+  /** Max distinct values listed per field per side in the rendered text. Default 4. */
+  readonly maxValuesPerField?: number;
+}
+interface RolloutArgumentDiff {
+  /** Human/LLM-readable per-field diff, one line per field. */
+  readonly text: string;
+  /** Lowercased stringified argument values seen in passing rollouts. */
+  readonly passingValues: ReadonlySet<string>;
+  /** 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 {
+  /** Root directory for JSONL files. Created if missing. */
+  root: string;
+  /** Per-source rate limit. When set, writes exceeding the cap are rejected
+   *  with a typed error. Default: no limit. */
+  maxWritesPerMinutePerBucket?: number;
+  /** 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
+/**
+ * @module
+ * Footprint-matched neutralization — the placebo control for content-vs-footprint
+ * attribution in a promotion gate.
+ *
+ * A promoted surface can raise a held-out score two different ways:
+ *  1. its CONTENT is informative (the thing we want to promote), or
+ *  2. it merely added prompt/mount FOOTPRINT — more bytes, more lines, a longer
+ *     more authoritative-looking prompt — that the model spends attention on
+ *     regardless of what the bytes say.
+ *
+ * A held-out gate proves the candidate beat baseline; it cannot separate (1) from
+ * (2). `neutralizeText` produces a variant that keeps the input's layout and
+ * length while carrying ZERO information, so scoring it isolates the footprint
+ * contribution (2). Feed the neutralized variant's scores to `neutralizationGate`:
+ * any lift it still holds over baseline is decorative, and a candidate whose lift
+ * survives neutralization is rejected however large its raw lift.
+ */
+/**
+ * Blank every non-whitespace character to a 1-byte filler while preserving all
+ * whitespace. Line count, indentation, and word/line lengths are unchanged — so
+ * the neutralized variant has the same layout and (for ASCII) the same byte
+ * footprint as the input, but no readable content. Whitespace is preserved
+ * deliberately: collapsing it would change the token structure and stop the
+ * variant from being a true footprint match.
+ */
+declare function neutralizeText(content: string): string;
+//#endregion
+//#region src/artifact-validator.d.ts
+/**
+ * Artifact validators.
+ *
+ * Generic "score a produced artifact" primitive. Tax uses it for PDF form
+ * correctness, research for sourced briefs, browser for task assertions, coding
+ * for social posts. One interface, many validators; all plug into
+ * `BenchmarkRunner` the same way.
+ *
+ * A validator receives an `Artifact` (file on disk, JSON blob, text, binary)
+ * plus a `ValidationContext` (scenario id, the turns that produced it) and
+ * returns a `ValidationResult` with pass/fail + 0..1 score + structured
+ * issues.
+ */
+interface Artifact {
+  /** Logical kind — validators type-guard on this */
+  kind: 'file' | 'json' | 'text' | 'binary' | string;
+  /** Filesystem-style path, optional */
+  path?: string;
+  /** String content for text/json/file kinds */
+  content?: string;
+  /** Binary content (if kind === 'binary') */
+  bytes?: Uint8Array;
+  /** Caller-supplied metadata (mimeType, sha256, size, etc.) */
+  metadata?: Record<string, unknown>;
+}
+interface ValidationContext {
+  scenarioId: string;
+  turnIndex?: number;
+  /** Prior artifacts for multi-artifact scenarios */
+  priorArtifacts?: Artifact[];
+  /** Free-form hints the validator uses for domain-specific checks */
+  hints?: Record<string, unknown>;
+}
+interface ValidationIssue {
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+  /** Optional path into the artifact (e.g. JSON path or byte offset) */
+  locus?: string;
+}
+interface ValidationResult {
+  pass: boolean;
+  /** 0–1 normalized score. Validators should be monotonic in pass-ness. */
+  score: number;
+  issues: ValidationIssue[];
+  /** Diagnostic payload for reporters */
+  evidence?: Record<string, unknown>;
+}
+interface ArtifactValidator {
+  /** Stable identifier for the validator; appears in reports. */
+  name: string;
+  /** Optional description for human-facing reports. */
+  description?: string;
+  /** Called once per artifact; validators are expected to be pure + idempotent. */
+  validate(artifact: Artifact, context: ValidationContext): Promise<ValidationResult>;
+}
+/**
+ * Run every validator on the same artifact; aggregate pass as AND, score as
+ * (weighted) mean, issues concatenated. Weights default to 1 each.
+ */
+declare function composeValidators(validators: ArtifactValidator[], options?: {
+  name?: string;
+  weights?: number[];
+}): ArtifactValidator;
+/** Pass if the artifact body matches a provided regex. */
+declare function regexMatch(name: string, pattern: RegExp): ArtifactValidator;
+/** Pass if JSON parses and every required key is present. */
+declare function jsonHasKeys(name: string, requiredPaths: string[]): ArtifactValidator;
+/** Pass if min ≤ byte length ≤ max. */
+declare function byteLengthRange(name: string, min: number, max: number): ArtifactValidator;
+/** Pass if the artifact contains every required substring (case-insensitive by default). */
+declare function containsAll(name: string, required: string[], options?: {
+  caseSensitive?: boolean;
+}): ArtifactValidator;
+//#endregion
+//#region src/completion-verifier.d.ts
+/** What kind of produced state can satisfy a requirement structurally. */
+type SatisfiedBy = 'artifact' | 'proposal' | 'tool-call' | 'any';
+interface CompletionRequirement {
+  /** Stable id from the task gold (e.g. a persona's `expected_requirements[].req_id`). */
+  reqId: string;
+  /** Human-readable description of the required deliverable. */
+  title: string;
+  /** Optional kind/category hint, matched against a produced item's kind. */
+  category?: string;
+  /** What produced state satisfies this requirement. Defaults to 'any'. */
+  satisfiedBy?: SatisfiedBy;
+}
+interface TaskGold {
+  taskId: string;
+  requirements: CompletionRequirement[];
+}
+interface ProducedProposal {
+  id: string;
+  title: string;
+  status: 'pending' | 'approved' | 'rejected';
+  /** Optional persisted body — when present, enables a correctness check. */
+  content?: string;
+}
+/** Everything observable about what a run actually produced. */
+interface ProducedState {
+  /** Persisted vault artifacts. Reuses the shared `Artifact` shape. */
+  artifacts: Artifact[];
+  /** Proposals / filings the agent created. */
+  proposals: ProducedProposal[];
+  /** Names of tools the agent invoked. */
+  toolCalls: string[];
+}
+interface RequirementCheck {
+  reqId: string;
+  title: string;
+  /** A produced item of the right kind matched the requirement, non-empty. */
+  structurallyPresent: boolean;
+  /**
+   * Whether the matched item actually fulfils the requirement. `null` when
+   * not structurally present, when the matched item carries no content
+   * to assess, or when the correctness check itself failed (`unmeasured`).
+   */
+  correct: boolean | null;
+  /** structurallyPresent && !unmeasured && correct !== false. */
+  satisfied: boolean;
+  /**
+   * Set when the correctness check itself errored (LLM call failure or an
+   * unparseable response after retry). The requirement's fulfilment is
+   * UNKNOWN — `correct` stays null, `satisfied` is false, and
+   * `completionVerdict` excludes the row from `completionRate`'s
+   * denominator. Never folded into a zero: a synthetic zero is
+   * indistinguishable from a real failure (see `JudgeParseError`).
+   */
+  unmeasured?: true;
+  /** Why the correctness check could not be measured (present iff `unmeasured`). */
+  unmeasuredReason?: string;
+  /** Human-readable evidence for the verdict. */
+  evidence: string[];
+}
+/** Extends the substrate verdict spine: `valid` = `fullyComplete` and
+ *  `score` = `completionRate` — derived in `completionVerdict()`, the one
+ *  place those equalities hold by construction. */
+interface CompletionVerdict extends DefaultVerdict {
+  taskId: string;
+  requirements: RequirementCheck[];
+  /** satisfied / MEASURABLE requirements (unmeasured rows leave the denominator). */
+  completionRate: number;
+  /** Every measurable requirement satisfied (false when anything is unmeasured). */
+  fullyComplete: boolean;
+  /** Requirements whose correctness check errored — reported, never scored as zero. */
+  unmeasuredCount: number;
+}
+/**
+ * Construct a `CompletionVerdict` from the per-requirement checks, deriving
+ * `completionRate` / `fullyComplete` and the spine fields (`valid` =
+ * `fullyComplete`, `score` = `completionRate`) in one place. Throws on zero
+ * requirements — a verdict over nothing is a misconfiguration, mirroring
+ * `verifyCompletion`'s gold-spec guard.
+ */
+declare function completionVerdict(input: {
+  taskId: string;
+  requirements: RequirementCheck[];
+}): CompletionVerdict;
+/**
+ * Decides whether a produced item's content actually fulfils a requirement.
+ * Injected so the structural verifier stays pure and unit-testable; the
+ * production implementation is `createLlmCorrectnessChecker`.
+ */
+type CorrectnessChecker = (requirement: CompletionRequirement, content: string) => Promise<{
+  correct: boolean;
+  reason: string;
+}>;
+/**
+ * Verify whether a run completed the task. `checkCorrectness` is injected —
+ * `createLlmCorrectnessChecker` for production, a deterministic stub in tests.
+ *
+ * Throws on a gold spec with no requirements: an eval task that requires
+ * nothing is a misconfiguration, not a vacuously-complete task.
+ */
+declare function verifyCompletion(gold: TaskGold, state: ProducedState, checkCorrectness: CorrectnessChecker): Promise<CompletionVerdict>;
+interface LlmCorrectnessCheckerOpts {
+  model?: string;
+  /** Optional ledger for direct use. */
+  costLedger?: CostLedgerHandle;
+  costPhase?: string;
+  costTags?: Record<string, string>;
+  signal?: AbortSignal;
+  /** Max chars of artifact content sent to the checker. */
+  maxContentChars?: number;
+  /**
+   * Checker LLM calls per requirement before giving up (parse failures and
+   * call errors both consume attempts). The failure then surfaces as an
+   * `unmeasured` requirement, never a zero.
+   */
+  maxAttempts?: number;
+  /**
+   * Forensic capture of every checker request/response/error — without it a
+   * checker failure is unauditable (the agent-turn raws never contain the
+   * checker's own calls). Same sink contract as `LlmClient`.
+   */
+  rawSink?: RawProviderSink;
+}
+/**
+ * Parse the correctness checker's model response. Tolerates a response
+ * truncated mid-JSON (max_tokens cap) by auto-closing the prefix — the
+ * verdict boolean usually lands in the first few tokens, so a recovered
+ * prefix with a boolean `correct` is a real measurement, not a guess.
+ * Fails loud (JudgeParseError) when no boolean verdict is recoverable.
+ */
+declare function parseCorrectnessResponse(raw: string): {
+  correct: boolean;
+  reason: string;
+};
+/**
+ * Production `CorrectnessChecker` — one LLM call per matched artifact,
+ * deterministic (temperature 0), structured JSON out. Judges fulfilment
+ * only: a plan, a gesture, or a description of what should be done does not
+ * fulfil a requirement — the artifact must BE the deliverable.
+ */
+declare function createLlmCorrectnessChecker(chat: ChatClient, opts?: LlmCorrectnessCheckerOpts): CorrectnessChecker;
+/**
+ * Deterministic `CorrectnessChecker` — the no-LLM counterpart to
+ * `createLlmCorrectnessChecker`. A produced item fulfils a requirement when its
+ * content is substantive (≥ `minContentLength` chars) AND recalls ≥ `minRecall`
+ * of the requirement title's significant tokens. No network.
+ *
+ * Polarity-blind: token recall credits a negation that contains the
+ * requirement's tokens ("I will NOT produce the comparison" recalls every token
+ * of "produce the comparison"). The structural match stage is ALSO lexical, so
+ * pairing the two collapses to a single gameable gate. Use this only as an
+ * opt-in structural pre-filter or for tasks whose requirements have no polarity
+ * to invert; for produced-state grading the correctness checker MUST be semantic
+ * (`createLlmCorrectnessChecker`). See the anti-game fixtures in the test suite.
+ */
+declare function createTokenRecallChecker(opts?: {
+  minRecall?: number;
+  minContentLength?: number;
+}): CorrectnessChecker;
+//#endregion
+//#region src/produced-state.d.ts
+/** A tool the agent invoked. */
+interface ToolCallEventLike {
+  type: 'tool_call';
+  toolName: string;
+}
+/**
+ * An artifact the agent produced. `content` is the enriched field — the
+ * runtime's base `artifact` event carries only metadata; the completion
+ * oracle needs the body to verify the deliverable, so the runtime emits it.
+ */
+interface ArtifactEventLike {
+  type: 'artifact';
+  artifactId: string;
+  name?: string;
+  mimeType?: string;
+  uri?: string;
+  content?: string;
+}
+/** A proposal / filing the agent created. */
+interface ProposalEventLike {
+  type: 'proposal_created';
+  proposalId: string;
+  title: string;
+  status?: 'pending' | 'approved' | 'rejected';
+  content?: string;
+}
+/**
+ * The subset of runtime stream events `extractProducedState` consumes.
+ * agent-runtime's full `RuntimeStreamEvent` union satisfies this structurally;
+ * the `{ type: string }` catch-all keeps the input permissive so callers can
+ * pass the whole unfiltered telemetry stream — unrecognized events are skipped.
+ */
+type RuntimeEventLike = ToolCallEventLike | ArtifactEventLike | ProposalEventLike | {
+  type: string;
+};
+/**
+ * Normalize a run's runtime event stream into `ProducedState`.
+ *
+ * Pure and total — unrecognized event types are skipped. `toolCalls` is
+ * deduplicated by name in first-seen order (completion cares about a tool's
+ * presence, not its call count). An artifact with neither a name nor a uri
+ * still yields an entry keyed by its `artifactId` so it is never silently
+ * dropped; an artifact with no `content` yields empty content, which the
+ * completion oracle's structural check then rejects on its own.
+ */
+declare function extractProducedState(events: readonly RuntimeEventLike[]): ProducedState;
+//#endregion
+//#region src/agent-profile.d.ts
+/**
+ * The agentic coding harnesses an eval sweeps by default — the ones we care about
+ * ranking. This is the SINGLE source of that list; consumers import it instead of
+ * re-declaring their own (a re-declared list is how the fleet drifts). Pass an
+ * explicit `harnesses` (e.g. `harnessTypeSchema.options` for literally every known
+ * harness) to widen beyond these.
+ */
+declare const CODING_HARNESSES: readonly HarnessType[];
+interface ProfileAxisSpec {
+  /** The domain profile to sweep. Its prompt/tools/skills are held fixed; only the
+   *  harness and model vary. `model.default` is the fallback model. */
+  base: AgentProfile;
+  /** Harnesses to cross. Default: {@link CODING_HARNESSES}. */
+  harnesses?: readonly HarnessType[];
+  /** Models to cross. Default: `[base.model.default]` — one model, i.e. today's
+   *  single-model behaviour, so omitting this never changes an existing run. */
+  models?: readonly string[];
+  /** Force every (harness, model) pair verbatim, even ones the harness can't run —
+   *  for deliberately testing failure modes. Default (false): SNAP instead — a
+   *  vendor-locked harness runs only the swept models in its family, or its native
+   *  default when it supports none, so no harness is dropped and none gets a
+   *  guaranteed-failing foreign-model cell. */
+  keepIncompatible?: boolean;
+}
+/** Model sentinel for a vendor-locked harness that supports none of the swept models:
+ *  it carries no provider prefix, so `harnessSupportsModel` accepts it and the harness
+ *  resolves it to its own native default model at runtime (e.g. kimi-code → its Kimi
+ *  model). Lets `expandProfileAxes` snap-instead-of-drop without a per-harness flagship
+ *  table that would rot as router catalogs change. */
+declare const HARNESS_NATIVE_MODEL = "default";
+/**
+ * Expand a base profile across the harness × model matrix into the `AgentProfile[]`
+ * that `runProfileMatrix` / `selfImprove` score — the ONE place "which harnesses ×
+ * which models do we evaluate" lives, so no product hand-rolls its own harness list
+ * or column→profile mapping (the pattern that let those copies drift and silently
+ * break the harness pivot).
+ *
+ * Each cell clones `base`, sets `model.default`, and stamps `metadata.harness` +
+ * `metadata.harnessModel` (both hash-bearing, so every cell gets a distinct
+ * `agentProfileId` row and results join back by harness/model via {@link harnessAxisOf}
+ * with no hand-recomputed key). A vendor-locked harness snaps to its family's swept
+ * models — or its native default ({@link HARNESS_NATIVE_MODEL}) when it supports none —
+ * so every requested harness runs; `keepIncompatible` forces every pair verbatim.
+ *
+ * Omit `harnesses`/`models` to sweep the full default set — the "turn it on for
+ * everything we care about" switch, identical in shape whether one harness or all.
+ */
+declare function expandProfileAxes(spec: ProfileAxisSpec): AgentProfile[];
+/**
+ * Read the (harness, model) a matrix cell ran under, off a profile or a result row's
+ * profile — the join-back for a `byHarness` pivot. Returns undefined when the profile
+ * wasn't produced by {@link expandProfileAxes}. Callers group `result.byProfile` by
+ * this instead of recomputing an id (recomputing the wrong key is what broke the pivot
+ * in the hand-rolled copies).
+ */
+declare function harnessAxisOf(profile: Pick<AgentProfile, 'metadata'>): {
+  harness: HarnessType;
+  model: string;
+} | undefined;
+/**
+ * Collision-resistant, path-safe, human-readable profile id for eval artifacts.
+ * Scorecard joins still use `agentProfileHash`; this id is for run ids, matrix
+ * keys, and directory names where two profiles must not collapse onto one row.
+ * The suffix is the first 64 bits of the behaviour hash, enough for ordinary
+ * eval matrices while keeping filenames readable.
+ */
+declare function agentProfileId(profile: AgentProfile): string;
+/**
+ * Model snapshot used for `RunRecord.model`. Eval surfaces require a concrete
+ * model id because run records reject bare/missing model aliases.
+ */
+declare function agentProfileModelId(profile: AgentProfile): string;
+/**
+ * Deterministic behaviour identity for the canonical
+ * `@tangle-network/agent-interface` AgentProfile.
+ *
+ * `name` and `description` are labels and do not affect the hash. Profile
+ * `version`, prompt, model hints, tools, resources, hooks, modes, permissions,
+ * and extensions do affect the hash. Resource array order is hash-bearing
+ * because mount order can change agent behaviour. Undefined fields are treated
+ * as absent; explicit `null` fields remain hash-bearing.
+ */
+declare function agentProfileHash(profile: AgentProfile): string;
+//#endregion
+//#region src/integrity/backend-integrity.d.ts
+interface BackendIntegrityReport {
+  /** Total records inspected. */
+  totalRecords: number;
+  /** Records with input=0 AND output=0 (a stub fingerprint). */
+  stubRecords: number;
+  /** Records with nonzero token usage (real LLM activity). */
+  realRecords: number;
+  /** Records where output>0 but costUsd=0 (real LLM, broken cost ledger). */
+  uncostedRecords: number;
+  /** Sum of input tokens across all records. */
+  totalInputTokens: number;
+  /** Sum of output tokens across all records. */
+  totalOutputTokens: number;
+  /** Sum of costUsd across all records. */
+  totalCostUsd: number;
+  /** Worst-case integrity verdict. */
+  verdict: 'real' | 'mixed' | 'stub';
+  /** Human-readable diagnosis suitable for terminal output. */
+  diagnosis: string;
+}
+/**
+ * Error thrown when an integrity assertion fails. Caller can pattern-match
+ * by `code === 'AGENT_EVAL_BACKEND_STUB'` to differentiate from other
+ * errors.
+ */
+declare class BackendIntegrityError extends AgentEvalError {
+  readonly report: BackendIntegrityReport;
+  constructor(message: string, report: BackendIntegrityReport);
+}
+/**
+ * Inspect a batch of RunRecords and return an integrity report. Pure
+ * function — no I/O, no logging. The caller decides what to do with the
+ * verdict (print warning, throw, gate CI, etc.).
+ */
+declare function summarizeBackendIntegrity(records: ReadonlyArray<RunRecord>): BackendIntegrityReport;
+/** Inspect settled agent calls from the canonical cost ledger. */
+declare function summarizeAgentReceiptIntegrity(receipts: ReadonlyArray<CostReceipt>): BackendIntegrityReport;
+/**
+ * Throw BackendIntegrityError if the verdict is 'stub' — i.e. every record
+ * shows zero LLM activity. Non-strict callers can pass `{ allowMixed: false }`
+ * to also reject mixed verdicts (recommended for CI gates).
+ *
+ * Real backends pass through silently.
+ */
+declare function assertRealBackend(records: ReadonlyArray<RunRecord>, opts?: {
+  allowMixed?: boolean;
+}): BackendIntegrityReport;
+/** Reject a cost ledger with no real agent call or a partial stub run. */
+declare function assertRealAgentReceipts(receipts: ReadonlyArray<CostReceipt>, opts?: {
+  allowMixed?: boolean;
+}): BackendIntegrityReport;
+//#endregion
+//#region src/campaign/presets/run-profile-matrix.d.ts
+/** Thrown when the matrix is misconfigured (no profiles, a profile whose model
+ *  lacks a snapshot version, 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. */
+type ProfileDispatchFn<TScenario extends Scenario, TArtifact> = (profile: AgentProfile$1, scenario: TScenario, ctx: DispatchContext) => Promise<TArtifact>;
+interface RunProfileMatrixOptions<TScenario extends Scenario, TArtifact> {
+  /** Axis 3 — the agent-under-test configurations. Each is one column. */
+  profiles: AgentProfile$1[];
+  /** Axis 1 — the persona/scenario corpus, run against every profile. */
+  scenarios: TScenario[];
+  /** Renders one (profile, scenario) cell. */
+  dispatch: ProfileDispatchFn<TScenario, TArtifact>;
+  /** The scoring axis. */
+  judges?: JudgeConfig<TArtifact, TScenario>[];
+  /** Where each profile's campaign writes artifacts/traces. One subdir per
+   *  profile. */
+  runDir: string;
+  /** Git SHA the harness ran from — stamped onto every RunRecord (mandatory
+   *  for paper-grade records). */
+  commitSha: string;
+  /** Logical experiment id shared across the whole matrix so the promotion
+   *  gate can pair profiles on matched scenarios. Default: a hash of the
+   *  profile + scenario ids. */
+  experimentId?: string;
+  /** Which split these runs belong to. Default `'search'`. */
+  splitTag?: RunSplitTag;
+  /** Replicates per (profile, scenario) cell for CI bands. Default 1. */
+  reps?: number;
+  /** Campaign seed (per profile). Default 42. */
+  seed?: number;
+  /**
+   * Backend-integrity posture, enforced AFTER the matrix completes:
+   *   - `'assert'` (default) — throw `BackendIntegrityError` if the run was a
+   *     stub (and, with `allowMixed:false`, if it was mixed).
+   *   - `'warn'` — log the verdict but never throw.
+   *   - `'off'` — skip the guard entirely (only for offline/replay analysis).
+   */
+  integrity?: 'assert' | 'warn' | 'off';
+  /** Forwarded to `assertRealBackend`. Default true (tolerate partial 429
+   *  cascades); set false for strict CI gates. */
+  allowMixed?: boolean;
+  /** Max concurrent cells WITHIN each profile's campaign. Default 2.
+   *  Profiles run sequentially so the cost ceiling is honored deterministically. */
+  maxConcurrency?: number;
+  /** Cumulative USD cap per profile campaign. */
+  costCeiling?: number;
+  /** Capture flywheel — forwarded to each campaign. */
+  labeledStore?: LabeledScenarioStore | 'off';
+  captureSource?: LabeledScenarioSource;
+  /** Storage backend. Default `fsCampaignStorage`. Pass
+   *  `inMemoryCampaignStorage()` for edge/CF-Worker/test runs. */
+  storage?: CampaignStorage;
+  /** Test seam — override the wall clock. */
+  now?: () => Date;
+  /** Optional persona key per scenario — drives the `byPersona` pivot. When
+   *  unset, `byPersona` is omitted. */
+  personaOf?: (scenario: TScenario) => string;
+  /** Validate every produced RunRecord with `validateRunRecord` (fail-loud).
+   *  Default true — catches bad model snapshots and non-finite judge dims at
+   *  the boundary instead of letting them poison downstream analysis. */
+  validate?: boolean;
+  /** Corpus-by-default: derive the trajectory text (`prompt` + `completion`)
+   *  for each cell from its artifact + scenario. When set, every produced
+   *  record carries `prompt`/`completion` (a `CorpusRecord`) so the run's
+   *  graded trajectories can be appended to the durable RL corpus with no
+   *  side-channel — `appendToCorpus(result.records, path)`. Fail-soft: a
+   *  throwing or undefined-returning extractor just omits the text. */
+  corpusText?: (artifact: TArtifact, scenario: TScenario) => {
+    prompt: string;
+    completion: string;
+  } | undefined;
+}
+interface ProfileSummary {
+  profileId: string;
+  profileHash: string;
+  model: string;
+  /** RunRecords produced for this profile (= scenarios × reps). */
+  records: number;
+  /** Mean across scored records, or null when the profile has no task labels. */
+  meanComposite: number | null;
+  totalCostUsd: number;
+  /** Per-profile integrity verdict — surfaces a single profile that ran stub
+   *  even when the matrix as a whole looks real. */
+  integrity: BackendIntegrityReport;
+}
+interface ScenarioRollup {
+  meanComposite: number;
+  n: number;
+}
+interface RunProfileMatrixResult<TArtifact, TScenario extends Scenario> {
+  matrixId: string;
+  experimentId: string;
+  /** One RunRecord per (profile, scenario, rep) cell — the integrity-checked,
+   *  paper-grade output. Feed straight into `analyzeRuns`, `HeldOutGate`,
+   *  scorecards, the hosted wire format. */
+  records: RunRecord[];
+  byProfile: Record<string, ProfileSummary>;
+  byScenario: Record<string, ScenarioRollup>;
+  /** Present only when `personaOf` was supplied. */
+  byPersona?: Record<string, ScenarioRollup>;
+  /** Whole-matrix integrity report (the one `integrity:'assert'` enforces). */
+  integrity: BackendIntegrityReport;
+  /** The raw per-profile campaign results, keyed by profile id. */
+  campaigns: Record<string, CampaignResult<TArtifact, TScenario>>;
+}
+/**
+ * Profile × scenario matrix runner: fan N agent profiles across M scenarios, project each cell to a validated `RunRecord` with real token usage, and enforce the backend-integrity guard before returning.
+ */
+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/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
+ *  compute so callers pass a *name*, not a path. */
+declare function resolveRunDir(runDir: string, repo?: string): string;
+//#endregion
+//#region src/campaign/scenario-selection.d.ts
+/**
+ * Discriminative scenario selection (research claim E2).
+ *
+ * The OR benchmark is SATURATING: run 7 measured ~75% tied holdout cells — most
+ * problems are solved optimally by the baseline AND every candidate, so those
+ * paired cells carry zero signal. A random/balanced holdout split spends its
+ * budget on scenarios that cannot separate candidates.
+ *
+ * This picks the holdout by DISCRIMINATION power instead: a scenario every
+ * candidate scores identically (variance ~0) carries no signal; one where the
+ * scores spread carries the most. We drop fully saturated ties so each paired
+ * holdout cell is spent on a scenario that can actually move a verdict.
+ */
+/** Per-scenario observation: the composite scores each candidate earned on it. */
+interface ScenarioSignal {
+  scenarioId: string;
+  /** Per-candidate composite scores observed for this scenario (>=1 values). */
+  scores: number[];
+}
+interface DiscriminationScore {
+  scenarioId: string;
+  /** Higher = separates candidates more (spread of their scores). */
+  discrimination: number;
+  /** Higher = easier / more-saturated (mean of candidate scores). */
+  meanScore: number;
+  variance: number;
+  /** variance ~0 AND meanScore at/above the ceiling ⇒ a saturated tie, no signal. */
+  tied: boolean;
+}
+/**
+ * Rank scenarios by how well they DISCRIMINATE candidates.
+ *
+ * `discrimination = variance` (spread of the candidate scores) — kept simple on
+ * purpose; the headroom term (`saturationCeiling - meanScore`) only breaks ties
+ * so that, among equally spread scenarios, the one with more room to improve
+ * ranks first. Returned sorted by the deterministic order above.
+ */
+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/score-utils.d.ts
+/** Mean composite across cells with complete task-quality evidence.
+ *  Partial judge results remain on their cells but never enter this value.
+ *  A campaign with no complete score has no numeric mean and fails loudly. */
+declare function campaignMeanComposite<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): number;
+/** Compare fixed-length lexicographic rank keys where each element is higher-is-better.
+ *  Returns a positive number when `a` ranks above `b`, negative when below, and
+ *  zero when equal. */
+declare function compareRankKeys(a: readonly number[], b: readonly number[]): number;
+interface CampaignBreakdown {
+  /** Mean score per judge dimension across all cells. */
+  dimensions: Record<string, number>;
+  /** Per-scenario composite (mean over reps + judges) + the judge's free-form
+   *  `notes` for that scenario (the "why" a reflective proposer grounds on) +
+   *  an optional `emitted` excerpt of the candidate's raw output (the "what it
+   *  actually did" a reflective proposer grounds on). */
+  scenarios: Array<{
+    scenarioId: string;
+    composite: number;
+    notes?: string;
+    emitted?: string;
+  }>;
+}
+/** Per-candidate evidence a reflective/patch proposer grounds its next proposal
+ *  on: mean score per judge dimension + per-scenario composite. */
+declare function campaignBreakdown<TArtifact, TScenario extends Scenario>(campaign: CampaignResult<TArtifact, TScenario>): CampaignBreakdown;
+//#endregion
+//#region src/campaign/search-ledger-errors.d.ts
+declare class SearchLedgerError extends ValidationError {}
+declare class SearchLedgerIntegrityError extends SearchLedgerError {}
+declare class SearchLedgerConflictError extends SearchLedgerError {}
+//#endregion
+//#region src/campaign/search-ledger.d.ts
+declare const SEARCH_LEDGER_SCHEMA: 'tangle.search-ledger.v1';
+type SearchLedgerHash = LedgerHash;
+type SearchSurfaceKind = 'prompt' | 'tool-contract' | 'runtime-config' | 'memory' | 'knowledge' | 'agent-profile' | 'code' | 'deployment';
+/** Content-addressed artifact or receipt. Mutable paths are locators only; the
+ * digest and byte length bind the exact bytes used by the search. */
+interface SearchArtifactRef {
+  role: string;
+  uri: string;
+  sha256: SearchLedgerHash;
+  byteLength: number;
+}
+/** Repository, dataset, or package source pinned to an immutable commit or
+ * content digest. Branches, tags, and bare package versions are rejected. */
+interface SearchSourceRef {
+  uri: string;
+  revision: string;
+}
+interface SearchModelIdentity {
+  provider: string;
+  snapshot: string;
+}
+interface SearchCandidateSurface {
+  surfaceId: string;
+  kind: SearchSurfaceKind;
+  artifact: SearchArtifactRef;
+}
+interface SearchCandidateLineage {
+  /** Existing `LineageNode.id`; this ledger references rather than embeds it. */
+  lineageNodeId: string;
+  parentCandidateIds: string[];
+  generation: number;
+  proposer: string;
+  proposerSource: SearchSourceRef;
+}
+type SearchOperationKind = 'candidate-generation' | 'analysis' | 'selection' | 'judge' | 'other';
+interface SearchPlannedTask {
+  taskId: string;
+  source: SearchSourceRef;
+  benchmark: SearchSourceRef;
+  /** Maximum transport attempts for this task and candidate. Only an explicit
+   * passed/failed outcome satisfies the planned denominator. */
+  maxAttempts: number;
+}
+interface SearchPlannedOperation {
+  operationId: string;
+  kind: SearchOperationKind;
+}
+interface SearchCandidateSlot {
+  slotId: string;
+  /** Planned candidate-generation call that must either produce this slot or
+   * fail before the slot can be closed. Several slots may share one batched call. */
+  generationOperationId: string;
+}
+interface SearchPlan {
+  /** Stable slots and their proposer calls are frozen before search begins. */
+  candidateSlots: SearchCandidateSlot[];
+  /** Every task applies to every successfully registered candidate. */
+  tasks: SearchPlannedTask[];
+  /** Non-task spend slots: proposal, analysis, selection, extra judges, etc. */
+  operations: SearchPlannedOperation[];
+}
+type SearchTokenAccounting = {
+  status: 'known';
+  inputTokens: number;
+  outputTokens: number;
+  cachedTokens: number;
+} | {
+  status: 'unknown';
+  reason: string;
+};
+type SearchCostAccounting = {
+  status: 'known';
+  usd: number;
+  source: 'provider' | 'pricing-table' | 'free';
+} | {
+  status: 'unknown';
+  /** Known spend may still be a lower bound when one call was unpriced. */
+  knownLowerBoundUsd: number;
+  reason: string;
+};
+interface SearchAttemptAccounting {
+  tokens: SearchTokenAccounting;
+  cost: SearchCostAccounting;
+}
+interface SearchFailureReason {
+  code: string;
+  message: string;
+}
+type SearchTaskOutcome = {
+  status: 'passed';
+  score: number;
+  metrics: Record<string, number>;
+} | {
+  status: 'failed';
+  score: number;
+  metrics: Record<string, number>;
+  failure: SearchFailureReason;
+} | {
+  status: 'errored';
+  metrics: Record<string, number>;
+  error: SearchFailureReason & {
+    retryable: boolean;
+  };
+};
+type SearchSurfaceEffect = {
+  status: 'measured';
+  metric: string;
+  baselineValue: number;
+  candidateValue: number;
+  delta: number;
+} | {
+  status: 'not-measured';
+  reason: string;
+};
+/** Per-attempt proof that a declared candidate surface was or was not active,
+ * plus measured effect when the experiment supports attribution. */
+interface SearchSurfaceEvidence {
+  surfaceId: string;
+  fired: boolean;
+  firingCount: number;
+  effect: SearchSurfaceEffect;
+  evidence: SearchArtifactRef[];
+}
+interface SearchLedgerEventBase {
+  eventId: string;
+  occurredAt: string;
+  artifacts: SearchArtifactRef[];
+}
+interface SearchPlannedEvent extends SearchLedgerEventBase {
+  kind: 'search-planned';
+  plan: SearchPlan;
+}
+interface SearchCandidateRegisteredEvent extends SearchLedgerEventBase {
+  kind: 'candidate-registered';
+  slotId: string;
+  generationOperationId: string;
+  candidateId: string;
+  lineage: SearchCandidateLineage;
+  surfaces: SearchCandidateSurface[];
+}
+interface SearchCandidateSlotClosedEvent extends SearchLedgerEventBase {
+  kind: 'candidate-slot-closed';
+  slotId: string;
+  generationOperationId: string;
+  reason: SearchFailureReason;
+}
+interface SearchTaskAttemptedEvent extends SearchLedgerEventBase {
+  kind: 'task-attempted';
+  candidateId: string;
+  runId: string;
+  attemptIndex: number;
+  task: {
+    taskId: string;
+    source: SearchSourceRef;
+  };
+  identity: {
+    model: SearchModelIdentity;
+    agent: SearchSourceRef;
+    benchmark: SearchSourceRef;
+  };
+  outcome: SearchTaskOutcome;
+  accounting: SearchAttemptAccounting;
+  surfaceEvidence: SearchSurfaceEvidence[];
+}
+interface SearchOperationRecordedEvent extends SearchLedgerEventBase {
+  kind: 'search-operation-recorded';
+  operationId: string;
+  operationKind: SearchOperationKind;
+  execution: {
+    kind: 'model';
+    model: SearchModelIdentity;
+    source: SearchSourceRef;
+  } | {
+    kind: 'deterministic';
+    source: SearchSourceRef;
+  };
+  outcome: {
+    status: 'completed';
+  } | {
+    status: 'partial';
+    failure: SearchFailureReason;
+  } | {
+    status: 'failed';
+    failure: SearchFailureReason;
+  };
+  accounting: SearchAttemptAccounting;
+}
+interface SearchCandidateDecidedEvent extends SearchLedgerEventBase {
+  kind: 'candidate-decided';
+  candidateId: string;
+  decision: {
+    status: 'selected';
+  } | {
+    status: 'rejected';
+    reason: SearchFailureReason;
+  };
+}
+interface SearchCompletedEvent extends SearchLedgerEventBase {
+  kind: 'search-completed';
+  result: {
+    status: 'selected';
+    candidateId: string;
+  } | {
+    status: 'all-rejected';
+    reason: SearchFailureReason;
+  };
+}
+type SearchLedgerEvent = SearchPlannedEvent | SearchCandidateRegisteredEvent | SearchCandidateSlotClosedEvent | SearchTaskAttemptedEvent | SearchOperationRecordedEvent | SearchCandidateDecidedEvent | SearchCompletedEvent;
+interface SearchLedgerEntry {
+  schema: typeof SEARCH_LEDGER_SCHEMA;
+  campaignId: string;
+  sequence: number;
+  previousHash: SearchLedgerHash | null;
+  event: SearchLedgerEvent;
+  entryHash: SearchLedgerHash;
+}
+type SearchAccountingAudit = {
+  status: 'known';
+  inputTokens: number;
+  outputTokens: number;
+  cachedTokens: number;
+  costUsd: number;
+} | {
+  status: 'partial';
+  knownInputTokens: number;
+  knownOutputTokens: number;
+  knownCachedTokens: number;
+  knownCostUsd: number;
+  unknownTokenEventIds: string[];
+  unknownCostEventIds: string[];
+};
+interface SearchLedgerAudit {
+  campaignId: string;
+  eventCount: number;
+  candidateCount: number;
+  closedCandidateSlotCount: number;
+  attemptCount: number;
+  operationCount: number;
+  outcomes: {
+    passed: number;
+    failed: number;
+    errored: number;
+  };
+  operationOutcomes: {
+    completed: number;
+    partial: number;
+    failed: number;
+  };
+  decisions: {
+    selected: number;
+    rejected: number;
+    pending: number;
+  };
+  expected: {
+    candidateSlots: number;
+    taskOutcomes: number;
+    operations: number;
+    missingCandidateSlots: string[];
+    missingTaskOutcomes: string[];
+    missingOperations: string[];
+  };
+  status: 'in-progress' | 'selected' | 'all-rejected';
+  selectedCandidateId: string | null;
+  accounting: SearchAccountingAudit;
+  headHash: SearchLedgerHash | null;
+}
+interface SearchLedgerReplay {
+  entries: SearchLedgerEntry[];
+  plan: SearchPlannedEvent | null;
+  candidates: SearchCandidateRegisteredEvent[];
+  closedCandidateSlots: SearchCandidateSlotClosedEvent[];
+  attempts: SearchTaskAttemptedEvent[];
+  operations: SearchOperationRecordedEvent[];
+  decisions: SearchCandidateDecidedEvent[];
+  completion: SearchCompletedEvent | null;
+  audit: SearchLedgerAudit;
+}
+interface SearchLedgerAppendResult {
+  entry: SearchLedgerEntry;
+  /** False when the exact event was already durably present. */
+  appended: boolean;
+  replay: SearchLedgerReplay;
+}
+/** Validate and return a canonical copy. Arrays whose order is not semantic are
+ * sorted so retries from different processes produce byte-identical events. */
+declare function validateSearchLedgerEvent(input: unknown): SearchLedgerEvent;
+interface OpenSearchLedgerOptions {
+  path: string;
+  campaignId: string;
+}
+interface SearchLedger {
+  readonly path: string;
+  readonly campaignId: string;
+  append(event: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
+  replay(): Promise<SearchLedgerReplay>;
+}
+/** Open a durable filesystem search ledger. Construction performs no I/O; the
+ * first `append` or `replay` validates the complete existing file. */
+declare function openSearchLedger(options: OpenSearchLedgerOptions): SearchLedger;
+declare class FileSearchLedger implements SearchLedger {
+  readonly path: string;
+  readonly campaignId: string;
+  private readonly journal;
+  constructor(path: string, campaignId: string);
+  replay(): Promise<SearchLedgerReplay>;
+  append(input: SearchLedgerEvent): Promise<SearchLedgerAppendResult>;
+}
+//#endregion
+//#region src/campaign/single-run-lock.d.ts
+/**
+ * Single-run lock for evaluations that share one mutable environment.
+ *
+ * Two concurrent runs against a shared stateful gym silently corrupt each
+ * other: each resets/mutates environment state mid-cell of the other, and
+ * every score from both becomes garbage that LOOKS like worker variance
+ * (agent-lab R357 burned hours on flip-flopping scores before tracing them
+ * to exactly this). The fix is a pid lockfile: refuse to start while a live
+ * holder exists, reclaim stale locks whose pid is gone, release only if the
+ * lock is still ours.
+ *
+ * `alsoCheck` exists because independent runners can guard the same shared
+ * resource with differently named lockfiles; a runner must respect all of
+ * them even though it writes only its own.
+ */
+interface SingleRunLockOptions {
+  /** Lockfile this runner writes (and checks). */
+  readonly lockPath: string;
+  /** Other runners' lockfiles guarding the same resource; checked, never written. */
+  readonly alsoCheck?: readonly string[];
+  /** Install a process 'exit' hook that releases the lock. Default true. */
+  readonly releaseOnExit?: boolean;
+  /** Owner pid recorded in the lockfile metadata. Default process.pid. */
+  readonly pid?: number;
+}
+interface SingleRunLock {
+  /** Remove the lockfile if this process still owns it. Idempotent. */
+  release(): void;
+}
+/**
+ * Acquire the lock or throw naming the live holder. A stale lock (holder pid
+ * no longer running) is reclaimed by one contender. An interrupted reclaim
+ * leaves a marker that fails closed instead of admitting overlapping runs.
+ */
+declare function acquireSingleRunLock(opts: SingleRunLockOptions): SingleRunLock;
+//#endregion
+//#region src/campaign/surface-identity.d.ts
+/** Validate the immutable identity shape; the owning executor verifies the Git objects and patch. */
+declare function assertCodeSurfaceIdentity(surface: unknown): asserts surface is CodeSurface;
+declare function assertComponentSurface(surface: unknown): asserts surface is ComponentSurface;
+declare function componentSurfaceIdentityMaterial(surface: ComponentSurface): string;
+/** Canonical, location-independent identity of a finalized code candidate.
+ *  Commit metadata is excluded: two commits with the same base, final tree,
+ *  and patch bytes are the same executable candidate. */
+declare function codeSurfaceIdentityMaterial(surface: CodeSurface): string;
+/** Full SHA-256 content identity for a prompt or finalized code surface. */
+declare function surfaceContentHash(surface: MutableSurface): `sha256:${string}`;
+/** Short loop key derived from the same content identity as provenance. */
+declare function surfaceHash(surface: MutableSurface): string;
+/** Canonical customer-visible description of the exact before/after surfaces. */
+declare function renderSurfaceDiff(winnerSurface: MutableSurface, baselineSurface: MutableSurface): string;
+//#endregion
+//#region src/campaign/transient-failure.d.ts
+/**
+ * Transient-transport-failure classification for dispatch retry policies.
+ *
+ * When an eval cell dies, the harness must decide: retry (the infrastructure
+ * hiccuped - a 502 storm, an admission-queue rejection, a dropped stream) or
+ * score it (the agent genuinely failed). Getting this wrong corrupts results
+ * in both directions: scoring transport hiccups as failures buries real
+ * effects under noise (agent-lab R353 found 5/30 identical repeats were 502s
+ * scored as task failures), while retrying genuine failures silently drops
+ * the hard cells and inflates every arm.
+ *
+ * Full-duration timeouts are the deliberate knob: on saturated shared
+ * infrastructure a timeout usually means the request never got a slot
+ * (retry it), but on unthrottled infrastructure it means the agent flailed
+ * on the task until the clock ran out (a real score-0). Both readings were
+ * needed in practice within one week, so the classifier takes it as an
+ * option instead of hardcoding either.
+ */
+interface TransientFailureOptions {
+  /**
+   * Treat full-duration timeouts ("timeout after 180000ms") as transient.
+   * Enable on saturated shared infrastructure where queue starvation eats
+   * the clock; leave off when the agent had the resources and simply failed.
+   * Default false.
+   */
+  readonly retryFullDurationTimeouts?: boolean;
+  /** Additional caller-specific transient patterns. */
+  readonly extraPatterns?: readonly RegExp[];
+}
+/**
+ * True when the error text describes an infrastructure hiccup that should be
+ * retried rather than scored. Empty/undefined input is not transient.
+ */
+declare function isTransientTransportFailure(message: string | null | undefined, opts?: TransientFailureOptions): boolean;
+//#endregion
+//#region src/campaign/worktree/index.d.ts
+type GitOutput = string | Uint8Array;
+type GitEnvironment = Readonly<Record<string, string>>;
+type GitRunner = (args: string[], cwd: string, env?: GitEnvironment) => GitOutput;
+interface Worktree {
+  /** Absolute path to the checked-out worktree directory. */
+  readonly path: string;
+  /** The branch the worktree is on (becomes the PR branch on promotion). */
+  readonly branch: string;
+  /** The ref the worktree was forked from. */
+  readonly baseRef: string;
+  /** Exact commit `baseRef` resolved to before the worktree was created. */
+  readonly baseCommit: string;
+  /** Exact tree object for `baseCommit`. */
+  readonly baseTree: string;
+}
+interface WorktreeAdapter {
+  /** Create an isolated worktree on a fresh branch off `baseRef`. */
+  create(opts: {
+    baseRef: string;
+    label: string;
+  }): Promise<Worktree>;
+  /** Commit pending changes, freeze the exact Git objects + binary patch, and
+   *  verify the worktree still matches that identity. */
+  finalize(worktree: Worktree, summary: string): Promise<CodeSurface>;
+  /** 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;
+  /** Directory worktrees are created under. Default: `<repoRoot>/.worktrees`. */
+  worktreeDir?: string;
+  /** Branch-name prefix. Default: `improve`. */
+  branchPrefix?: string;
+  /** Test seam — defaults to a real `git` runner. The return value must contain
+   *  stdout verbatim, and runners that execute Git must forward the optional
+   *  environment overrides used to isolate patch generation. */
+  git?: GitRunner;
+}
+interface CodeSurfaceVerification {
+  /** Verified worktree path. */
+  path: string;
+  /** Git's canonical root for the verified checkout. */
+  repoRoot: string;
+  /** Recomputed full content identity. */
+  contentHash: `sha256:${string}`;
+  /** Exact verified binary-patch bytes. Candidate-bundle builders encode this
+   *  directly instead of reproducing Git diff options. */
+  patchBytes: Uint8Array;
+}
+/**
+ * Git-backed `WorktreeAdapter`: creates isolated worktrees on fresh branches, commits agent changes, and discards losers.
+ */
+declare function gitWorktreeAdapter(opts: GitWorktreeAdapterOptions): WorktreeAdapter;
+/** Verify a finalized code surface against its current checkout. This rejects
+ *  dirty/ignored files, moved refs, missing Git objects, raw byte/mode
+ *  mismatches, external symlinks, and submodules. */
+declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string): CodeSurfaceVerification;
+/** Resolve a code candidate for evaluation only after verifying its immutable
+ *  identity against the checkout at `worktreeRef`. */
+declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
+//#endregion
+export { SearchTaskAttemptedEvent as $, sequentialDecide as $n, CrossSurfaceRankedSingle as $r, ArtifactEventLike as $t, SearchCandidateSlot as A, FsLabeledScenarioStoreOptions as An, CrossSurfaceBootstrapPolicy as Ar, ProfileDispatchFn as At, SearchLedgerHash as B, HeldoutSignificance as Bn, CrossSurfaceEligibility as Br, assertRealBackend as Bt, SEARCH_LEDGER_SCHEMA as C, byteLengthRange as Cn, planEvalFixtureRun as Cr, UserStory as Ct, SearchCandidateDecidedEvent as D, regexMatch as Dn, CrossSurfaceAdditionRejectionReason as Dr, scoreUserStory as Dt, SearchAttemptAccounting as E, jsonHasKeys as En, CrossSurfaceAdditionDecision as Er, renderScoreboardMarkdown as Et, SearchFailureReason as F, ScoredRollout as Fn, CrossSurfaceCandidateSummary as Fr, ScenarioRollup as Ft, SearchPlan as G, heldoutSignificance as Gn, CrossSurfaceInteractionPath as Gr, HARNESS_NATIVE_MODEL as Gt, SearchModelIdentity as H, PairedHoldout as Hn, CrossSurfaceIneligibilityReason as Hr, summarizeBackendIntegrity as Ht, SearchLedger as I, UngroundedLiteralReport as In, CrossSurfaceComponent as Ir, runProfileMatrix as It, SearchPlannedTask as J, SequentialDecideOptions as Jn, CrossSurfaceNaiveStackSelection as Jr, agentProfileHash as Jt, SearchPlannedEvent as K, pairHoldout as Kn, CrossSurfaceInteractionReport as Kr, HarnessType$1 as Kt, SearchLedgerAppendResult as L, classifyUngroundedLiterals as Ln, CrossSurfaceComponentEvidence as Lr, BackendIntegrityError as Lt, SearchCandidateSurface as M, RolloutArgumentDiff as Mn, CrossSurfaceCandidateComparison as Mr, ProfileSummary as Mt, SearchCompletedEvent as N, RolloutArgumentDiffOptions as Nn, CrossSurfaceCandidateEvidence as Nr, RunProfileMatrixOptions as Nt, SearchCandidateLineage as O, neutralizeText as On, CrossSurfaceAttemptCompleteness as Or, scoreboardSummary as Ot, SearchCostAccounting as P, RolloutCall as Pn, CrossSurfaceCandidateOutcome as Pr, RunProfileMatrixResult as Pt, SearchSurfaceKind as Q, SequentialPairedGateOptions as Qn, CrossSurfacePairwiseEntry as Qr, harnessAxisOf as Qt, SearchLedgerEntry as R, rolloutArgumentDiff as Rn, CrossSurfaceCompositionStep as Rr, BackendIntegrityReport as Rt, OpenSearchLedgerOptions as S, failureModeRecallJudge as Si, ValidationResult as Sn, loadEvalFixtureScenarios as Sr, ScoreboardSummary as St, SearchArtifactRef as T, containsAll as Tn, AnalyzeCrossSurfaceInteractionsInput as Tr, makePlaybackDispatch as Tt, SearchOperationKind as U, detectScale as Un, CrossSurfaceInteractionAwareSelection as Ur, AgentProfile$1 as Ut, SearchLedgerReplay as V, HeldoutSignificanceOptions as Vn, CrossSurfaceEvidenceBreakdown as Vr, summarizeAgentReceiptIntegrity as Vt, SearchOperationRecordedEvent as W, dimensionRegressions as Wn, CrossSurfaceInteractionEffect as Wr, CODING_HARNESSES as Wt, SearchSurfaceEffect as X, SequentialObservation as Xn, CrossSurfacePairEvidence as Xr, agentProfileModelId as Xt, SearchSourceRef as Y, SequentialDecision as Yn, CrossSurfacePairCompatibility as Yr, agentProfileId as Yt, SearchSurfaceEvidence as Z, SequentialPairedGate as Zn, CrossSurfacePairIncompatibilityReason as Zr, expandProfileAxes as Zt, surfaceHash as _, AnalystArtifact as _i, verifyCompletion as _n, EvalFixtureValidationMode as _r, PlaybackContext as _t, WorktreeAdapterError as a, MatchedPair as ai, CompletionVerdict as an, canonicalize as ar, SearchLedgerError as at, acquireSingleRunLock as b, FailureModeRecallJudgeOptions as bi, ValidationContext as bn, discoverEvalFixtures as br, ScoreboardRenderOptions as bt, verifyCodeSurface as c, PairArmsResult as ci, ProducedProposal as cn, signManifest as cr, campaignBreakdown as ct, assertCodeSurfaceIdentity as d, PairedArmsComparison as di, SatisfiedBy as dn, neutralizationGate as dr, DiscriminationScore as dt, CrossSurfaceRelativeCost as ei, ProposalEventLike as en, sequentialPairedGate as er, SearchTaskOutcome as et, assertComponentSurface as f, PairedCorrectness as fi, TaskGold as fn, EvalFixture as fr, ScenarioSignal as ft, surfaceContentHash as g, pairRunRecords as gi, parseCorrectnessResponse as gn, EvalFixtureScenario as gr, tangleTracesRoot as gt, renderSurfaceDiff as h, pairArms as hi, createTokenRecallChecker as hn, EvalFixtureRunPlan as hr, resolveRunDir as ht, WorktreeAdapter as i, ComparePairedArmsOptions as ii, CompletionRequirement as in, SignedManifestAlgo as ir, SearchLedgerConflictError as it, SearchCandidateSlotClosedEvent as j, LabeledScenarioStoreError as jn, CrossSurfaceCandidate as jr, ProfileMatrixError as jt, SearchCandidateRegisteredEvent as k, FsLabeledScenarioStore as kn, CrossSurfaceBestSingleSelection as kr, userStoryScoreboard as kt, TransientFailureOptions as l, PairRunRecordsResult as li, ProducedState as ln, verifyManifest as lr, campaignMeanComposite as lt, componentSurfaceIdentityMaterial as m, comparePairedArms as mi, createLlmCorrectnessChecker as mn, EvalFixtureLoadOptions as mr, selectDiscriminative as mt, GitWorktreeAdapterOptions as n, CrossSurfaceSelections as ni, ToolCallEventLike as nn, HypothesisResult as nr, openSearchLedger as nt, gitWorktreeAdapter as o, MatchedRunRecordPair as oi, CorrectnessChecker as on, evaluateHypothesis as or, SearchLedgerIntegrityError as ot, codeSurfaceIdentityMaterial as p, PairedMetricDelta as pi, completionVerdict as pn, EvalFixtureFile as pr, scoreDiscrimination as pt, SearchPlannedOperation as q, SequentialDecideFn as qn, CrossSurfaceInteractionTask as qr, ProfileAxisSpec as qt, Worktree as r, CrossSurfaceTaskRow as ri, extractProducedState as rn, SignedManifest as rr, validateSearchLedgerEvent as rt, resolveWorktreePath as s, PairArmsOptions as si, LlmCorrectnessCheckerOpts as sn, hashJson as sr, CampaignBreakdown as st, CodeSurfaceVerification as t, CrossSurfaceSelectionPolicy as ti, RuntimeEventLike as tn, HypothesisManifest as tr, SearchTokenAccounting as tt, isTransientTransportFailure as u, PairedArmRow as ui, RequirementCheck as un, NeutralizationGateOptions as ur, compareRankKeys as ut, SingleRunLock as v, AnalystScenario as vi, Artifact as vn, LoadEvalFixtureScenariosOptions as vr, PlaybackDriver as vt, SearchAccountingAudit as w, composeValidators as wn, analyzeCrossSurfaceInteractions as wr, UserStoryVerdict as wt, FileSearchLedger as x, buildAnalystSurfaceDispatch as xi, ValidationIssue as xn, loadEvalFixture as xr, ScoreboardRow as xt, SingleRunLockOptions as y, BuildAnalystSurfaceDispatchOptions as yi, ArtifactValidator as yn, PlanEvalFixtureRunOptions as yr, PlaybackStep as yt, SearchLedgerEvent as z, DimensionRegression as zn, CrossSurfaceDistribution as zr, assertRealAgentReceipts as zt };
+//# sourceMappingURL=index-DE5fb3EC.d.ts.map