@tangle-network/agent-eval 0.126.7 → 0.128.0

package/dist/rl.d.ts

@@ -233,7 +233,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
@@ -254,6 +255,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. */
@@ -267,11 +275,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';
@@ -317,8 +320,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,
@@ -329,11 +332,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
@@ -397,42 +400,36 @@ 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
-     *  `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. */
+    /** Canonical task-failure class drawn from the shared
+     *  `FAILURE_CLASSES` taxonomy. Producers set it only from task-result
+     *  evidence. Execution errors belong in
+     *  `outcome.raw.execution_error_count`. */
     failureClass?: FailureClass;
-    /** Free-form domain-specific 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. */
+    /** Free-form task-failure detail scoped under a non-success
+     *  `failureClass`. It is invalid without that class. */
     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
@@ -442,6 +439,23 @@ interface RunRecord {
      */
     agentProfile?: AgentProfileCell;
 }
+/**
+ * Canonical task-result classification.
+ *
+ * A producer may omit classification, record explicit success, or attach
+ * domain-specific detail to a non-success class. Detail can never stand alone.
+ * Execution errors belong in `outcome.raw.execution_error_count`.
+ */
+type RunTaskFailure = {
+    failureClass?: undefined;
+    failureMode?: undefined;
+} | {
+    failureClass: 'success';
+    failureMode?: undefined;
+} | {
+    failureClass: Exclude<FailureClass, 'success'>;
+    failureMode?: string;
+};
 
 /**
  * Adaptive curriculum / active scenario selection.
@@ -959,9 +973,7 @@ declare function injectIrrelevantClause<S extends {
  *      per scenario but biggest score gap per pair. Useful for early
  *      bootstrapping when you have few variants.
  *
- * The output `PreferenceTriple` is *agent-eval-canonical* but trivially
- * mappable to TRL's `DPODataset` shape (`prompt`, `chosen`, `rejected`)
- * via the `toTRLFormat` helper.
+ * Resolve `PreferenceTriple` text with `toDpoRows` from `./exporters`.
  */
 
 type PreferenceStrategy = 'paired-by-scenario-and-seed' | 'paired-by-scenario' | 'top-vs-bottom';
@@ -1000,7 +1012,7 @@ interface PreferenceTriple {
         rejectedModel: string;
     };
 }
-interface ExtractPreferencesOptions {
+interface ExtractPreferencesOptions extends TrainingRunSelectionOptions {
     strategy?: PreferenceStrategy;
     /**
      * Minimum score gap required to admit a pair. Pairs below this are
@@ -1008,8 +1020,8 @@ interface ExtractPreferencesOptions {
      */
     minMargin?: number;
     /**
-     * Optional split tag filter — restrict to runs from one split. Default
-     * `'holdout'` (the canonical "real" signal).
+     * Optional split tag filter. Without one, only search is included.
+     * Holdout requires `allowHeldOutTrainingData: true`; dev is evaluation-only.
      */
     splitTag?: RunRecord['splitTag'];
     /**
@@ -1040,19 +1052,9 @@ interface PreferenceExtractionReport {
  *   1. Run a campaign producing 5–10 variants × 50–200 scenarios × 3 seeds
  *   2. Call this with `strategy: 'paired-by-scenario-and-seed'` and a
  *      verifiable-reward extractor as `rewardOf`
- *   3. Pass `report.pairs` to `toTRLFormat` and pipe to your DPO trainer
+ *   3. Pass `report.pairs` to `toDpoRows` with prompt/completion resolvers
  */
 declare function extractPreferences(runs: RunRecord[], opts?: ExtractPreferencesOptions): PreferenceExtractionReport;
-/**
- * TRL-compatible export. TRL's `DPODataset` is `{ prompt, chosen, rejected }`
- * but the prompt isn't stored on the RunRecord — only its hash. The caller
- * passes a `promptOf(promptHash)` lookup that the TRL trainer can use.
- */
-declare function toTRLFormat(triples: PreferenceTriple[], promptOf: (hash: string) => string): Array<{
-    prompt: string;
-    chosen: string;
-    rejected: string;
-}>;
 /**
  * Anthropic finetuning JSONL export — `{ system, user, assistant_chosen, assistant_rejected }`
  * shape. Same caveat as TRL: prompt + outputs are content the caller has
@@ -1290,7 +1292,13 @@ interface DpoExportRow {
 declare function toDpoRows(triples: PreferenceTriple[], lookups: DpoLookups): Promise<DpoExportRow[]>;
 /** Serialize DPO rows as JSONL. One line per row. */
 declare function toDpoJsonl(rows: DpoExportRow[]): string;
-interface GrpoLookups {
+interface TrainingRunSelectionOptions {
+    /** Include held-out evaluation data in training output. Default false. */
+    allowHeldOutTrainingData?: boolean;
+    /** Require quality to be strictly greater than this value. Default 0. */
+    minimumQualityExclusive?: number;
+}
+interface GrpoLookups extends TrainingRunSelectionOptions {
     promptOf: (runId: string) => string | Promise<string>;
     completionOf: (runId: string) => string | Promise<string>;
     /** Optional: derive a custom reward from the run. Defaults to score. */
@@ -1305,16 +1313,17 @@ interface GrpoExportRow {
     meta?: Record<string, unknown>;
 }
 /**
- * Convert RunRecord[] grouped by `(scenarioId)` into GRPO offline rows —
- * one row per scenario, with one completion per run on that scenario.
+ * Convert RunRecord[] grouped by canonical `(scenarioId, promptHash)` identity
+ * into GRPO offline rows.
  *
  * GRPO (Shao et al. 2024 / DeepSeek-R1) trains on relative advantages
  * within a group of completions for the same prompt; this is the
- * canonical input format.
+ * canonical input format. A scenario containing multiple prompt hashes, or a
+ * prompt hash that resolves to different text, is rejected rather than mixed.
  */
 declare function toGrpoRows(runs: RunRecord[], lookups: GrpoLookups): Promise<GrpoExportRow[]>;
 declare function toGrpoJsonl(rows: GrpoExportRow[]): string;
-interface SftLookups {
+interface SftLookups extends TrainingRunSelectionOptions {
     promptOf: (runId: string) => string | Promise<string>;
     completionOf: (runId: string) => string | Promise<string>;
     /** Optional system message. Default omits. */
@@ -1331,9 +1340,8 @@ interface SftExportRow {
 }
 /**
  * Convert RunRecord[] into Hugging Face / OpenAI / Anthropic-style
- * conversational SFT rows. By default every record becomes one row;
- * pass `include` to filter (e.g., keep only `score >= 0.8` for
- * rejection-sampling SFT).
+ * conversational SFT rows. By default, only completed, positive-quality
+ * search runs are eligible. Pass `include` for additional filtering.
  */
 declare function toSftRows(runs: RunRecord[], lookups: SftLookups): Promise<SftExportRow[]>;
 declare function toSftJsonl(rows: SftExportRow[]): string;
@@ -1372,6 +1380,7 @@ interface StepRewardJsonlRow {
     weight: number;
 }
 declare function stepRewardsToJsonl(stepRewards: StepReward[]): string;
+declare function isTrainingRunEligible(run: RunRecord, quality: number | null | undefined, options?: TrainingRunSelectionOptions): quality is number;
 
 /**
  * RL dataset packaging + datasheet — the publishable, sellable bundle.
@@ -1393,7 +1402,9 @@ declare function stepRewardsToJsonl(stepRewards: StepReward[]): string;
  */
 
 type RewardKind = 'deterministic' | 'probabilistic' | 'mixed';
-type DatasetFormat = 'grpo' | 'sft' | 'dpo';
+declare const DATASET_FORMATS: readonly ["grpo", "sft", "dpo"];
+type DatasetFormat = (typeof DATASET_FORMATS)[number];
+declare function validateDatasetFormats(value: unknown): DatasetFormat[];
 /** Caller-declared context — the qualitative half of the datasheet that can't
  *  be computed from records. */
 interface RlDatasetConfig {
@@ -1416,7 +1427,7 @@ interface RlDatasetConfig {
     limitations: string;
     /** ISO timestamp — passed in (the substrate forbids Date.now()). */
     createdAtIso: string;
-    /** Default: ['grpo', 'sft']. */
+    /** Default: ['sft']. GRPO must be requested for multi-completion groups. */
     formats?: DatasetFormat[];
     /** Quality gates already run, recorded on the card for the buyer. */
     qualityGates?: {
@@ -1427,14 +1438,16 @@ interface RlDatasetConfig {
 }
 interface RewardStats {
     n: number;
-    mean: number;
-    median: number;
-    min: number;
-    max: number;
-    std: number;
+    mean: number | null;
+    median: number | null;
+    min: number | null;
+    max: number | null;
+    std: number | null;
 }
 interface RlDatasetStats {
     records: number;
+    /** Records carrying an explicit task-quality score. */
+    scoredRecords: number;
     /** Record count per split — a publishable dataset must declare its holdout. */
     splits: Record<RunSplitTag, number>;
     reward: RewardStats;
@@ -1470,7 +1483,7 @@ declare function buildRlDataset(records: RunRecord[], lookups: GrpoLookups & Sft
     triples: PreferenceTriple[];
     lookups: DpoLookups;
 }): Promise<RlDatasetBundle>;
-/** Render the "Datasheet for Datasets" card — the artifact a buyer reads. */
+/** Render the "Datasheet for Datasets" card that a buyer reads. */
 declare function datasheetToMarkdown(m: RlDatasetManifest): string;
 
 /**
@@ -1515,8 +1528,10 @@ declare function readCorpus(corpusPath: string): CorpusRecord[];
 interface HarvestOptions {
     /** Keep only records scoring >= this (rejection-sampling for SFT). */
     minScore?: number;
-    /** Keep only these splits (e.g. ['holdout'] for an eval-only dataset). */
+    /** Keep only these source splits. Held-out rows still require the explicit override below. */
     splits?: RunRecord['splitTag'][];
+    /** Permit held-out rows in training files. Default false. */
+    allowHeldOutTrainingData?: boolean;
 }
 /**
  * Harvest the accumulated corpus into a publishable RL dataset bundle. Reads
@@ -1851,35 +1866,39 @@ interface RubricPredictiveValidityReport {
  *     specific promotion path (still useful for replay-style evals).
  */
 
-type HeldOutGateRejectionCode = 'few_runs' | 'negative_delta' | 'overfit_gap' | 'cost_ceiling';
+type HeldOutGateRejectionCode = 'few_runs' | 'missing_split_scores' | 'missing_cost' | 'negative_delta' | 'overfit_gap' | 'cost_ceiling';
 interface GateEvidence {
     /** Number of paired (candidate, baseline) holdout observations used. */
     productiveRuns: number;
-    /** Median of (candidate − baseline) paired holdout deltas. */
-    medianPairedDelta: number;
-    /** Bootstrap CI on the median paired holdout delta. */
+    /** Candidate holdout rows with no baseline row at the same work identity. */
+    unpairedCandidateRuns: number;
+    /** Baseline holdout rows with no candidate row at the same work identity. */
+    unpairedBaselineRuns: number;
+    /** Median of paired holdout deltas, or null when there are no pairs. */
+    medianPairedDelta: number | null;
+    /** Bootstrap CI on the median paired holdout delta, if computed. */
     pairedCI: {
         low: number;
         high: number;
-    };
-    /** Wilcoxon signed-rank p-value on the paired holdout deltas. */
-    pairedPValue: number;
-    /** Mean candidate score on the search split (NaN if none). */
-    searchScore: number;
-    /** Mean candidate score on the holdout split (NaN if none). */
-    holdoutScore: number;
-    /** Candidate (search − holdout) gap. */
-    overfitGap: number;
-    /** Baseline (search − holdout) gap. */
-    baselineOverfitGap: number;
+    } | null;
+    /** Wilcoxon signed-rank p-value, if computed. */
+    pairedPValue: number | null;
+    /** Mean candidate score on the search split, or null when absent. */
+    searchScore: number | null;
+    /** Mean candidate score on the holdout split, or null when absent. */
+    holdoutScore: number | null;
+    /** Candidate (search − holdout) gap, or null when either side is absent. */
+    overfitGap: number | null;
+    /** Baseline (search − holdout) gap, or null when either side is absent. */
+    baselineOverfitGap: number | null;
     /** Median per-task USD cost across the candidate's runs. Recorded
      *  even when no `costPerTaskCeiling` is configured so downstream
      *  dashboards (intelligence.tangle.tools) can render \$/task per
      *  generation regardless of gating policy. */
-    medianCandidateCost: number;
+    medianCandidateCost: number | null;
     /** Median per-task USD cost across the baseline runs, for
      *  symmetric reporting. */
-    medianBaselineCost: number;
+    medianBaselineCost: number | null;
 }
 interface GateDecision$1 {
     /** Final promote/no-promote verdict. */
@@ -2142,6 +2161,8 @@ interface Finding {
 interface LayerResult {
     layer: string;
     status: LayerStatus;
+    /** Origin of an `error` or `timeout`. Defaults to `execution`. */
+    errorSource?: 'execution' | 'judge';
     /** 0..1 score, optional — layers that don't produce a numeric score omit. */
     score?: number;
     durationMs: number;
@@ -2160,22 +2181,29 @@ interface LayerResult {
     /** Any rich per-layer detail — rendered as-is by consumers that know the layer. */
     detail?: Record<string, unknown>;
 }
-/** Extends the substrate verdict spine: `valid` = `allPass` and `score` =
- *  `blendedScore` — derived where the report is aggregated, so spine
- *  consumers (drivers, gates) read this report without an adapter. */
+/** Extends the substrate verdict spine: `valid` = `allPass`; `score` is the
+ * complete task score or 0 when the configured scoring panel was incomplete. */
 interface VerificationReport extends DefaultVerdict {
     layers: LayerResult[];
     passCount: number;
     failCount: number;
     skippedCount: number;
     errorCount: number;
-    /** True iff at least one scored layer ran AND every scored layer passed. */
+    /** True iff the configured scoring panel completed and every layer passed. */
     allPass: boolean;
     /**
-     * Weighted mean of `score` across contributing layers. 0 when no layers
-     * contributed. See {@link Layer.failContributesToScore} for fail semantics.
+     * Diagnostic weighted mean across contributing layers. This may represent a
+     * partial panel. It is 0 when no layer contributed.
      */
     blendedScore: number;
+    /**
+     * Complete task-quality measurement.
+     * Present when at least one layer produced a valid score, every other layer
+     * completed successfully or contributed an explicit scored failure, and no
+     * result is missing because of a failure, skip, error, or timeout.
+     * Use this field, not `blendedScore`, when creating task labels.
+     */
+    taskScore?: number;
     durationMs: number;
     startedAt: string;
     finishedAt: string;
@@ -2354,14 +2382,17 @@ interface RewardHackingFinding {
 }
 interface RewardHackingReport {
     findings: RewardHackingFinding[];
+    /** Signals with enough usable observations to produce a finding. */
+    evaluatedSignals: RewardHackingSignal[];
     /**
-     * Composite verdict. `'clean'` if every signal severity < 0.3;
-     * `'suspect'` if at least one ≥ 0.3 but none ≥ 0.6; `'gaming'` if any ≥ 0.6.
+     * Composite verdict. `'insufficient_evidence'` when fewer than four scored
+     * runs exist; otherwise `'clean'` if every signal severity < 0.3,
+     * `'suspect'` if at least one ≥ 0.3 but none ≥ 0.6, and `'gaming'` if any ≥ 0.6.
      */
-    verdict: 'clean' | 'suspect' | 'gaming';
+    verdict: 'insufficient_evidence' | 'clean' | 'suspect' | 'gaming';
     /** Rationale for the verdict, ready to paste into an audit log. */
     rationale: string[];
-    /** Number of paired (proxy, truth) data points the report saw. */
+    /** Number of runs with a usable proxy reward. */
     n: number;
 }
 interface DetectRewardHackingInput {
@@ -2531,6 +2562,7 @@ type ProviderRedactor = (event: RawProviderEvent) => RawProviderEvent;
  * 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
@@ -2751,10 +2783,16 @@ interface SummaryTableRow {
     mean: number;
     ciLow: number;
     ciHigh: number;
-    /** BH-adjusted q-value vs comparator. NaN if no comparator. */
-    qValue: number;
-    /** Cohen's d vs comparator. NaN if no comparator. */
-    cohensD: number;
+    /** BH-adjusted q-value vs comparator, or null when unavailable. */
+    qValue: number | null;
+    /** Paired Cohen's dz vs comparator, or null when the paired variance is zero. */
+    cohensD: number | null;
+    /** Matched observations used for paired comparison, or null on the comparator row. */
+    pairedN: number | null;
+    /** Candidate observations without a comparator match. */
+    unpairedCandidateN: number | null;
+    /** Comparator observations without a candidate match. */
+    unpairedComparatorN: number | null;
 }
 interface SummaryTable {
     rows: SummaryTableRow[];
@@ -2776,7 +2814,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';
@@ -2802,12 +2840,16 @@ interface GainDistributionFigureSpec {
     split: 'search' | 'holdout';
     /** Number of pairs used. */
     n: number;
+    /** Candidate rows without a comparator match. */
+    unpairedCandidateN: number;
+    /** Comparator rows without a candidate match. */
+    unpairedComparatorN: number;
     bins: GainDistributionBin[];
-    median: number;
+    median: number | null;
     ci: {
         low: number;
         high: number;
-    };
+    } | null;
 }
 type ResearchReportDecision = 'promote' | 'hold' | 'reject' | 'equivalent' | 'needs_more_data';
 interface ResearchReportOptions {
@@ -2880,8 +2922,8 @@ interface ResearchReportCandidate {
     mean: number;
     ciLow: number;
     ciHigh: number;
-    qValue: number;
-    cohensD: number;
+    qValue: number | null;
+    cohensD: number | null;
     meanDeltaVsComparator: number | null;
     pairedN: number;
     medianGain: number | null;
@@ -2891,10 +2933,9 @@ interface ResearchReportCandidate {
         high: number;
     } | null;
     /**
-     * Bayesian-bootstrap-style posterior summaries on the paired delta. Computed
-     * from the same resamples that produce the gain CI; interpretable as
-     * "fraction of resamples in which the candidate beats the comparator on
-     * matched pairs."
+     * Bayesian-bootstrap posterior summaries on the paired mean delta.
+     * Dirichlet(1, ..., 1) weights represent uncertainty over the empirical
+     * distribution of matched deltas.
      */
     prGreaterThanZero: number | null;
     prInRope: number | null;
@@ -3204,13 +3245,15 @@ interface CampaignRunContext<V> {
      */
     llmOpts: LlmClientOptions;
 }
-interface CampaignRunOutcome {
+interface CampaignRunOutcomeFields {
     /** Did the run pass? Mirrors `RunOutcome.pass` semantics. */
     pass: boolean;
     /** Score for the run on its split. Maps to `searchScore` or `holdoutScore`. */
     score: number;
-    /** Mandatory cost in USD. Use 0 + raw.cost_unknown=1 only if truly unknown. */
-    costUsd: number;
+    /** Cost in USD, or null when the runner could not capture it. */
+    costUsd: number | null;
+    /** Source of the cost amount. */
+    costProvenance: RunCostProvenance;
     tokenUsage: RunTokenUsage;
     /** Snapshot model id (e.g. `claude-sonnet-4-6@2025-04-15`). */
     model: string;
@@ -3220,12 +3263,6 @@ interface CampaignRunOutcome {
     configHash: string;
     /** Optional extra numeric metrics to land in `outcome.raw`. */
     raw?: Record<string, number>;
-    /** Canonical cross-agent failure class from the shared `FAILURE_CLASSES`
-     *  taxonomy. Propagated to `RunRecord.failureClass` so campaign runs
-     *  aggregate failures in the same vocabulary as every other producer. */
-    failureClass?: FailureClass;
-    /** Optional free-form failure detail, scoped under `failureClass`. */
-    failureMode?: string;
     /** Optional judge metadata when a judge was used. */
     judgeMetadata?: RunJudgeMetadata;
     /**
@@ -3241,6 +3278,8 @@ interface CampaignRunOutcome {
      */
     agentProfile?: AgentProfileCell | AgentProfileCellInput;
 }
+/** Campaign result with the same task-failure invariant as `RunRecord`. */
+type CampaignRunOutcome = CampaignRunOutcomeFields & RunTaskFailure;
 type CampaignRunner<V> = (ctx: CampaignRunContext<V>) => Promise<CampaignRunOutcome>;
 type CampaignIntegrityPolicy = 'throw' | 'mark_failed' | 'log';
 interface EvalCampaignOptions<V> {
@@ -3569,14 +3608,17 @@ interface JudgeScore {
 }
 /** 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 GateResult {
     decision: GateDecision;
     reasons: string[];
-    contributingGates: Array<{
-        name: string;
-        passed: boolean;
-        detail: unknown;
-    }>;
+    contributingGates: GateContribution[];
     delta?: number;
 }
 /** Token usage accumulated for a cell. Aliased to the canonical `RunTokenUsage`
@@ -3609,6 +3651,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 {
@@ -3633,8 +3679,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. */
@@ -3644,13 +3692,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<{
@@ -3691,10 +3738,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. */
@@ -3749,29 +3804,30 @@ interface AdapterContext {
     configHash: string;
     /** Default split tag. Default `'search'`. */
     splitTag?: RunSplitTag;
-    /** Default cost in USD when the source doesn't record one. Default `0`. */
+    /** Estimated cost in USD when the source doesn't record one. */
     defaultCostUsd?: number;
 }
 /**
- * Convert a `CampaignResult` into canonical `RunRecord[]` — one record per
- * scored cell. The cell's mean judge composite becomes the split score; every
- * judge dimension is carried through to `outcome.raw`. A cell that errored
- * becomes a record with `failureMode: 'cell_error'` (kept, not dropped — an
- * unscored cell is signal). `candidateId` identifies the measured surface
- * (defaults to the campaign manifest hash).
+ * Convert a `CampaignResult` into canonical `RunRecord[]`, one per cell.
+ * Successful judged cells carry their mean judge composite and dimensions.
+ * Errored or unjudged cells remain unlabeled while retaining explicit terminal
+ * outcome, execution-error count, token usage, cost, and failure detail.
+ * `candidateId` identifies the measured surface and defaults to the campaign
+ * manifest hash.
  */
 declare function campaignToRunRecords(campaign: CampaignResult, ctx: AdapterContext & {
     candidateId?: string;
 }): RunRecord[];
 /**
  * Convert a `MultiLayerVerifier` `VerificationReport` into a `RunRecord`.
- * `outcome.searchScore` (or `holdoutScore`) is `report.blendedScore`;
- * `outcome.raw` carries every layer's score + a pass indicator; `failureMode`
- * is the first failing layer's reason.
+ * A split score is emitted only when `report.taskScore` proves the configured
+ * scoring panel completed. Partial scores remain in `outcome.raw` for
+ * diagnosis. Layer errors and timeouts become judge or execution telemetry;
+ * only a scored `fail` layer may produce task-failure detail.
  */
 declare function verificationReportToRunRecord(report: VerificationReport, ctx: AdapterContext & {
     candidateId: string;
-    scenarioId?: string;
+    scenarioId: string;
 }, opts?: {
     runId?: string;
 }): RunRecord;
@@ -4057,4 +4113,4 @@ interface BuildPairwiseFromCampaignInput {
 }
 declare function buildPairwiseFromCampaign(input: BuildPairwiseFromCampaignInput): PairwiseOutcome[];
 
-export { ABSENT_CATEGORY, type AdaptationCurve, type AdaptationPoint, type AdaptationRunner, type AdapterContext, type AdversarialMutation, type BehaviorFeatures, type BradleyTerryFit, type BradleyTerryRating, type BuildPairwiseFromCampaignInput, type CellObservation, type CompareCurvesResult, type ComputeBestOfNOptions, type ComputeBestOfNResult, type ComputeCurve, type ComputeCurveBudget, type ComputeCurvePoint, type ContaminationProbeInput, type ContaminationProbeOptions, type ContaminationProbeReport, type CorpusAppendResult, type CorpusRecord, type CurriculumAllocation, DEFAULT_MIN_N_PER_FEATURE, DEFAULT_QUANTILE_BUCKETS, type DatasetFormat, type DeploymentOutcome, type DetectRewardHackingInput, type DpoExportRow, type DpoLookups, type EasyModeOptions, type EasyModeReport, type EloOptions, type ExtractPreferencesOptions, type ExtractStepRewardsOptions, type FeatureDivergence, type FeatureShift, type FidelityReport, type FidelityVerdict, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, type GrpoExportRow, type GrpoLookups, type HarvestOptions, InMemoryOutcomeStore, type OffPolicyContributionCounts, type OffPolicyEstimate, type OffPolicyOptions, type OffPolicyTrajectory, type OutcomeStore, type PairwiseOutcome, type ParetoPointInput, PredictiveValidityResearcher, type PredictiveValidityResearcherOptions, type PreferenceExtractionReport, type PreferenceStrategy, type PreferenceTriple, type PrmExportRow, type PrmLookups, type PrmTrainingTriple, REPRESENTATIVE_MIN_FIDELITY, type RLCampaignResult, type RewardHackingFinding, type RewardHackingReport, type RewardHackingSignal, type RewardKind, type RewardStats, type RlDatasetBundle, type RlDatasetConfig, type RlDatasetManifest, type RlDatasetStats, type RunAdaptationCurveOptions, type RunComputeCurveOptions, type RunRLCampaignOptions, type RunwiseStepSummary, type ScenarioPerturbation, type ScenarioPerturbationKind, type SelfConsistencyOptions, type SelfConsistencyResult, type SftExportRow, type SftLookups, type SimFidelityOptions, type StepReward, type StepRewardJsonlRow, type StepScorer, type ThompsonCurriculumOptions, type VarianceCurriculumOptions, type VerifiableReward, type VerifiableRewardExtractionOptions, type VerifiableRewardSource, appendToCorpus, applyEloUpdate, bestOfN, bucketLabel, buildDatasetFromCorpus, buildPairwiseFromCampaign, buildRlDataset, campaignToRunRecords, compareAdaptationCurves, datasheetToMarkdown, defaultBehaviorFeatures, detectRewardHacking, doublyRobust, easyModeCheck, extractPreferences, extractStepRewards, extractVerifiableReward, extractVerifiableRewardsFromRecords, filterDeterministicallyRewarded, firstPassK, fitBradleyTerry, injectIrrelevantClause, inverseProbabilityWeighting, jsDivergence, observationsFromRunRecords, offPolicyEstimateAll, paretoFrontier, prmTrainingPairs, quantileEdges, readCorpus, renameVariables, runAdaptationCurve, runComputeCurve, runContaminationProbe, runEvalCampaign, runRLCampaign, runwiseStepRewardSummary, selfConsistency, selfNormalizedImportanceWeighting, shuffleOrder, simFidelityReport, stepRewardsToJsonl, thompsonCurriculum, toAnthropicFormat, toDpoJsonl, toDpoRows, toGrpoJsonl, toGrpoRows, toPrmJsonl, toPrmRows, toSftJsonl, toSftRows, toTRLFormat, varianceBasedCurriculum, verificationReportToRunRecord };
+export { ABSENT_CATEGORY, type AdaptationCurve, type AdaptationPoint, type AdaptationRunner, type AdapterContext, type AdversarialMutation, type BehaviorFeatures, type BradleyTerryFit, type BradleyTerryRating, type BuildPairwiseFromCampaignInput, type CellObservation, type CompareCurvesResult, type ComputeBestOfNOptions, type ComputeBestOfNResult, type ComputeCurve, type ComputeCurveBudget, type ComputeCurvePoint, type ContaminationProbeInput, type ContaminationProbeOptions, type ContaminationProbeReport, type CorpusAppendResult, type CorpusRecord, type CurriculumAllocation, DEFAULT_MIN_N_PER_FEATURE, DEFAULT_QUANTILE_BUCKETS, type DatasetFormat, type DeploymentOutcome, type DetectRewardHackingInput, type DpoExportRow, type DpoLookups, type EasyModeOptions, type EasyModeReport, type EloOptions, type ExtractPreferencesOptions, type ExtractStepRewardsOptions, type FeatureDivergence, type FeatureShift, type FidelityReport, type FidelityVerdict, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, type GrpoExportRow, type GrpoLookups, type HarvestOptions, InMemoryOutcomeStore, type OffPolicyContributionCounts, type OffPolicyEstimate, type OffPolicyOptions, type OffPolicyTrajectory, type OutcomeStore, type PairwiseOutcome, type ParetoPointInput, PredictiveValidityResearcher, type PredictiveValidityResearcherOptions, type PreferenceExtractionReport, type PreferenceStrategy, type PreferenceTriple, type PrmExportRow, type PrmLookups, type PrmTrainingTriple, REPRESENTATIVE_MIN_FIDELITY, type RLCampaignResult, type RewardHackingFinding, type RewardHackingReport, type RewardHackingSignal, type RewardKind, type RewardStats, type RlDatasetBundle, type RlDatasetConfig, type RlDatasetManifest, type RlDatasetStats, type RunAdaptationCurveOptions, type RunComputeCurveOptions, type RunRLCampaignOptions, type RunwiseStepSummary, type ScenarioPerturbation, type ScenarioPerturbationKind, type SelfConsistencyOptions, type SelfConsistencyResult, type SftExportRow, type SftLookups, type SimFidelityOptions, type StepReward, type StepRewardJsonlRow, type StepScorer, type ThompsonCurriculumOptions, type TrainingRunSelectionOptions, type VarianceCurriculumOptions, type VerifiableReward, type VerifiableRewardExtractionOptions, type VerifiableRewardSource, appendToCorpus, applyEloUpdate, bestOfN, bucketLabel, buildDatasetFromCorpus, buildPairwiseFromCampaign, buildRlDataset, campaignToRunRecords, compareAdaptationCurves, datasheetToMarkdown, defaultBehaviorFeatures, detectRewardHacking, doublyRobust, easyModeCheck, extractPreferences, extractStepRewards, extractVerifiableReward, extractVerifiableRewardsFromRecords, filterDeterministicallyRewarded, firstPassK, fitBradleyTerry, injectIrrelevantClause, inverseProbabilityWeighting, isTrainingRunEligible, jsDivergence, observationsFromRunRecords, offPolicyEstimateAll, paretoFrontier, prmTrainingPairs, quantileEdges, readCorpus, renameVariables, runAdaptationCurve, runComputeCurve, runContaminationProbe, runEvalCampaign, runRLCampaign, runwiseStepRewardSummary, selfConsistency, selfNormalizedImportanceWeighting, shuffleOrder, simFidelityReport, stepRewardsToJsonl, thompsonCurriculum, toAnthropicFormat, toDpoJsonl, toDpoRows, toGrpoJsonl, toGrpoRows, toPrmJsonl, toPrmRows, toSftJsonl, toSftRows, validateDatasetFormats, varianceBasedCurriculum, verificationReportToRunRecord };