@tangle-network/agent-eval 0.126.7 → 0.127.0

package/dist/campaign/index.d.ts

@@ -237,6 +237,7 @@ type CostLedgerHandle = Pick<CostLedger, Exclude<keyof CostLedger, 'listPending'
  * OpenAI-compatible `/v1/chat/completions` client with:
  *   - Exponential-backoff retry on 429 + 5xx gateway errors (502/503/504).
  *   - Retry on transient network errors (fetch failed, AbortError, ECONNRESET).
+ *   - One retry at temperature 1 when a model explicitly requires it.
  *   - Graceful json_schema → json_object degrade on 400 with schema-reject body.
  *   - Fenced-JSON stripping (```json ... ```) for models that wrap structured output.
  *   - Configurable base URL + api key / bearer, works with LiteLLM proxies, OpenAI
@@ -419,7 +420,8 @@ type FailureClass = 'success' | 'reasoning_error' | 'tool_selection_error' | 'to
  * researcher loop SHOULD be recorded as a `RunRecord`. The mandatory
  * fields are exactly those the paper "Two Loops, Three Roles" requires
  * for reproducibility: who/what/when/cost/seed/hash, plus the search vs
- * holdout split tag and either a `searchScore` or a `holdoutScore`.
+ * holdout split tag. A task score is optional because execution-only records
+ * must preserve missing labels instead of converting errors into zero quality.
  *
  * This is intentionally NOT a replacement for the rich `Run` /
  * `ProposeReviewReport` / `ScenarioResult` types already in the
@@ -440,6 +442,13 @@ type FailureClass = 'success' | 'reasoning_error' | 'tool_selection_error' | 'to
 /** Search/dev/holdout split tag. 'search' is the paper-grade alias for the
  *  combined train+test pool that the optimizer is allowed to read. */
 type RunSplitTag = 'search' | 'dev' | 'holdout';
+/**
+ * Explicit execution-lifecycle result for a run.
+ *
+ * This is separate from task quality (`outcome`) and failure classification.
+ * Producers set it only from root-run or process evidence.
+ */
+type RunTerminalOutcome = 'succeeded' | 'failed' | 'cancelled' | 'incomplete' | 'unknown';
 interface RunTokenUsage {
     input: number;
     /** All generated tokens charged as output, including reasoning tokens. */
@@ -453,11 +462,6 @@ interface RunTokenUsage {
 }
 /**
  * How a run's USD amount was obtained.
- *
- * `costUsd` remains mandatory for wire compatibility. New producers should
- * always populate this discriminated union so a missing bill is never
- * mistaken for an observed zero-dollar run. For `uncaptured`, `costUsd` uses
- * the legacy `0` sentinel while this field carries the truthful null.
  */
 type RunCostProvenance = {
     kind: 'observed';
@@ -503,8 +507,8 @@ interface JudgeScoresRecord {
     perJudge: Record<string, Record<string, number>>;
     /** Per-dim mean across judges. Convenience — derivable from `perJudge`. */
     perDimMean: Record<string, number>;
-    /** Composite mean across all dims and judges. Mirrors the score
-     *  the gate sees on `outcome.searchScore` / `holdoutScore`. */
+    /** Composite mean across successful judges. Mirrors the task score only
+     *  when `failedJudges` is empty. */
     composite: number;
     /** Judges that errored or returned an unparseable verdict. Recorded
      *  by id (e.g. `['glm-5.1']`) so a partial-failure case is explicit,
@@ -515,11 +519,11 @@ interface JudgeScoresRecord {
     notes?: string;
 }
 interface RunOutcome {
-    /** Score on the search/optimization split. Optional because a
-     *  holdout-only evaluation only fills `holdoutScore`. */
+    /** Score on the search/optimization split. Optional for holdout-only and
+     *  execution-only records. */
     searchScore?: number;
-    /** Score on the held-out split. Optional because a search-only run
-     *  only fills `searchScore`. At least one must be present. */
+    /** Score on the held-out split. Optional for search-only and execution-only
+     *  records. When both scores are absent, the run is explicitly unlabeled. */
     holdoutScore?: number;
     /** Bag of any other metric the run produced — judge dimensions,
      *  pass/fail counters, latency stats, etc. Numeric only — keeps
@@ -583,42 +587,39 @@ interface RunRecord {
     wallMs: number;
     /** Time spent queued before execution started, if known. */
     queueMs?: number;
-    /** Total USD cost. Mandatory — runs without a cost number are
-     *  unbounded by definition and must not be admitted into the gate.
-     *  `0` is retained as the compatibility sentinel for an uncaptured amount;
-     *  inspect `costProvenance` before treating it as observed. */
-    costUsd: number;
-    /** Observed, model-priced estimate, or genuinely uncaptured USD amount.
-     *  Optional only so existing serialized RunRecords remain valid. */
-    costProvenance?: RunCostProvenance;
+    /** Total USD cost, or null when the producer could not capture one. */
+    costUsd: number | null;
+    /** Whether `costUsd` came from billing data, a price calculation, or is unavailable. */
+    costProvenance: RunCostProvenance;
     /** Token usage breakdown. */
     tokenUsage: RunTokenUsage;
+    /** Root-run or process terminal result. Never inferred from a child span. */
+    terminalOutcome: RunTerminalOutcome;
+    /** Root-run or process failure reason. Valid only for a failed, cancelled,
+     *  or incomplete terminal result; never populated from a child span. */
+    terminalFailureReason?: string;
     /** Judge-side metadata, if a judge was used. */
     judgeMetadata?: RunJudgeMetadata;
     /** Per-split scores + raw bag. */
     outcome: RunOutcome;
-    /** Canonical, cross-agent failure class drawn from the shared
+    /** Canonical task-failure class drawn from the shared
      *  `FAILURE_CLASSES` taxonomy. This is the aggregation key that makes
      *  "which failure dominates across the whole fleet" answerable in ONE
      *  vocabulary — every agent classifies against the same enum. Producers
-     *  set it via the substrate classifier; leave unset only when the failure
-     *  genuinely can't be classified. */
+     *  set it only from task-result evidence. Execution errors belong in
+     *  `outcome.raw.execution_error_count`, even when the run later fails. */
     failureClass?: FailureClass;
-    /** Free-form domain-specific failure detail, scoped UNDER `failureClass`
+    /** Free-form task-failure detail, scoped UNDER `failureClass`
      *  (e.g. failureClass='tool_recovery_failure', failureMode='forge_build_unsatisfied').
-     *  The within-agent drill-down; `failureClass` is the cross-agent key. */
+     *  Do not populate this from a child execution error alone. */
     failureMode?: string;
     /** Which split this run was drawn from. */
     splitTag: RunSplitTag;
     /**
-     * Stable scenario identifier the run was scored against. Optional for
-     * backwards compatibility, but **strongly recommended**: every primitive
-     * that pairs runs by scenario (preferences, paired stats, BT tournament)
-     * keys on this. The campaign artifact populates it canonically; legacy
-     * runs without it fall back to inference from `outcome.raw.scenario_id`
-     * or `experimentId`.
+     * Stable scenario identifier the run observed or was scored against.
+     * Comparison primitives match this identity rather than input order.
      */
-    scenarioId?: string;
+    scenarioId: string;
     /**
      * Canonical identity for the agent profile cell that produced this row:
      * profile artifact hash plus optional harness/model/prompt/reporting
@@ -976,6 +977,13 @@ interface OptimizerConfig extends OptimizerConfigBase {
 }
 /** Five-valued verdict taxonomy (MOSS-paper alignment). */
 type GateDecision = 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
+/** Outcome of one check that contributed to a release decision. */
+type GateCheckStatus = 'pass' | 'fail' | 'not_evaluated';
+interface GateContribution {
+    name: string;
+    status: GateCheckStatus;
+    detail: unknown;
+}
 interface GateContext<TArtifact, TScenario extends Scenario> {
     candidateArtifacts: Map<string, TArtifact>;
     baselineArtifacts?: Map<string, TArtifact>;
@@ -1009,11 +1017,7 @@ interface GateContext<TArtifact, TScenario extends Scenario> {
 interface GateResult {
     decision: GateDecision;
     reasons: string[];
-    contributingGates: Array<{
-        name: string;
-        passed: boolean;
-        detail: unknown;
-    }>;
+    contributingGates: GateContribution[];
     delta?: number;
 }
 /** Composable promotion gate. */
@@ -1157,6 +1161,10 @@ interface CampaignCellResult<TArtifact> {
     durationMs: number;
     seed: number;
     cached: boolean;
+    /** Stage that produced `error`. Missing on successful cells. */
+    errorStage?: 'dispatch' | 'judge';
+    /** Judge that threw when `errorStage` is `judge`. */
+    errorJudge?: string;
     error?: string;
 }
 interface JudgeAggregate {
@@ -1181,8 +1189,10 @@ interface GenerationRecord {
  *  handled — the evidence a blind `Mutator` cannot see. */
 interface GenerationCandidate {
     surfaceHash: string;
-    composite: number;
-    ci95: [number, number];
+    /** Mean over complete task-quality scores, or null when none were produced. */
+    composite: number | null;
+    /** Descriptive interval for `composite`, or null when no score exists. */
+    ci95: [number, number] | null;
     /** Exact surface this candidate mutated. */
     parentSurfaceHash?: string;
     /** Measured search-split composite of the exact parent surface. */
@@ -1192,13 +1202,12 @@ interface GenerationCandidate {
     observedDeltaFromParent?: number;
     /** Whether this candidate had a scorable result for every designed campaign
      *  cell and was therefore eligible for ranking, promotion, and Pareto
-     *  selection. Older externally-authored records may omit this field; loop
-     *  records always populate it. */
-    eligibleForPromotion?: boolean;
+     *  selection. */
+    eligibleForPromotion: boolean;
     /** Exact denominator receipt for selection eligibility. Scores stay
      *  descriptive: an incomplete candidate is retained with its observed score
      *  and errors instead of receiving an invented penalty. */
-    coverage?: {
+    coverage: {
         expectedCells: number;
         scorableCells: number;
         unscorableCells: Array<{
@@ -1239,10 +1248,18 @@ interface CampaignAggregates {
     cost: CostLedgerSummary;
     /** Compatibility alias of `cost.totalCostUsd`. */
     totalCostUsd: number;
+    /** Cells whose dispatch completed, including cells whose later judge failed. */
     cellsExecuted: number;
     cellsSkipped: number;
     cellsCached: number;
+    /** All non-skipped dispatch, judge, and unclassified cell failures. */
     cellsFailed: number;
+    /** Present on results that record failure stages. */
+    cellsDispatchFailed?: number;
+    /** Present on results that record failure stages. */
+    cellsJudgeFailed?: number;
+    /** Legacy failures whose stage was not recorded. */
+    cellsUnclassifiedFailed?: number;
 }
 interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scenario> {
     /** sha256(scenarios, judges, dispatch source ref, optimizer config, seed). Stable identity for reruns. */
@@ -1379,7 +1396,7 @@ declare function createReferenceEquivalenceJudge(options: ReferenceEquivalenceJu
  * `ViewTraceOversized`.
  */
 /** OTLP span kind (subset we actually use). */
-type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
+type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'EVALUATOR' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
 type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
 /** Subset of OTLP span fields the analyst exposes to the agent. The
  *  store's job is to project upstream's full span shape down to this
@@ -1948,10 +1965,10 @@ interface PairedMetricDelta {
     n: number;
     /** Pairs where at least one side does not carry the metric. */
     nMissing: number;
-    /** Median paired delta; NaN when `n === 0` (no data ≠ measured zero). */
-    medianDelta: number;
-    /** Mean paired delta; NaN when `n === 0`. */
-    meanDelta: 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. */
@@ -2856,6 +2873,86 @@ declare function planEvalFixtureRun<TArtifact = unknown>(options: PlanEvalFixtur
  *  (so the result records every gate's reason — useful for diagnostics). */
 declare function composeGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(...gates: Array<Gate<TArtifact, TScenario>>): Gate<TArtifact, TScenario>;
 
+/**
+ * Liveness canaries — cheap statistical checks that catch the failure
+ * modes a green test suite never sees.
+ *
+ * Three canary types in this module:
+ *
+ *   1. **Silent judge fallback** — the judge degraded to a fallback
+ *      path (rules-only / cached / heuristic) without anyone
+ *      noticing. Signature: a string of consecutive runs whose
+ *      `judgeMetadata.confidence` equals a known fallback constant
+ *      (default 0.30) OR whose `judgeMetadata.fallback` is true.
+ *
+ *   2. **Judge calibration drift** — the judge's confidence
+ *      distribution has drifted from a historical window. Two-sample
+ *      Kolmogorov-Smirnov test on the recent vs historical confidences,
+ *      with the empirical-CDF max-difference statistic.
+ *
+ *   3. **Eval-set distribution shift** — the mix of categories /
+ *      buckets in the recent runs differs significantly from the
+ *      historical mix. Chi-square test on the binned counts.
+ *
+ * Outputs are alerts. The canary does NOT fail loud the way a test
+ * does — failing tests are reserved for hard correctness violations.
+ * A canary that fires is a *signal* to investigate, not a verdict.
+ *
+ * Why this lives here rather than in `observability.ts`: that module
+ * exports already, and is a pure-fanout-to-Langfuse/Prometheus
+ * adapter. Canaries are statistical detectors, not adapters.
+ */
+
+interface CanaryOptions {
+    /**
+     * Silent-fallback detection.
+     * - `constant`: confidence value treated as the fallback signal.
+     *   Default 0.30 (matches the soft-fail default in
+     *   `propose-review.ts`).
+     * - `consecutiveThreshold`: trip the alert after this many
+     *   consecutive runs at `constant` (or `fallback === true`).
+     *   Default 3.
+     */
+    silentFallback?: {
+        constant?: number;
+        consecutiveThreshold?: number;
+        /** Floating-point tolerance when comparing against `constant`. */
+        epsilon?: number;
+    };
+    /**
+     * Calibration-drift detection.
+     * - `historyWindow`: number of past runs (oldest-first) treated as
+     *   the historical baseline. Default 50.
+     * - `recentWindow`: number of recent runs (newest-first) compared
+     *   against history. Default 20.
+     * - `ksAlpha`: alpha for the KS statistic vs critical value.
+     *   Default 0.05.
+     * - `minRecent`: minimum recent runs required to even attempt the
+     *   check. Default 10.
+     */
+    calibrationDrift?: {
+        historyWindow?: number;
+        recentWindow?: number;
+        ksAlpha?: number;
+        minRecent?: number;
+    };
+    /**
+     * Distribution-shift detection.
+     * - `category`: function that maps a run to a categorical bucket.
+     *   Required to enable this canary; if omitted the chi-square check
+     *   is skipped entirely.
+     * - `chiSquareAlpha`: alpha. Default 0.05.
+     * - `historyWindow`, `recentWindow`, `minRecent`: like above.
+     */
+    distributionShift?: {
+        category: (run: RunRecord) => string | null;
+        chiSquareAlpha?: number;
+        historyWindow?: number;
+        recentWindow?: number;
+        minRecent?: number;
+    };
+}
+
 /**
  * Dataset — versioned, sliceable, content-hashed scenario collection.
  *
@@ -2927,6 +3024,178 @@ interface RedTeamCase extends DatasetScenario {
     payload: RedTeamPayload;
 }
 
+/**
+ * Validator-output verdict — substrate primitive for "did this output pass,
+ * and how well?"
+ *
+ * Used by:
+ *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.
+ *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.
+ *     Runtime keeps `Validator` because it's coupled to runtime-shaped
+ *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE
+ *     itself is a substrate concept and lives here.
+ *
+ * Repo layering: agent-eval is the substrate (no upward deps). Both
+ * agent-runtime and agent-knowledge consume this type FROM agent-eval —
+ * never the other way around. See CLAUDE.md "Repo layering" for the rule.
+ */
+/**
+ * Minimal verdict shape — `valid` + `score` are required; `scores` +
+ * `notes` are optional surface. Validators that need richer shapes
+ * parameterise `Validator<Output, MyVerdict>` with their own type.
+ *
+ * Need structured extras? Extend DefaultVerdict with typed fields — never
+ * serialize extras into `notes`.
+ */
+interface DefaultVerdict {
+    /** Whether the output meets the validator's pass criteria. */
+    valid: boolean;
+    /** Aggregate score in [0, 1]. Drivers use this for winner selection. */
+    score: number;
+    /** Per-dimension scores. Free-form; weighted into `score` by the validator. */
+    scores?: Record<string, number>;
+    /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */
+    notes?: string;
+}
+
+/**
+ * Verifiable reward channel.
+ *
+ * For RL on coding / math / theorem-proving / structured-output tasks, the
+ * reward signal is *decidable* — a test passes or fails, a proof checks or
+ * doesn't, an output validates against a schema or doesn't. These rewards
+ * are dramatically more useful for RL training than LLM-judge scores
+ * because they don't drift, can't be Goodhart-gamed by the policy in the
+ * same way, and don't require a separate calibration loop.
+ *
+ * The `MultiLayerVerifier` already produces this signal — it just doesn't
+ * surface it in a shape that's clean enough for RL training. This module
+ * wraps the verifier output so consumers can:
+ *
+ *   1. Extract a clean `VerifiableReward` from a `VerificationReport`
+ *   2. Distinguish *deterministic* rewards (compile, test, schema) from
+ *      *probabilistic* rewards (judge) so they can be weighted differently
+ *      in the RL training step
+ *   3. Filter `RunRecord[]` to only those with a verifiable reward,
+ *      producing the clean training set that DeepSeek-R1-style GRPO and
+ *      AlphaProof-style search both depend on
+ *
+ * Why this matters: every credible 2025-2026 frontier RL result on coding
+ * agents leans on verifiable reward (DeepSeek-R1 GRPO on test pass-rate,
+ * o-series RL on math/code, AlphaProof on Lean kernel checking). Mixing
+ * judge scores into the reward signal poisons the gradient. This module
+ * is the seam.
+ */
+
+type VerifiableRewardSource = 'compile' | 'test' | 'schema' | 'sandbox' | 'judge' | 'composite';
+interface VerifiableRewardExtractionOptions {
+    /**
+     * Which layers count as deterministic-reward sources. The verifier doesn't
+     * tag layers as "this is verifiable"; the caller declares it via this list
+     * (or via the layer name → source mapping). Default treats common names
+     * (`install`, `typecheck`, `build`, `lint`, `test`, `compile`, `schema`,
+     * `sandbox`) as deterministic.
+     */
+    deterministicLayers?: string[];
+    /**
+     * Map layer name → reward source. Defaults to a sensible string-match.
+     */
+    sourceFor?: (layerName: string) => VerifiableRewardSource;
+    /**
+     * Whether to fall back to a probabilistic (judge) reward when no
+     * deterministic layer produced a numeric score. Default `true`. Set to
+     * `false` for "deterministic-only" training pipelines that should
+     * discard runs without a verifiable signal.
+     */
+    fallbackToJudge?: boolean;
+    /**
+     * Default confidence for probabilistic (judge) rewards when the judge
+     * doesn't report one. Default `0.7`.
+     */
+    judgeConfidenceFloor?: number;
+}
+
+/**
+ * Reward hacking / Goodhart detection.
+ *
+ * Goodhart's Law says: when a measure becomes a target, it ceases to be
+ * a good measure. In RLHF and agentic-RL settings this is the dominant
+ * failure mode — the policy learns to produce outputs that score well on
+ * the proxy reward (judge, rubric, test pass-rate) without producing
+ * the underlying capability the proxy was meant to track.
+ *
+ * Krakovna et al. (2020, "Specification Gaming Examples in AI") and the
+ * subsequent RLHF reward-hacking literature (Skalse et al. 2022, Kim et al.
+ * 2023) converge on a few diagnostic signatures:
+ *
+ *   1. **Reward divergence:** the proxy reward grows while the held-out
+ *      ground-truth signal stagnates or drops. Predictive validity over
+ *      time captures this.
+ *   2. **Distributional shift in outputs:** after RL, the policy produces
+ *      outputs that no longer match the reference distribution — usually
+ *      because it found a high-reward attractor that's degenerate (e.g.
+ *      one-token responses, repetition, formatting tricks).
+ *   3. **Disagreement between independent rewards:** if you train on
+ *      reward A and a held-out independent reward B drops sharply, you're
+ *      probably hacking A.
+ *   4. **Calibration drift:** the verifiable / deterministic component of
+ *      the reward is stable; the probabilistic / judge component drifts up
+ *      while the deterministic component doesn't. The judge is being
+ *      gamed.
+ *
+ * This module ships explicit detectors for all four signatures, plus a
+ * combined verdict. The output is diagnostic — actionable signals,
+ * not autoreject — because each signature has known false positives
+ * (e.g., a policy that genuinely improves can show distributional shift).
+ *
+ * Differs from `rubricPredictiveValidity` (which is a *standing* check on
+ * whether rubrics correlate with deployment outcomes) — this is a
+ * *temporal* check on whether the reward-vs-truth gap is *widening over
+ * time during a training run*.
+ */
+
+interface DetectRewardHackingInput {
+    /**
+     * Run records ordered by recency (oldest first). The detector segments
+     * them into prefix/suffix windows to compute "did the gap widen."
+     */
+    runs: RunRecord[];
+    /**
+     * The metric the policy was trained to optimize. Should be present on
+     * `outcome.raw` or `outcome.holdoutScore`. Default reads `outcome.holdoutScore`.
+     */
+    proxyOf?: (run: RunRecord) => number | null;
+    /**
+     * The held-out ground-truth metric. For RL on coding, this is typically
+     * test pass-rate. For RLHF, it's downstream task performance or human
+     * preference. For knowledge tasks, it's an independently-graded score.
+     */
+    truthOf?: (run: RunRecord) => number | null;
+    /**
+     * Independent secondary reward. Used for the `reward_disagreement`
+     * signal. Default uses the verifiable reward extractor (deterministic
+     * sources only).
+     */
+    secondaryRewardOf?: (run: RunRecord) => number | null;
+    /**
+     * Window size — how many of the most recent runs count as the "after"
+     * cohort. Default min(50, half the runs).
+     */
+    windowSize?: number;
+    /**
+     * Severity threshold to flag a signal. Default 0.3 (suspect) and 0.6
+     * (gaming).
+     */
+    thresholds?: {
+        suspect?: number;
+        gaming?: number;
+    };
+    /**
+     * Verifiable-reward options used for the secondary-reward fallback.
+     */
+    verifiableRewardOptions?: VerifiableRewardExtractionOptions;
+}
+
 /**
  * `defaultProductionGate` — composes the substrate's existing safety
  * primitives (red-team / reward-hacking / canary / heldout) into a single
@@ -2939,6 +3208,10 @@ interface RedTeamCase extends DatasetScenario {
  * extra domain-specific gates they need (`composeGate(defaultProductionGate(...), customGate)`).
  */
 
+type DefaultProductionGateCheck = 'dimension-regression' | 'budget' | 'red-team' | 'reward-hacking' | 'canary';
+type DefaultProductionRewardHackingOptions = Omit<DetectRewardHackingInput, 'runs' | 'truthOf'> & {
+    truthOf: NonNullable<DetectRewardHackingInput['truthOf']>;
+};
 interface DefaultProductionGateOptions {
     /** Required: scenarios held out from training; substrate compares
      *  candidate-on-holdout vs baseline-on-holdout. */
@@ -2971,19 +3244,25 @@ interface DefaultProductionGateOptions {
      *  native scale. When omitted it auto-scales off observed magnitudes:
      *  0.05 on [0,1], 5 on 0-100. */
     regressionTolerance?: number;
-    /** Total $ budget for ALL cells in this campaign — including baseline + candidate.
-     *  Composite verdict refuses to ship when spend exceeded budget. */
+    /** Total $ budget for the complete improvement run. Requires
+     *  `GateContext.costLedger`; missing or incomplete accounting holds. */
     budgetUsd?: number;
-    /** Red-team cases to probe candidate outputs against. When omitted the
-     *  substrate uses `DEFAULT_RED_TEAM_CORPUS`. Provide a domain-specific
-     *  battery for tighter coverage. */
+    /** Static artifact-screening cases. Only `expected: 'ignore'` cases without
+     *  tool assertions are valid because this check does not dispatch case inputs
+     *  or observe tool calls. */
     redTeamBattery?: RedTeamCase[];
-    /** Run records (oldest-first) needed for the reward-hacking detector.
-     *  Substrate populates from prior production-loop generations. */
+    /** Shared run history, oldest first. Supplying history does not enable either
+     *  monitoring check; configure `rewardHacking` and/or `canary` explicitly. */
     recentRuns?: RunRecord[];
-    /** When true, the gate refuses to ship if the reward-hacking detector
-     *  fires at the `gaming` severity. Default true. */
-    blockOnRewardHackingGaming?: boolean;
+    /** Enable reward-hacking monitoring with a caller-owned independent truth channel. */
+    rewardHacking?: DefaultProductionRewardHackingOptions;
+    /** Enable canary monitoring. Pass `{}` to use the canary defaults. */
+    canary?: CanaryOptions;
+    /** Optional checks that must be evaluated even when their normal input is
+     *  absent. Configuring a check's input also makes that check required.
+     *  Missing evidence always records `not_evaluated`; required unevaluated
+     *  checks hold the release decision. Held-out significance is always required. */
+    requiredChecks?: DefaultProductionGateCheck[];
 }
 /**
  * Opinionated production gate composing held-out significance, red-team, reward-hacking, and canary checks into a single `Gate.decide` decision.
@@ -3902,40 +4181,6 @@ interface Artifact {
     metadata?: Record<string, unknown>;
 }
 
-/**
- * Validator-output verdict — substrate primitive for "did this output pass,
- * and how well?"
- *
- * Used by:
- *   - `@tangle-network/agent-eval/matrix` — verdict per cell in the cartesian.
- *   - `@tangle-network/agent-runtime` — Validator<Output, Verdict = DefaultVerdict>.
- *     Runtime keeps `Validator` because it's coupled to runtime-shaped
- *     `ValidationCtx` (iteration, signal, traceEmitter); the verdict TYPE
- *     itself is a substrate concept and lives here.
- *
- * Repo layering: agent-eval is the substrate (no upward deps). Both
- * agent-runtime and agent-knowledge consume this type FROM agent-eval —
- * never the other way around. See CLAUDE.md "Repo layering" for the rule.
- */
-/**
- * Minimal verdict shape — `valid` + `score` are required; `scores` +
- * `notes` are optional surface. Validators that need richer shapes
- * parameterise `Validator<Output, MyVerdict>` with their own type.
- *
- * Need structured extras? Extend DefaultVerdict with typed fields — never
- * serialize extras into `notes`.
- */
-interface DefaultVerdict {
-    /** Whether the output meets the validator's pass criteria. */
-    valid: boolean;
-    /** Aggregate score in [0, 1]. Drivers use this for winner selection. */
-    score: number;
-    /** Per-dimension scores. Free-form; weighted into `score` by the validator. */
-    scores?: Record<string, number>;
-    /** Human-readable rationale; surfaces in trace + final-result `winner.verdict`. */
-    notes?: string;
-}
-
 /**
  * Completion verifier — the task-completion oracle.
  *
@@ -4251,8 +4496,8 @@ interface ProfileSummary {
     model: string;
     /** RunRecords produced for this profile (= scenarios × reps). */
     records: number;
-    /** Mean composite across this profile's records. */
-    meanComposite: 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. */
@@ -4480,7 +4725,7 @@ interface RunOptimizationBaseOptions<TScenario extends Scenario, TArtifact> exte
         candidates: Array<{
             surfaceHash: string;
             campaign: CampaignResult<TArtifact, TScenario>;
-            composite: number;
+            composite: number | null;
         }>;
         history: GenerationRecord[];
         /** Shared run spend account and receipt attribution phase. */
@@ -4641,7 +4886,7 @@ interface ParetoPoint {
     onFrontier: boolean;
     /** Optional gate verdict for this candidate, if a `GateDecision`
      *  for it was passed in. */
-    gate?: 'promote' | 'reject_few_runs' | 'reject_negative_delta' | 'reject_overfit_gap' | null;
+    gate?: 'promote' | 'reject';
 }
 interface ParetoFigureSpec {
     kind: 'pareto-cost-quality';
@@ -4695,8 +4940,8 @@ interface InsightReport {
     /** Number of runs analyzed. */
     n: number;
     /** Runtime facts carried by the run records. These describe execution,
-     *  not task quality: duration, queueing, token categories, models, and
-     *  explicitly recorded failures. */
+     *  not task quality: duration, queueing, token categories, models,
+     *  execution errors, and terminal outcomes. */
     execution: ExecutionInsight;
     /** Composite-score distribution across all runs. Always present. */
     composite: ScalarDistribution;
@@ -4754,10 +4999,9 @@ interface InsightReport {
      *  Surfaced metrics: composite, cost, duration, tokenUsage, plus any
      *  per-dimension judge metric present in both windows. */
     priorPeriodComparison?: PriorPeriodComparison;
-    /** Model-free failure-mode breakdown from `RunRecord.failureMode`, ranked
-     *  by count descending. Present when any run carries a `failureMode`.
-     *  Complements `failureClusters` (LLM-semantic) with the structured tags
-     *  the harness already recorded — actionable with no analyst wired. */
+    /** Model-free task-failure breakdown from `RunRecord.failureClass` or
+     *  `failureMode`, ranked by count descending. Tags from successful or
+     *  otherwise non-failed tasks are excluded. */
     failureModes?: FailureModeTally[];
     /** Top-N actionable recommendations, ranked by priority. The packet's
      *  human-readable layer; the numeric sections are the evidence. */
@@ -4806,14 +5050,45 @@ interface ExecutionInsight {
         events: number;
         reportingRuns: number;
     };
-    /** Failure counts remain separate from outcome scores. `reportedErrorEvents`
-     *  sums `outcome.raw.error_span_count` only where a producer supplied it. */
-    failures: {
+    /** Runs with explicit execution-error telemetry. This is independent of
+     *  whether the root run ultimately succeeded, failed, or has no terminal
+     *  evidence. */
+    executionErrors: {
         runs: number;
-        fraction: number;
-        reportedErrorEvents: number;
+        /** Share among runs that supplied an execution-error count.
+         *  `null` when no run supplied error telemetry. */
+        fraction: number | null;
+        /** Execution-error events reported through the canonical count. */
+        events: number;
+        /** Runs that supplied an execution-error count, including explicit zeroes. */
         reportingRuns: number;
+        /** Exact sum of `outcome.raw.error_span_count`, kept separate from other errors. */
+        errorSpanEvents: number;
+        /** Runs that supplied `outcome.raw.error_span_count`, including explicit zeroes. */
+        errorSpanReportingRuns: number;
+        /**
+         * Error-telemetry coverage crossed with independently reported terminal
+         * outcomes. `unreported` is distinct from a reported zero.
+         */
+        byTerminalOutcome: Record<RunTerminalOutcome, ExecutionErrorOutcomeCell>;
     };
+    /** Root-run or process outcomes. Missing `RunRecord.terminalOutcome` values
+     *  count as `unknown`; child-span status never changes these counts. */
+    terminalOutcomes: {
+        succeeded: number;
+        failed: number;
+        cancelled: number;
+        incomplete: number;
+        unknown: number;
+    };
+}
+interface ExecutionErrorOutcomeCell {
+    /** Runs that explicitly reported one or more execution errors. */
+    withErrors: number;
+    /** Runs that explicitly reported zero execution errors. */
+    withoutErrors: number;
+    /** Runs with no execution-error count from the producer. */
+    unreported: number;
 }
 interface TokenUsageInsight {
     input: ScalarDistribution;
@@ -4833,12 +5108,18 @@ interface TokenUsageInsight {
 interface ScalarDistribution {
     /** Sample count after dropping non-finite values. */
     n: number;
-    mean: number;
-    p50: number;
-    p95: number;
-    stddev: number;
-    min: number;
-    max: number;
+    /** Null when `n` is zero. */
+    mean: number | null;
+    /** Null when `n` is zero. */
+    p50: number | null;
+    /** Null when `n` is zero. */
+    p95: number | null;
+    /** Null when `n` is zero. */
+    stddev: number | null;
+    /** Null when `n` is zero. */
+    min: number | null;
+    /** Null when `n` is zero. */
+    max: number | null;
     /** Histogram bins using `agent-eval`'s `gainHistogram` primitive. */
     histogram: GainDistributionBin[];
     /** Worst-N runs by score, ascending. Populated for the composite
@@ -4904,12 +5185,16 @@ interface LiftInsight {
     pValue: number;
     /** Number of paired observations. */
     n: number;
-    /** Cohen's d for the delta. */
-    cohensD: number;
+    /** Scored baseline observations without a candidate match. */
+    unpairedBaseline: number;
+    /** Scored candidate observations without a baseline match. */
+    unpairedCandidate: number;
+    /** Cohen's dz for paired deltas; null when the observed delta variance is zero. */
+    cohensD: number | null;
     /** Minimum detectable effect at current n, 80% power. */
     mde: number;
-    /** Sample size needed to detect the observed delta at 80% power. */
-    requiredN: number;
+    /** Paired sample size needed to detect the standardized effect at 80% power. */
+    requiredN: number | null;
 }
 interface FailureClusterInsight {
     /** All clusters identified by the registry, ranked by share descending. */
@@ -4973,7 +5258,7 @@ interface ReleaseSummary {
     status: 'pass' | 'warn' | 'fail';
     axes: Array<{
         name: 'quality-lift' | 'contamination' | 'composite-distribution';
-        status: 'pass' | 'warn' | 'fail';
+        status: 'pass' | 'warn' | 'fail' | 'not_evaluated';
         detail: string;
     }>;
     /** Free-form issues surfaced beyond the standard axes. Empty by default;
@@ -5033,9 +5318,8 @@ interface Recommendation {
  * # Hosted-tier wire format — the schema that EVERY orchestrator (ours,
  * a partner's self-hosted one, a future open implementation) must accept.
  *
- * **Stability:** every type in this file is committed under semver. New
- * minors only ADD optional fields. Breaking changes mean a major bump
- * (`HostedWireVersion` literal increment).
+ * This package implements exactly one wire version. Servers reject every
+ * other version instead of translating old payloads.
  *
  * The wire format is two event streams in one transport:
  *
@@ -5054,7 +5338,7 @@ interface Recommendation {
  * ever sees another tenant's data.
  */
 
-declare const HOSTED_WIRE_VERSION: "2026-05-26.v1";
+declare const HOSTED_WIRE_VERSION: "2026-07-24.v1";
 type HostedWireVersion = typeof HOSTED_WIRE_VERSION;
 /** Lifecycle stages of an eval-run as the substrate reports them. */
 type EvalRunStatus = 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
@@ -5063,11 +5347,15 @@ interface EvalRunCellScore {
     scenarioId: string;
     /** Repetition index when reps > 1; 0 for the default. */
     rep: number;
-    /** Composite score across all judges + dimensions for this cell. */
-    compositeMean: number;
-    /** Per-judge → per-dimension scores; null where the judge did not run. */
+    /** Composite score across successful judges, or null when unscored. */
+    compositeMean: number | null;
+    /** Per-judge and per-dimension scores; failed or missing judges are absent. */
     dimensions: Record<string, Record<string, number>>;
-    /** Per-cell error message if the dispatch threw. Null on success. */
+    /** Root execution result, kept separate from task quality. */
+    terminalOutcome: RunTerminalOutcome;
+    /** Canonical execution-error count, or null when the producer did not measure it. */
+    executionErrorCount: number | null;
+    /** Per-cell dispatch or judge error. Missing on success. */
     errorMessage?: string;
 }
 interface EvalRunGenerationSnapshot {
@@ -5081,8 +5369,8 @@ interface EvalRunGenerationSnapshot {
     surface?: MutableSurface;
     /** Per-cell scores for this generation. */
     cells: EvalRunCellScore[];
-    /** Aggregate composite mean across all cells in this generation. */
-    compositeMean: number;
+    /** Mean across scored cells, or null when no cell has a task-quality label. */
+    compositeMean: number | null;
     /** Total $ spent across this generation. */
     costUsd: number;
     /** Wall-clock duration of this generation. */
@@ -5122,10 +5410,14 @@ interface EvalRunEvent {
      *  paired-bootstrap lift CI, judge stats, inter-rater agreement,
      *  contamination check, failure clusters (when an analyst is wired),
      *  outcome correlation (when downstream signal is supplied), and the
-     *  recommendations the dashboard surfaces verbatim. Additive; older
-     *  clients that don't know about this field continue to work. */
+     *  recommendations the dashboard surfaces verbatim. */
     insightReport?: InsightReport;
 }
+/**
+ * Canonical unsigned 64-bit integer encoded as a base-10 string.
+ * JSON numbers cannot represent OTLP nanosecond timestamps exactly.
+ */
+type UnixNanoTimestamp = string;
 /**
  * OTel-shape span with a few additional attributes for eval-run pivoting.
  * Compatible with any OTLP collector — `name`, `traceId`, `spanId`,
@@ -5136,11 +5428,11 @@ interface TraceSpanEvent {
     spanId: string;
     parentSpanId?: string;
     name: string;
-    startTimeUnixNano: number;
-    endTimeUnixNano: number;
+    startTimeUnixNano: UnixNanoTimestamp;
+    endTimeUnixNano: UnixNanoTimestamp;
     attributes: Record<string, string | number | boolean>;
     events?: Array<{
-        timeUnixNano: number;
+        timeUnixNano: UnixNanoTimestamp;
         name: string;
         attributes?: Record<string, string | number | boolean>;
     }>;
@@ -5257,8 +5549,8 @@ interface LoopProvenanceCandidate {
     eligibleForPromotion: boolean;
     /** Designed-denominator receipt retained even for incomplete candidates. */
     coverage: NonNullable<GenerationCandidate['coverage']>;
-    /** Mean composite this candidate scored on the search split. */
-    composite: number;
+    /** Mean composite this candidate scored on the search split, or null when unscorable. */
+    composite: number | null;
     /** Whether this candidate was promoted out of its generation. */
     promoted: boolean;
 }
@@ -5330,11 +5622,7 @@ interface LoopProvenanceRecord {
         decision: GateDecision;
         reasons: string[];
         delta?: number;
-        contributingGates: Array<{
-            name: string;
-            passed: boolean;
-            detail: unknown;
-        }>;
+        contributingGates: GateContribution[];
     };
     /** Present iff the loop ran with `holdout: 'deferred'` — the held-out
      *  comparison was intentionally not measured in this run, so the holdout
@@ -5529,11 +5817,9 @@ declare function selectDiscriminative(signals: ScenarioSignal[], k: number, opts
  * the optimizers cannot drift on how a surface's score is computed.
  */
 
-/** Mean composite across a campaign: per cell, the mean of its finite,
- *  successful judge composites; then the mean across cells. Invalid scores
- *  remain visible on raw cells and coverage receipts but never poison the
- *  descriptive aggregate with NaN. Cells with no valid scores are skipped.
- *  Empty ⇒ 0. */
+/** 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
@@ -6106,4 +6392,4 @@ declare function verifyCodeSurface(surface: CodeSurface, worktreeDir?: string):
  *  identity against the checkout at `worktreeRef`. */
 declare function resolveWorktreePath(surface: CodeSurface, worktreeDir?: string): string;
 
-export { type AnalystArtifact, type AnalystScenario, type AnalyzeCrossSurfaceInteractionsInput, type AxisEvidence, type AxisVerdict, type BuildAnalystSurfaceDispatchOptions, type BuildEvidenceVectorOptions, type BuildLoopProvenanceArgs, type CampaignAggregates, type CampaignArtifactWriter, type CampaignBreakdown, type CampaignCellFailureReceipt, type CampaignCellResult, type CampaignCostMeter, type CampaignResult, type CampaignRunPlan, type CampaignRunPlanCell, type CampaignScenarioIdentity, type CampaignStorage, type CampaignTokenUsage, type CampaignTraceWriter, type CodeSurface, type CodeSurfaceVerification, type CompareOptimizationMethodsOptions, type ComparisonCost, type ComponentSurface, type CostLedgerHandle, type CrossSurfaceAdditionDecision, type CrossSurfaceAdditionRejectionReason, type CrossSurfaceAttemptCompleteness, type CrossSurfaceBestSingleSelection, type CrossSurfaceBootstrapPolicy, type CrossSurfaceCandidate, type CrossSurfaceCandidateComparison, type CrossSurfaceCandidateEvidence, type CrossSurfaceCandidateOutcome, type CrossSurfaceCandidateSummary, type CrossSurfaceComponent, type CrossSurfaceComponentEvidence, type CrossSurfaceCompositionStep, type CrossSurfaceDistribution, type CrossSurfaceEligibility, type CrossSurfaceEvidenceBreakdown, type CrossSurfaceIneligibilityReason, type CrossSurfaceInteractionAwareSelection, type CrossSurfaceInteractionEffect, type CrossSurfaceInteractionPath, type CrossSurfaceInteractionReport, type CrossSurfaceInteractionTask, type CrossSurfaceNaiveStackSelection, type CrossSurfacePairCompatibility, type CrossSurfacePairEvidence, type CrossSurfacePairIncompatibilityReason, type CrossSurfacePairwiseEntry, type CrossSurfaceRankedSingle, type CrossSurfaceRelativeCost, type CrossSurfaceSelectionPolicy, type CrossSurfaceSelections, type CrossSurfaceTaskRow, type DefaultProductionGateOptions, type DimensionRegression, type DiscriminationScore, type DispatchContext, type DispatchFn, type EmitLoopProvenanceArgs, type EmitLoopProvenanceResult, type EvalFixture, type EvalFixtureFile, type EvalFixtureLoadOptions, type EvalFixtureRunPlan, type EvalFixtureScenario, type EvalFixtureValidationMode, type EvidenceVector, type ExternalOptimizationExample, type ExternalTextEvaluationResponse, type ExternalTextOptimizationMethodConfig, type ExternalTextOptimizerContext, type ExternalTextOptimizerResult, type FailureModeRecallJudgeOptions, FileSearchLedger, FsLabeledScenarioStore, type FsLabeledScenarioStoreOptions, type Gate, type GateContext, type GateDecision, type GateResult, type GenerationCandidate, type GenerationRecord, type GepaAdaptiveEngineRun, type GepaEngineOptions, type GepaEngineRun, type GepaOptimizationMethodConfig, type GepaOptimizationRecipe, type GepaRunnerCommand, type GitWorktreeAdapterOptions, type HeldOutGateOptions, type HeldoutSignificance, type HeldoutSignificanceOptions, type JudgeAggregate, type JudgeConfig, type JudgeDimension, type JudgeScore, type LabelTrust, type LabeledScenarioRecord, type LabeledScenarioSampleArgs, type LabeledScenarioSource, type LabeledScenarioStore, LabeledScenarioStoreError, type LabeledScenarioWrite, type LlmJudgeDimension, type LlmJudgeOptions, type LoadEvalFixtureScenariosOptions, type LoopProvenanceArgsFromResult, type LoopProvenanceBackend, type LoopProvenanceCandidate, type LoopProvenanceEvidence, type LoopProvenanceOptimizationMethod, type LoopProvenanceRecord, type MutableSurface, type NeutralizationGateOptions, type ObjectiveSource, type OpenAICompatibleOptimizerModel, type OpenAutoPrOptions, type OpenAutoPrResult, type OpenSearchLedgerOptions, type OptimizationMethod, type OptimizationMethodComparison, type OptimizationMethodInput, type OptimizationMethodPairwise, type OptimizationMethodProvenance, type OptimizationMethodResult, type OptimizationMethodRunOptions, type OptimizationMethodScore, type OptimizationPackageSource, type OptimizationProposer, type OptimizationTokenUsage, type OptimizerConfig, type OptimizerModelBudget, type PairedHoldout, type ParetoParent, type ParetoSignificanceGateOptions, type PendingCostCallView, type PlanCampaignRunOptions, type PlanEvalFixtureRunOptions, type PlaybackContext, type PlaybackDriver, type PlaybackStep, type PowerPreflight, type PowerPreflightOptions, type PremeasuredOptimizationBaseline, type ProfileDispatchFn, ProfileMatrixError, type ProfileSummary, type PromotionObjective, type PromotionPolicy, type ProposalTrackContext, type ProposeContext, type ProposedCandidate, type RedactionStatus, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceScenario, type RolloutArgumentDiff, type RolloutArgumentDiffOptions, type RolloutCall, type RunCampaignOptions, type RunEvalOptions, type RunImprovementLoopOptions, type RunImprovementLoopResult, type RunOptimizationOptions, type RunOptimizationResult, type RunProfileMatrixOptions, type RunProfileMatrixResult, SEARCH_LEDGER_SCHEMA, type Scenario, type ScenarioAggregate, type ScenarioRollup, type ScenarioSignal, type ScoreboardRenderOptions, type ScoreboardRow, type ScoreboardSummary, type ScoredRollout, type ScoredSurfaceOutcome, type SearchAccountingAudit, type SearchArtifactRef, type SearchAttemptAccounting, type SearchCandidateDecidedEvent, type SearchCandidateLineage, type SearchCandidateRegisteredEvent, type SearchCandidateSlot, type SearchCandidateSlotClosedEvent, type SearchCandidateSurface, type SearchCompletedEvent, type SearchCostAccounting, type SearchFailureReason, type SearchLedger, type SearchLedgerAppendResult, SearchLedgerConflictError, type SearchLedgerEntry, SearchLedgerError, type SearchLedgerEvent, type SearchLedgerHash, SearchLedgerIntegrityError, type SearchLedgerReplay, type SearchModelIdentity, type SearchOperationKind, type SearchOperationRecordedEvent, type SearchPlan, type SearchPlannedEvent, type SearchPlannedOperation, type SearchPlannedTask, type SearchSourceRef, type SearchSurfaceEffect, type SearchSurfaceEvidence, type SearchSurfaceKind, type SearchTaskAttemptedEvent, type SearchTaskOutcome, type SearchTokenAccounting, type SequentialDecideFn, type SequentialDecideOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SessionScript, type SingleRunLock, type SingleRunLockOptions, type SkillOptOptimizationMethodConfig, type SkillOptRunnerCommand, type SkillOptTrainerConfig, type SurfaceProposer, type TraceSpan, type TransientFailureOptions, type UngroundedLiteralReport, type UserStory, type UserStoryVerdict, type Worktree, type WorktreeAdapter, WorktreeAdapterError, acquireSingleRunLock, analyzeCrossSurfaceInteractions, assertCampaignDesign, assertCampaignSplitIdentity, assertCodeSurfaceIdentity, assertComponentSurface, buildAnalystSurfaceDispatch, buildEvidenceVector, buildLoopProvenanceRecord, campaignBreakdown, campaignMeanComposite, campaignMeasurementDigest, campaignScenarioIdentity, campaignSplitDigest, campaignSplitDigestFromIdentities, canonicalDigest, classifyUngroundedLiterals, codeSurfaceIdentityMaterial, compareOptimizationMethods, compareRankKeys, componentSurfaceIdentityMaterial, composeGate, costFromLedgerSummary, createReferenceEquivalenceJudge, createRunCostLedger, defaultProductionGate, detectScale, dimensionRegressions, discoverEvalFixtures, emitLoopProvenance, externalTextOptimizationMethod, failureModeRecallJudge, fsCampaignStorage, gepaOptimizationMethod, gitWorktreeAdapter, heldOutGate, heldoutSignificance, inMemoryCampaignStorage, isProposedCandidate, isTransientTransportFailure, labelTrustRank, llmJudge, loadEvalFixture, loadEvalFixtureScenarios, loopProvenanceArgsFromResult, loopProvenanceSpans, makePlaybackDispatch, neutralizationGate, neutralizeText, openAutoPr, openSearchLedger, optimizationTokenUsageFromSummary, pairHoldout, paretoPolicy, paretoSignificanceGate, planCampaignRun, planEvalFixtureRun, powerPreflight, provenanceRecordPath, provenanceSpansPath, renderScoreboardMarkdown, renderSurfaceDiff, resolveRunDir, resolveWorktreePath, rolloutArgumentDiff, runCampaign, runEval, runImprovementLoop, runOptimization, runProfileMatrix, scoreDiscrimination, scoreUserStory, scoreboardSummary, selectDiscriminative, sequentialDecide, sequentialPairedGate, skillOptOptimizationMethod, surfaceContentHash, surfaceHash, tangleTracesRoot, userStoryScoreboard, validateSearchLedgerEvent, verifyCodeSurface, verifyLoopProvenanceRecord };
+export { type AnalystArtifact, type AnalystScenario, type AnalyzeCrossSurfaceInteractionsInput, type AxisEvidence, type AxisVerdict, type BuildAnalystSurfaceDispatchOptions, type BuildEvidenceVectorOptions, type BuildLoopProvenanceArgs, type CampaignAggregates, type CampaignArtifactWriter, type CampaignBreakdown, type CampaignCellFailureReceipt, type CampaignCellResult, type CampaignCostMeter, type CampaignResult, type CampaignRunPlan, type CampaignRunPlanCell, type CampaignScenarioIdentity, type CampaignStorage, type CampaignTokenUsage, type CampaignTraceWriter, type CodeSurface, type CodeSurfaceVerification, type CompareOptimizationMethodsOptions, type ComparisonCost, type ComponentSurface, type CostLedgerHandle, type CrossSurfaceAdditionDecision, type CrossSurfaceAdditionRejectionReason, type CrossSurfaceAttemptCompleteness, type CrossSurfaceBestSingleSelection, type CrossSurfaceBootstrapPolicy, type CrossSurfaceCandidate, type CrossSurfaceCandidateComparison, type CrossSurfaceCandidateEvidence, type CrossSurfaceCandidateOutcome, type CrossSurfaceCandidateSummary, type CrossSurfaceComponent, type CrossSurfaceComponentEvidence, type CrossSurfaceCompositionStep, type CrossSurfaceDistribution, type CrossSurfaceEligibility, type CrossSurfaceEvidenceBreakdown, type CrossSurfaceIneligibilityReason, type CrossSurfaceInteractionAwareSelection, type CrossSurfaceInteractionEffect, type CrossSurfaceInteractionPath, type CrossSurfaceInteractionReport, type CrossSurfaceInteractionTask, type CrossSurfaceNaiveStackSelection, type CrossSurfacePairCompatibility, type CrossSurfacePairEvidence, type CrossSurfacePairIncompatibilityReason, type CrossSurfacePairwiseEntry, type CrossSurfaceRankedSingle, type CrossSurfaceRelativeCost, type CrossSurfaceSelectionPolicy, type CrossSurfaceSelections, type CrossSurfaceTaskRow, type DefaultProductionGateCheck, type DefaultProductionGateOptions, type DefaultProductionRewardHackingOptions, type DimensionRegression, type DiscriminationScore, type DispatchContext, type DispatchFn, type EmitLoopProvenanceArgs, type EmitLoopProvenanceResult, type EvalFixture, type EvalFixtureFile, type EvalFixtureLoadOptions, type EvalFixtureRunPlan, type EvalFixtureScenario, type EvalFixtureValidationMode, type EvidenceVector, type ExternalOptimizationExample, type ExternalTextEvaluationResponse, type ExternalTextOptimizationMethodConfig, type ExternalTextOptimizerContext, type ExternalTextOptimizerResult, type FailureModeRecallJudgeOptions, FileSearchLedger, FsLabeledScenarioStore, type FsLabeledScenarioStoreOptions, type Gate, type GateCheckStatus, type GateContext, type GateContribution, type GateDecision, type GateResult, type GenerationCandidate, type GenerationRecord, type GepaAdaptiveEngineRun, type GepaEngineOptions, type GepaEngineRun, type GepaOptimizationMethodConfig, type GepaOptimizationRecipe, type GepaRunnerCommand, type GitWorktreeAdapterOptions, type HeldOutGateOptions, type HeldoutSignificance, type HeldoutSignificanceOptions, type JudgeAggregate, type JudgeConfig, type JudgeDimension, type JudgeScore, type LabelTrust, type LabeledScenarioRecord, type LabeledScenarioSampleArgs, type LabeledScenarioSource, type LabeledScenarioStore, LabeledScenarioStoreError, type LabeledScenarioWrite, type LlmJudgeDimension, type LlmJudgeOptions, type LoadEvalFixtureScenariosOptions, type LoopProvenanceArgsFromResult, type LoopProvenanceBackend, type LoopProvenanceCandidate, type LoopProvenanceEvidence, type LoopProvenanceOptimizationMethod, type LoopProvenanceRecord, type MutableSurface, type NeutralizationGateOptions, type ObjectiveSource, type OpenAICompatibleOptimizerModel, type OpenAutoPrOptions, type OpenAutoPrResult, type OpenSearchLedgerOptions, type OptimizationMethod, type OptimizationMethodComparison, type OptimizationMethodInput, type OptimizationMethodPairwise, type OptimizationMethodProvenance, type OptimizationMethodResult, type OptimizationMethodRunOptions, type OptimizationMethodScore, type OptimizationPackageSource, type OptimizationProposer, type OptimizationTokenUsage, type OptimizerConfig, type OptimizerModelBudget, type PairedHoldout, type ParetoParent, type ParetoSignificanceGateOptions, type PendingCostCallView, type PlanCampaignRunOptions, type PlanEvalFixtureRunOptions, type PlaybackContext, type PlaybackDriver, type PlaybackStep, type PowerPreflight, type PowerPreflightOptions, type PremeasuredOptimizationBaseline, type ProfileDispatchFn, ProfileMatrixError, type ProfileSummary, type PromotionObjective, type PromotionPolicy, type ProposalTrackContext, type ProposeContext, type ProposedCandidate, type RedactionStatus, type ReferenceEquivalenceJudgeOptions, type ReferenceEquivalenceScenario, type RolloutArgumentDiff, type RolloutArgumentDiffOptions, type RolloutCall, type RunCampaignOptions, type RunEvalOptions, type RunImprovementLoopOptions, type RunImprovementLoopResult, type RunOptimizationOptions, type RunOptimizationResult, type RunProfileMatrixOptions, type RunProfileMatrixResult, SEARCH_LEDGER_SCHEMA, type Scenario, type ScenarioAggregate, type ScenarioRollup, type ScenarioSignal, type ScoreboardRenderOptions, type ScoreboardRow, type ScoreboardSummary, type ScoredRollout, type ScoredSurfaceOutcome, type SearchAccountingAudit, type SearchArtifactRef, type SearchAttemptAccounting, type SearchCandidateDecidedEvent, type SearchCandidateLineage, type SearchCandidateRegisteredEvent, type SearchCandidateSlot, type SearchCandidateSlotClosedEvent, type SearchCandidateSurface, type SearchCompletedEvent, type SearchCostAccounting, type SearchFailureReason, type SearchLedger, type SearchLedgerAppendResult, SearchLedgerConflictError, type SearchLedgerEntry, SearchLedgerError, type SearchLedgerEvent, type SearchLedgerHash, SearchLedgerIntegrityError, type SearchLedgerReplay, type SearchModelIdentity, type SearchOperationKind, type SearchOperationRecordedEvent, type SearchPlan, type SearchPlannedEvent, type SearchPlannedOperation, type SearchPlannedTask, type SearchSourceRef, type SearchSurfaceEffect, type SearchSurfaceEvidence, type SearchSurfaceKind, type SearchTaskAttemptedEvent, type SearchTaskOutcome, type SearchTokenAccounting, type SequentialDecideFn, type SequentialDecideOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SessionScript, type SingleRunLock, type SingleRunLockOptions, type SkillOptOptimizationMethodConfig, type SkillOptRunnerCommand, type SkillOptTrainerConfig, type SurfaceProposer, type TraceSpan, type TransientFailureOptions, type UngroundedLiteralReport, type UserStory, type UserStoryVerdict, type Worktree, type WorktreeAdapter, WorktreeAdapterError, acquireSingleRunLock, analyzeCrossSurfaceInteractions, assertCampaignDesign, assertCampaignSplitIdentity, assertCodeSurfaceIdentity, assertComponentSurface, buildAnalystSurfaceDispatch, buildEvidenceVector, buildLoopProvenanceRecord, campaignBreakdown, campaignMeanComposite, campaignMeasurementDigest, campaignScenarioIdentity, campaignSplitDigest, campaignSplitDigestFromIdentities, canonicalDigest, classifyUngroundedLiterals, codeSurfaceIdentityMaterial, compareOptimizationMethods, compareRankKeys, componentSurfaceIdentityMaterial, composeGate, costFromLedgerSummary, createReferenceEquivalenceJudge, createRunCostLedger, defaultProductionGate, detectScale, dimensionRegressions, discoverEvalFixtures, emitLoopProvenance, externalTextOptimizationMethod, failureModeRecallJudge, fsCampaignStorage, gepaOptimizationMethod, gitWorktreeAdapter, heldOutGate, heldoutSignificance, inMemoryCampaignStorage, isProposedCandidate, isTransientTransportFailure, labelTrustRank, llmJudge, loadEvalFixture, loadEvalFixtureScenarios, loopProvenanceArgsFromResult, loopProvenanceSpans, makePlaybackDispatch, neutralizationGate, neutralizeText, openAutoPr, openSearchLedger, optimizationTokenUsageFromSummary, pairHoldout, paretoPolicy, paretoSignificanceGate, planCampaignRun, planEvalFixtureRun, powerPreflight, provenanceRecordPath, provenanceSpansPath, renderScoreboardMarkdown, renderSurfaceDiff, resolveRunDir, resolveWorktreePath, rolloutArgumentDiff, runCampaign, runEval, runImprovementLoop, runOptimization, runProfileMatrix, scoreDiscrimination, scoreUserStory, scoreboardSummary, selectDiscriminative, sequentialDecide, sequentialPairedGate, skillOptOptimizationMethod, surfaceContentHash, surfaceHash, tangleTracesRoot, userStoryScoreboard, validateSearchLedgerEvent, verifyCodeSurface, verifyLoopProvenanceRecord };