@tangle-network/agent-eval 0.128.2 → 0.129.0

package/dist/rl.d.ts

@@ -939,7 +939,369 @@ declare function injectIrrelevantClause<S extends {
 }>(clause: string, position?: 'prefix' | 'suffix'): ScenarioPerturbation<S>;
 
 /**
- * Preference dataset extraction — bridge from `RunRecord[]` to RL training.
+ * `tangle.rollout.v1` — THE canonical rollout serialization, owned by
+ * agent-eval. One JSONL line per agent invocation (a solo eval run, a
+ * supervisor episode, a worker session, a proposer shot, a judge call, an
+ * analyst pass), labeled with its task/split coordinates and a single
+ * scalar reward, carrying the FULL message transcript inline.
+ *
+ * This schema is the reconciliation of two prior producers:
+ *   - agent-eval's RunRecord-joined rollout rows (PR #410): identity,
+ *     provenance hashes, the realness gate travelling into the reward,
+ *     trace-derived steps.
+ *   - the bench rollout-ledger (agent-runtime PR #591): the wire shape —
+ *     role, task.split/rep, parent_rollout_id, policy provenance, capture
+ *     provenance, inline canonical chat-with-tools messages.
+ * Where the two conflicted, RunRecord-derived semantics won; the wire
+ * field names follow the ledger (snake_case). See `docs/rollout.md` for
+ * the field-by-field decision table.
+ *
+ * Messages are inlined — never referenced — because every harness store a
+ * rollout can be recovered from is mutable or garbage-collected. A line
+ * must stay a complete training/eval example on its own.
+ *
+ * `outcome.reward` is THE single scalar (null = no verdict exists — a
+ * labeled gap, never 0). `outcome.realness_gated` is the anti-Goodhart
+ * flag: a gated line must never export as a positive training example.
+ *
+ * That last sentence is enforced here, by `validateRolloutLine`, not merely
+ * documented. Validating `reward` and `realness_gated` independently — each a
+ * well-typed field, their COMBINATION unchecked — is what let a line claiming
+ * `{reward: 0.95, realness_gated: true}` validate clean and walk into every
+ * training export. The relationship between the two IS the invariant, so it is
+ * checked where every other structural claim about a line is checked.
+ *
+ * The invariant is about the OUTCOME, not about one field of it. Zeroing
+ * `reward` while `outcome.metrics` still carried the per-layer scores that
+ * reward was computed from exported the gamed signal anyway, in the dict the
+ * verifiers format reads as its per-rubric scores. So `gateGamedOutcome`
+ * transforms the whole outcome once, at `assertMinted` — the funnel every
+ * minted line passes — and the reward-bearing components are relocated to
+ * `provenance.gated_evidence`, which no exporter projects.
+ *
+ * WHICH checks each door applies is not decided in this file. `./gate-checks`
+ * owns the canonical list and the total per-entry-point policy; the three doors
+ * below (`validateRolloutLine`, `assertRewardGate`, `assertMinted`) each call
+ * `gateErrors` with their declared policy, so a check added to that list applies
+ * here without anyone editing this file, and a check deliberately skipped has to
+ * name itself there.
+ */
+declare const ROLLOUT_SCHEMA = "tangle.rollout.v1";
+/** `agent` = a solo evaluation run (no multi-agent topology). */
+type RolloutRole = 'agent' | 'supervisor' | 'worker' | 'proposer' | 'judge' | 'analyst';
+/** Split vocabulary follows `RunRecord.splitTag`, extended with `canary`. */
+type RolloutSplit = 'search' | 'dev' | 'holdout' | 'canary';
+/** 'mint' = joined live from RunRecord + trace by `mintRolloutRows`. */
+type RolloutCapture = 'mint' | 'settle-time' | 'backfill';
+type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
+interface ChatToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        /** JSON-encoded argument object, exactly as the model emitted it. */
+        arguments: string;
+    };
+}
+interface ChatMessage {
+    role: ChatRole;
+    content: string | null;
+    /** Reasoning/thinking channel where the harness captured it (full fidelity). */
+    reasoning_content?: string;
+    tool_calls?: ChatToolCall[];
+    /** Required on role:"tool" — the ChatToolCall this result answers. */
+    tool_call_id?: string;
+    name?: string;
+    /**
+     * Harbor ATIF `is_copied_context` (RFC 0001 rule 7): this turn was COPIED IN
+     * from another trajectory's context, not produced by the agent on this line.
+     * The RFC makes excluding it from SFT a MUST, and `toSftRows` does — training
+     * on it teaches the model to author text it never authored, and credits this
+     * run for another one's work. Absent = false (authored here).
+     */
+    is_copied_context?: boolean;
+}
+interface ToolDef {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+/**
+ * Compact trace-span projection (llm/tool step) carried alongside the
+ * conversation when the line was minted from a trace. Optional: lines
+ * recovered from harness stores have no span structure.
+ */
+interface RolloutStep {
+    kind: string;
+    name: string;
+    /** llm: last-message summary · tool: stringified args. Scrubbed. */
+    input?: string;
+    /** llm: output text · tool: stringified result. Scrubbed. */
+    output?: string;
+    status?: 'ok' | 'error';
+    durationMs?: number;
+    /**
+     * LLM inferences this span represents. 0 = deterministic dispatch with no
+     * model call — distinct from absent, which means the producer did not track it.
+     */
+    llm_call_count?: number;
+    /** Exact prompt tokenization. Removes the ambiguity of re-tokenizing text at train time. */
+    prompt_token_ids?: number[];
+    /** Exact completion tokenization; aligns index-wise with `logprobs`. */
+    completion_token_ids?: number[];
+    /**
+     * Per-completion-token log probabilities under the sampling policy. Required
+     * for off-policy correction (importance weighting) when the rollout was
+     * generated by a policy other than the one being trained.
+     */
+    logprobs?: number[];
+}
+interface RolloutTask {
+    /** Benchmark/suite id (e.g. "swe-bench-verified") or the experiment id. */
+    suite: string;
+    instance_id: string;
+    split: RolloutSplit;
+    /** Sampling seed the campaign pinned; null = not recorded. */
+    seed: number | null;
+    /** Replicate index (0-based). */
+    rep: number;
+}
+interface RolloutPolicy {
+    /** Harness that drove the invocation (e.g. "opencode", "claude", "pi-loops"). */
+    harness: string | null;
+    harness_version: string | null;
+    model: string | null;
+    provider: string | null;
+    /** Commit of the agent profile / candidate under evaluation. */
+    profile_commit: string | null;
+    /** sha256 of the effective prompt (post-steering), when recorded. */
+    prompt_hash?: string | null;
+    /** sha256 of the effective run config, when recorded. */
+    config_hash?: string | null;
+    /** Canonical agent-profile cell identity, when the run carries one. */
+    agent_profile_cell_id?: string | null;
+    /** Sampling params (temperature, top_p, max_tokens…); null = not recorded. */
+    sampling: Record<string, unknown> | null;
+}
+interface RolloutOutcome {
+    /**
+     * THE single scalar training signal — the official verdict.
+     * null = no verdict exists for this invocation (a labeled gap, never 0).
+     */
+    reward: number | null;
+    /** Where the reward came from (judge id; "/inherited" = parent episode's). */
+    reward_source: string | null;
+    /** Raw judge verdict record, verbatim. */
+    verdict: unknown;
+    /** Everything that is NOT the scalar reward. */
+    metrics: Record<string, unknown>;
+    is_completed: boolean;
+    is_truncated: boolean;
+    error: string | null;
+    /**
+     * Anti-Goodhart flag from `RunRecord.outcome.realness.gated`: the run faked
+     * its success signal. `true` requires `reward` to be 0 or null — the
+     * validator rejects the line otherwise — and the line never qualifies for
+     * SFT. Required on the wire: a line that does not state the flag does not
+     * validate, so no producer can dodge the gate by omitting it.
+     *
+     * `true` ALSO requires `metrics` to be empty and `verdict` to be null: the
+     * numbers the reward was computed from are relocated to
+     * `provenance.gated_evidence` by `gateGamedOutcome`. See that function for
+     * why zeroing the scalar alone was not enough.
+     */
+    realness_gated: boolean;
+    /**
+     * Whether an authenticity SCREEN ever RAN on this reward — a different claim
+     * from `realness_gated`, which is the screen's VERDICT.
+     *
+     * `realness_gated: false` reads as "we looked and nothing fired". A producer
+     * with no screen at all was emitting exactly that, so a never-screened reward
+     * was indistinguishable on the wire from a screened-clean one, and the whole
+     * anti-Goodhart apparatus silently treated the first as the second. The two
+     * claims are now separable:
+     *
+     *   - `true`   — a screen ran; `realness_gated` is its verdict.
+     *   - `false`  — the producer declares it HAS no screen (`unscreenedRewardFields`).
+     *                `assertMinted` REFUSES such a line when its reward is above
+     *                zero: an unscreened positive reward is precisely the signal
+     *                the gate exists to qualify, and nothing has qualified it.
+     *   - absent   — not stated. Pre-unification ledgers land here, as does a
+     *                `RunRecord` carrying no `outcome.realness` at all. Absent is
+     *                read as "unknown", never as `false` (which would refuse most
+     *                of the existing corpus) and never as `true`.
+     */
+    realness_screened?: boolean;
+}
+interface RolloutCostBlock {
+    usd: number | null;
+    tokens_in: number | null;
+    tokens_out: number | null;
+    tokens_reasoning: number | null;
+    cache_read: number | null;
+    cache_write: number | null;
+    wall_s: number | null;
+    /**
+     * Total LLM inferences across the invocation (ATIF `llm_call_count`,
+     * aggregated). Optional and additive: absent = not tracked, never 0.
+     */
+    llm_call_count?: number | null;
+}
+interface RolloutArtifacts {
+    patch_path: string | null;
+    run_dir: string | null;
+    /** Source-of-truth transcript pointer (session id / jsonl path) for audit. */
+    transcript_ref: string | null;
+}
+/**
+ * The reward-bearing half of a GATED line's outcome, moved off `outcome` and
+ * parked here verbatim. Diagnostics, never training input — see
+ * `gateGamedOutcome`.
+ */
+interface GatedEvidence {
+    /** `outcome.metrics` exactly as the producer measured it. */
+    metrics?: Record<string, unknown>;
+    /** `outcome.verdict` verbatim — the judge record that claimed the success. */
+    verdict?: unknown;
+    /**
+     * The per-step fields `tangle.rollout.v1` does not declare, parked here when
+     * the gate projected `steps[]` down to the schema's own key set.
+     *
+     * A per-step reward is training signal exactly like the scalar, and `steps`
+     * rides through `toRewardRows` verbatim — so a gated line was shipping its
+     * step-level credit assignment at full value beside a `reward` of 0.
+     */
+    steps?: unknown;
+}
+interface RolloutProvenance {
+    captured_at: string;
+    capture: RolloutCapture;
+    /**
+     * Why this line is incomplete. Required when `messages` is empty (the
+     * transcript could not be recovered); also set by interchange importers to
+     * name a MISSING LABEL — an imported trajectory carries no verdict, so
+     * `outcome.reward` is null and this says why.
+     */
+    gap?: string;
+    /**
+     * Present only on a realness-gated line: the outcome fields the gate
+     * relocated, kept so an auditor can still see WHY the run was gated and what
+     * it claimed. Deliberately OUTSIDE `outcome`, because every training exporter
+     * reads `outcome` and none reads `provenance`.
+     */
+    gated_evidence?: GatedEvidence;
+}
+interface RolloutLine {
+    schema: typeof ROLLOUT_SCHEMA;
+    rollout_id: string;
+    /** Spawning invocation within the same episode (worker → supervisor). */
+    parent_rollout_id: string | null;
+    run_id: string;
+    /** Logical experiment grouping from `RunRecord.experimentId`; null = not recorded. */
+    experiment_id: string | null;
+    /** Stable candidate identity from `RunRecord.candidateId`; null = not recorded. */
+    candidate_id: string | null;
+    /** Improvement-loop generation (-1 = baseline); null = not an improvement loop. */
+    generation: number | null;
+    /** Improvement-loop candidate index (-1 = baseline); null = not an improvement loop. */
+    candidate_index: number | null;
+    role: RolloutRole;
+    task: RolloutTask;
+    policy: RolloutPolicy;
+    /** Full transcript, inline. [] = gap line (see provenance.gap). */
+    messages: ChatMessage[];
+    tool_defs: ToolDef[];
+    /** Trace-span projections, when minted from a trace. */
+    steps?: RolloutStep[];
+    outcome: RolloutOutcome;
+    cost: RolloutCostBlock;
+    artifacts: RolloutArtifacts;
+    provenance: RolloutProvenance;
+}
+/**
+ * Phantom property. `declare const` means it exists only in the type system:
+ * nothing is written at runtime, so a branded line still serializes to exactly
+ * the same JSON as a plain one.
+ */
+declare const MINTED_ROLLOUT: unique symbol;
+/**
+ * A minted outcome states the gate verdict — it is not allowed to stay silent —
+ * and, when that verdict is `true`, carries nothing else the reward was derived
+ * from (`gateGamedOutcome` has run).
+ */
+interface MintedRolloutOutcome extends RolloutOutcome {
+    realness_gated: boolean;
+}
+/**
+ * A `RolloutLine` whose reward has been checked against the anti-Goodhart
+ * invariant. The type every training-data exporter takes.
+ *
+ * Why a brand and not just the interface: `RolloutLine` is structural, so any
+ * hand-built object literal of the right shape IS one — which is how a line
+ * declaring `{reward: 0.95, realness_gated: true}` reached the exporters
+ * despite them "only accepting a minted line". The phantom symbol makes the
+ * type nominal: it cannot be produced by writing an object literal, only by
+ * `mintRolloutRows` (which applies the gate), `readRolloutLedger` (which
+ * validates every line off disk), or an explicit, greppable `assertMinted`.
+ *
+ * Belt and braces on purpose. The brand closes first-party call sites at
+ * COMPILE time; `validateRolloutLine` closes data arriving at RUNTIME (ledger
+ * files, foreign imports, JSON from another process) where types are absent.
+ * Neither alone is enough.
+ *
+ * Assignable to `RolloutLine` in one direction only: readers, analysis, and
+ * the ledger writer keep taking the plain type.
+ */
+type MintedRolloutLine = Omit<RolloutLine, 'outcome'> & {
+    readonly [MINTED_ROLLOUT]: true;
+    outcome: MintedRolloutOutcome;
+};
+
+/**
+ * Shared checks for trainer exports over canonical minted rollout lines.
+ *
+ * Exporters accept only `MintedRolloutLine[]`. Callers convert run records with
+ * `mintRolloutRows` before deriving preferences or trainer files.
+ */
+
+/**
+ * The minted lines behind a LINE-LESS training artifact.
+ *
+ * `PreferenceTriple`, `PrmTrainingTriple` and `StepReward` all carry a bare
+ * reward number plus run ids, and nothing that says whether those runs faked
+ * their success. An exporter over them therefore has no way, from its input
+ * alone, to learn that its chosen side is a run the gate flagged — it will
+ * happily emit the gaming trajectory as the preferred one. Supplying the lines
+ * is what gives it eyes.
+ */
+interface RolloutLineContext {
+    /**
+     * Minted lines for every INVOCATION the artifacts reference.
+     *
+     * Not "one line per run": `tangle.rollout.v1` models many invocations per
+     * `run_id` — that is what `rollout_id` and `parent_rollout_id` are for, and
+     * `supervisorRunRolloutLines` emits a supervisor node plus one per worker, all
+     * sharing a single `run_id`. A reference is resolved against `rollout_id`
+     * first and falls back to `run_id` only when that run has exactly one
+     * invocation; see `resolveInvocation`.
+     */
+    lines: MintedRolloutLine[];
+}
+/** How one exporter names itself and its context type in the failure messages. */
+interface LineContextRequirement {
+    /** Exporter label, e.g. `'DPO export'`. */
+    exporter: string;
+    /** The context type the caller must pass, e.g. `'DpoLineContext'`. */
+    contextType: string;
+    /** Why this exporter cannot see the gate without lines. One sentence. */
+    because: string;
+}
+
+/**
+ * Preference dataset extraction from canonical minted rollout lines.
  *
  * Production RLHF / DPO / KTO / SimPO pipelines need preference triples:
  * `(prompt, chosen, rejected)`. The campaign artifact already contains the
@@ -973,7 +1335,16 @@ declare function injectIrrelevantClause<S extends {
  *      per scenario but biggest score gap per pair. Useful for early
  *      bootstrapping when you have few variants.
  *
- * Resolve `PreferenceTriple` text with `toDpoRows` from `./exporters`.
+ * The output `PreferenceTriple` is *agent-eval-canonical* but trivially
+ * mappable to TRL's `DPODataset` shape (`prompt`, `chosen`, `rejected`)
+ * via the `toTRLFormat` helper, which resolves real prompt/completion text
+ * through the same lookups `toDpoRows` takes (`./exporters` carries the
+ * richer row with margin + metadata).
+ *
+ * Input discipline: the function accepts only `MintedRolloutLine[]`, whose
+ * reward and authenticity fields have already been validated. `search` is the
+ * default split; held-out pairing requires an explicit opt-in, while `dev` and
+ * `canary` remain evaluation-only.
  */
 
 type PreferenceStrategy = 'paired-by-scenario-and-seed' | 'paired-by-scenario' | 'top-vs-bottom';
@@ -1000,7 +1371,7 @@ interface PreferenceTriple {
     /** Tie-breaker — when multiple seeds match this scenario, the one used. */
     seed?: number;
     /**
-     * Free-form metadata propagated from the run records — e.g. original
+     * Free-form metadata propagated from the rollout lines, such as original
      * prompt-hash, model, etc. Lets the RL trainer reconstruct the prompt.
      */
     meta: {
@@ -1012,7 +1383,7 @@ interface PreferenceTriple {
         rejectedModel: string;
     };
 }
-interface ExtractPreferencesOptions extends TrainingRunSelectionOptions {
+interface ExtractPreferencesOptions {
     strategy?: PreferenceStrategy;
     /**
      * Minimum score gap required to admit a pair. Pairs below this are
@@ -1020,16 +1391,13 @@ interface ExtractPreferencesOptions extends TrainingRunSelectionOptions {
      */
     minMargin?: number;
     /**
-     * Optional split tag filter. Without one, only search is included.
-     * Holdout requires `allowHeldOutTrainingData: true`; dev is evaluation-only.
+     * Optional split filter. Without one, only search is included.
+     * Holdout requires `allowHeldOutTrainingData: true`; dev and canary are
+     * evaluation-only.
      */
-    splitTag?: RunRecord['splitTag'];
-    /**
-     * Optional reward extractor that overrides `outcome.holdoutScore` /
-     * `outcome.searchScore`. Use to drive preferences off a verifiable
-     * reward instead of the headline score.
-     */
-    rewardOf?: (run: RunRecord) => number | null;
+    split?: RolloutSplit;
+    /** Named opt-in required before held-out lines may be paired. */
+    allowHeldOutTrainingData?: boolean;
 }
 interface PreferenceExtractionReport {
     pairs: PreferenceTriple[];
@@ -1041,26 +1409,64 @@ interface PreferenceExtractionReport {
     cellsSingleton: number;
     /** Strategy used. */
     strategy: PreferenceStrategy;
+    /**
+     * Lines dropped before pairing because they carry no `candidate_id`. A
+     * preference is a statement about two candidates, so a line that names none
+     * cannot be paired.
+     */
+    linesWithoutCandidateId: number;
 }
 /**
- * Convert `RunRecord[]` to preference triples for RL training.
+ * Convert rollout lines to preference triples for RL training.
  *
  * Returns a structured report so callers can see how much data was
  * dropped and why (low-margin pairs, singleton cells). For production
  * pipelines, you usually want to:
  *
  *   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 `toDpoRows` with prompt/completion resolvers
+ *   2. Mint the runs with `mintRolloutRows` and call this with
+ *      `strategy: 'paired-by-scenario-and-seed'`
+ *   3. Pass `report.pairs` to `toDpoRows` (or `toTRLFormat`) with
+ *      prompt/completion resolvers and pipe to your DPO trainer
+ *
+ * The gate is what makes a preference dataset safe: ordered on an ungated
+ * score, a gamed run with an inflated number becomes the `chosen` side and DPO
+ * is trained to prefer the gaming trajectory over its honest sibling. A gated
+ * line arrives here already scored 0, so it sinks to `rejected`.
+ */
+declare function extractPreferences(lines: MintedRolloutLine[], opts?: ExtractPreferencesOptions): PreferenceExtractionReport;
+/**
+ * TRL-compatible export. TRL's `DPODataset` is `{ prompt, chosen, rejected }`
+ * where `chosen`/`rejected` are completion TEXT — a trainer fed prompt hashes
+ * would optimize the policy toward emitting hex digests. Neither the prompt
+ * nor the completions live on the triple (it carries only run ids and hashes),
+ * so the caller supplies the same `promptOf`/`completionOf` lookups `toDpoRows`
+ * takes, keyed by run id, and this function resolves real text.
+ *
+ * The chosen and rejected sides of a valid pair share one prompt; resolving
+ * both and comparing catches lookup bugs (a stale map keyed by the wrong id)
+ * before they ship a row whose prompt does not match its rejected completion.
+ *
+ * `context` is REQUIRED: this is the third exporter over the identical
+ * line-less input class, and the round that hardened `toPrmRows` while leaving
+ * `toDpoRows` open is why every one of them now takes the same argument and
+ * runs the same admission rule.
  */
-declare function extractPreferences(runs: RunRecord[], opts?: ExtractPreferencesOptions): PreferenceExtractionReport;
+declare function toTRLFormat(triples: PreferenceTriple[], lookups: DpoLookups, context: RolloutLineContext): Promise<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
  * to map back from the run record / raw event log.
+ *
+ * `context` is REQUIRED — see `toTRLFormat`. The emitted `margin` is a number
+ * derived from the two runs' rewards, so this row is training signal even
+ * though it ships no completion text.
  */
-declare function toAnthropicFormat(triples: PreferenceTriple[]): Array<{
+declare function toAnthropicFormat(triples: PreferenceTriple[], context: RolloutLineContext): Array<{
     scenarioId: string;
     chosenRunId: string;
     rejectedRunId: string;
@@ -1239,7 +1645,7 @@ declare function prmTrainingPairs(stepRewardsByRun: Map<string, StepReward[]>, o
 /**
  * Trainer-format exporters.
  *
- * agent-eval produces canonical artifacts (`RunRecord[]`, `PreferenceTriple[]`,
+ * agent-eval produces canonical artifacts (`MintedRolloutLine[]`, `PreferenceTriple[]`,
  * `StepReward[]`, `PrmTrainingTriple[]`). RL training pipelines consume
  * different shapes — Hugging Face TRL, Prime Intellect's prime-rl, OpenAI
  * fine-tuning, Anthropic finetuning, OpenRLHF, verl. Each has its own
@@ -1259,7 +1665,7 @@ declare function prmTrainingPairs(stepRewardsByRun: Map<string, StepReward[]>, o
  *     Consumed by Lightman-style PRM trainers and prime-rl's PRM mode.
  *
  * Why ship this in agent-eval rather than a separate adapter package: the
- * canonical artifacts (`RunRecord[]`, `PreferenceTriple[]`, etc.) are
+ * canonical artifacts (`MintedRolloutLine[]`, `PreferenceTriple[]`, etc.) are
  * agent-eval's contract; without first-party exporters consumers reverse-
  * engineer the mapping every release. The exporters codify it.
  *
@@ -1267,6 +1673,10 @@ declare function prmTrainingPairs(stepRewardsByRun: Map<string, StepReward[]>, o
  * artifact (specifically: prompt + completion text, since the package
  * stores only their hashes by design — full text is the consumer's
  * trace store / raw event log).
+ *
+ * Every exporter that produces a training row accepts canonical minted rollout
+ * lines. Convert run records once with `mintRolloutRows`; downstream transforms
+ * then share one reward, split, and authenticity contract.
  */
 
 interface DpoLookups {
@@ -1284,25 +1694,43 @@ interface DpoExportRow {
     /** Free-form metadata for downstream filtering / sharding. */
     meta?: Record<string, unknown>;
 }
+/** The minted lines for the runs a `PreferenceTriple` names on each side. */
+type DpoLineContext = RolloutLineContext;
+declare const DPO_CONTEXT_REQUIREMENT: LineContextRequirement;
 /**
  * Convert preference triples to TRL-compatible DPO rows. The shape
  * `{prompt, chosen, rejected}` is the canonical HuggingFace DPODataset
  * entry; every major DPO trainer accepts it.
+ *
+ * `context` is REQUIRED, and for the same reason it is required on the sibling
+ * `toPrmRows`: a triple is a line-less artifact. It names two run ids and a
+ * margin, and nothing on it says whether either run was flagged as gamed —
+ * so a two-argument call applied NO gate at all and emitted the row verbatim,
+ * reachable straight through the published bundle builder
+ * (`buildRlDataset(lines, lookups, {formats:['dpo']}, {triples, lookups})`).
+ * Triples whose chosen or rejected side is realness-gated are dropped; a triple
+ * naming a run with no supplied line is refused. See `admitUngatedByInvocation` for
+ * why dropping, not zeroing, is the right disposition for a preference pair.
  */
-declare function toDpoRows(triples: PreferenceTriple[], lookups: DpoLookups): Promise<DpoExportRow[]>;
+declare function toDpoRows(triples: PreferenceTriple[], lookups: DpoLookups, context: DpoLineContext): Promise<DpoExportRow[]>;
 /** Serialize DPO rows as JSONL. One line per row. */
 declare function toDpoJsonl(rows: DpoExportRow[]): string;
-interface TrainingRunSelectionOptions {
+interface TrainingLineSelectionOptions {
     /** 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;
+    /**
+     * Explicit split selection, replacing the default trainable-split rule.
+     * Use this only when producing a deliberately named non-training slice.
+     */
+    splitFilter?: RolloutSplit[];
 }
-interface GrpoLookups extends TrainingRunSelectionOptions {
+interface GrpoLookups extends Pick<TrainingLineSelectionOptions, 'allowHeldOutTrainingData' | 'splitFilter'> {
+    /** Resolve the prompt text for a rollout, keyed by `line.run_id`. */
     promptOf: (runId: string) => string | Promise<string>;
+    /** Resolve the assistant completion text for a rollout. */
     completionOf: (runId: string) => string | Promise<string>;
-    /** Optional: derive a custom reward from the run. Defaults to score. */
-    rewardOf?: (run: RunRecord) => number | null;
 }
 interface GrpoExportRow {
     prompt: string;
@@ -1313,23 +1741,35 @@ interface GrpoExportRow {
     meta?: Record<string, unknown>;
 }
 /**
- * Convert RunRecord[] grouped by canonical `(scenarioId, promptHash)` identity
- * into GRPO offline rows.
+ * Convert rollout lines grouped by `task.instance_id` into GRPO offline rows —
+ * one row per scenario, with one completion per rollout on that scenario.
+ * A scenario with fewer than two rewarded completions emits no row because a
+ * group of one has no relative baseline.
  *
  * 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. A scenario containing multiple prompt hashes, or a
- * prompt hash that resolves to different text, is rejected rather than mixed.
+ * canonical input format. That relative baseline is exactly why the gate has
+ * to hold here: one gamed sibling exporting at full reward shifts the advantage
+ * of every honest run beside it.
+ *
+ * On the line path a realness-gated line stays in its group at reward 0 rather
+ * than being dropped. 0 is the honest label for a faked success and is usable
+ * signal; removing the line would also move the group's baseline, just in the
+ * other direction. (SFT differs — see `toSftRows`.)
  */
-declare function toGrpoRows(runs: RunRecord[], lookups: GrpoLookups): Promise<GrpoExportRow[]>;
+declare function toGrpoRows(lines: MintedRolloutLine[], lookups: GrpoLookups): Promise<GrpoExportRow[]>;
 declare function toGrpoJsonl(rows: GrpoExportRow[]): string;
-interface SftLookups extends TrainingRunSelectionOptions {
+interface SftLookups extends TrainingLineSelectionOptions {
+    /** Resolve the prompt text for a rollout, keyed by `line.run_id`. */
     promptOf: (runId: string) => string | Promise<string>;
+    /** Resolve the assistant completion text for a rollout. */
     completionOf: (runId: string) => string | Promise<string>;
     /** Optional system message. Default omits. */
-    systemOf?: (run: RunRecord) => string | null | undefined;
-    /** Filter — return false to skip the run (e.g., low score, failed cases). */
-    include?: (run: RunRecord) => boolean;
+    systemOf?: (line: MintedRolloutLine) => string | null | undefined;
+    /** Extra filter on top of the realness gate (e.g., low score, failed cases). */
+    include?: (line: MintedRolloutLine) => boolean;
+    /** Include held-out lines under the default split rule. Default false. */
+    allowHeldOutTrainingData?: boolean;
 }
 interface SftExportRow {
     messages: Array<{
@@ -1339,11 +1779,24 @@ interface SftExportRow {
     meta?: Record<string, unknown>;
 }
 /**
- * Convert RunRecord[] into Hugging Face / OpenAI / Anthropic-style
- * conversational SFT rows. By default, only completed, positive-quality
- * search runs are eligible. Pass `include` for additional filtering.
+ * Convert rollout lines into Hugging Face / OpenAI / Anthropic-style
+ * conversational SFT rows. By default every qualifying line becomes one row;
+ * pass `include` to filter further (e.g., keep only `reward >= 0.8` for
+ * rejection-sampling SFT).
+ *
+ * Realness-gated lines are dropped outright, not zeroed. SFT is imitation
+ * learning: unlike GRPO, where a 0 reward teaches "this trajectory was bad",
+ * every row here is a target to copy, so a gamed trajectory must not be in the
+ * file at all. Mirrors the waist filter in `rollout/exporters.toSftRows`.
+ *
+ * The exporter is fail-closed on the split, same rule as
+ * `rollout/exporters.toSftRows` (`isSplitEligible`): `search` ships by
+ * default, held-out lines need `allowHeldOutTrainingData: true`, `dev` and
+ * `canary` never pass the default rule. A non-training bundle that wants an
+ * explicit slice (e.g. a holdout-only eval bundle) names it with
+ * `splitFilter: ['holdout']` — explicit selection replaces the default rule.
  */
-declare function toSftRows(runs: RunRecord[], lookups: SftLookups): Promise<SftExportRow[]>;
+declare function toSftRows(lines: MintedRolloutLine[], lookups: SftLookups): Promise<SftExportRow[]>;
 declare function toSftJsonl(rows: SftExportRow[]): string;
 interface PrmLookups {
     /** Resolve the prompt text for a run. */
@@ -1365,11 +1818,48 @@ interface PrmExportRow {
     marginScore: number;
     meta?: Record<string, unknown>;
 }
+interface PrmLineContext extends RolloutLineContext {
+    /**
+     * The `maxSteps` cap the lines were minted with, if any.
+     *
+     * `mintRolloutRows` drops the MIDDLE of an over-long trajectory and leaves no
+     * marker on the line, so a capped trajectory is indistinguishable from a
+     * short one. Declaring the cap lets this exporter refuse any line sitting at
+     * it — a process-reward model trained on a trajectory with a hole in it
+     * learns credit assignment that never happened.
+     */
+    mintedWithMaxSteps?: number;
+}
 /**
  * Convert PRM training triples to JSONL rows. Caller's `stepTextOf`
  * callback resolves span text from the consumer's trace store.
+ *
+ * Every referenced run is checked against its minted line before any row is
+ * emitted, and the export FAILS LOUD on a trajectory that was never fully
+ * captured (see `assertPrmTrainableLine`). Triples whose chosen or rejected
+ * side is realness-gated are dropped instead: a capture defect is the caller's
+ * mint configuration and must be fixed, whereas a gamed run is exactly the
+ * condition the gate exists to filter.
+ *
+ * `context` is REQUIRED. A two-argument call used to be accepted and produced
+ * rows with no gate applied at all — a `PrmTrainingTriple` carries a bare
+ * `chosenReward` number and nothing that says which run it came from is honest,
+ * so with no lines this exporter has no way to learn that its chosen step is a
+ * step from a run that faked its success. It now throws: fail closed, because
+ * the alternative is a process-reward model taught to prefer the gaming move at
+ * the exact step the gaming happened.
+ */
+declare function toPrmRows(triples: PrmTrainingTriple[], lookups: PrmLookups, context: PrmLineContext): Promise<PrmExportRow[]>;
+/**
+ * Refuse to build a process-reward row from a trajectory we do not fully have.
+ *
+ * PRM training assigns credit step by step, so a missing or silently shortened
+ * step list is not degraded data — it is data about a trajectory that never
+ * existed. Every condition below throws rather than filters, because each one
+ * means the CALLER's capture or mint configuration is wrong.
  */
-declare function toPrmRows(triples: PrmTrainingTriple[], lookups: PrmLookups): Promise<PrmExportRow[]>;
+declare function assertPrmTrainableLine(line: MintedRolloutLine, mintedWithMaxSteps?: number): void;
+declare const PRM_CONTEXT_REQUIREMENT: LineContextRequirement;
 declare function toPrmJsonl(rows: PrmExportRow[]): string;
 interface StepRewardJsonlRow {
     runId: string;
@@ -1379,8 +1869,18 @@ interface StepRewardJsonlRow {
     determinism: 'deterministic' | 'probabilistic';
     weight: number;
 }
-declare function stepRewardsToJsonl(stepRewards: StepReward[]): string;
-declare function isTrainingRunEligible(run: RunRecord, quality: number | null | undefined, options?: TrainingRunSelectionOptions): quality is number;
+declare const STEP_REWARD_CONTEXT_REQUIREMENT: LineContextRequirement;
+/**
+ * Step-level reward rows as JSONL.
+ *
+ * `context` is REQUIRED for the same reason it is on `toDpoRows` and
+ * `toPrmRows`: this is a line-less input carrying a reward number. Steps
+ * belonging to a realness-gated run are dropped rather than zeroed — a
+ * per-step reward of 0 across a whole trajectory is a claim that every step was
+ * bad, which is a different (and false) statement from "this run's success was
+ * fabricated, so its step-level credit assignment is meaningless".
+ */
+declare function stepRewardsToJsonl(stepRewards: StepReward[], context: RolloutLineContext): string;
 
 /**
  * RL dataset packaging + datasheet — the publishable, sellable bundle.
@@ -1392,13 +1892,19 @@ declare function isTrainingRunEligible(run: RunRecord, quality: number | null |
  * reward was derived (deterministic verifiable vs probabilistic judge — the
  * credibility axis a buyer checks first), the split discipline, the reward
  * distribution, the quality gates, the license, and the intended/out-of-scope
- * uses. This module computes those facts from the `RunRecord[]` and renders a
+ * uses. This module computes those facts from `MintedRolloutLine[]` and renders a
  * "Datasheet for Datasets" (Gebru et al. 2018) card alongside the format files.
  *
  * It composes the existing `rl/exporters` — it does not reimplement any trainer
  * format. The renderers token-identity step (DeepSeek/Kimi/Qwen tokenization
  * with per-token loss masks) is a downstream Python stage that consumes the
  * `messages`/`completions` this bundle emits.
+ *
+ * Input discipline: the bundle is built from `MintedRolloutLine[]`. The datasheet's
+ * reward distribution ships INSIDE the published artifact, so it has to be
+ * derived from exactly the same gated number as the rows it describes —
+ * otherwise the provenance a buyer checks first is a lie. Taking the same
+ * gated input as the exporters is what guarantees that.
  */
 
 type RewardKind = 'deterministic' | 'probabilistic' | 'mixed';
@@ -1446,10 +1952,10 @@ interface RewardStats {
 }
 interface RlDatasetStats {
     records: number;
-    /** Records carrying an explicit task-quality score. */
+    /** Rollouts carrying an explicit task-quality score. */
     scoredRecords: number;
-    /** Record count per split — a publishable dataset must declare its holdout. */
-    splits: Record<RunSplitTag, number>;
+    /** Rollout count per split. */
+    splits: Record<RolloutSplit, number>;
     reward: RewardStats;
     /** Distinct snapshot-pinned models that produced the trajectories. */
     models: string[];
@@ -1461,6 +1967,12 @@ interface RlDatasetStats {
         output: number;
     };
     totalCostUsd: number;
+    /**
+     * Rollouts whose USD cost was never captured (`cost.usd === null`). When
+     * non-zero, `totalCostUsd` is a floor, not the bill — a published dataset
+     * must not present an unbilled run as a $0 one.
+     */
+    rolloutsWithoutCost: number;
 }
 interface RlDatasetManifest extends RlDatasetConfig {
     formats: DatasetFormat[];
@@ -1473,13 +1985,13 @@ interface RlDatasetBundle {
     files: Record<string, string>;
 }
 /**
- * Package graded `RunRecord[]` into a publishable RL dataset bundle: the
+ * Package graded rollout lines into a publishable RL dataset bundle: the
  * trainer-format JSONL files + a manifest + a datasheet. DPO requires
  * pre-extracted preference triples (pass `preferences`); GRPO/SFT derive from
- * the records directly via the supplied lookups. Throws on an empty corpus —
+ * the lines directly via the supplied lookups. Throws on an empty corpus —
  * an empty dataset must never be published.
  */
-declare function buildRlDataset(records: RunRecord[], lookups: GrpoLookups & SftLookups, config: RlDatasetConfig, preferences?: {
+declare function buildRlDataset(lines: MintedRolloutLine[], lookups: GrpoLookups & SftLookups, config: RlDatasetConfig, preferences?: {
     triples: PreferenceTriple[];
     lookups: DpoLookups;
 }): Promise<RlDatasetBundle>;
@@ -1539,6 +2051,12 @@ interface HarvestOptions {
  * missing either are excluded (a graded score with no trajectory can't train).
  * Optionally filters by score / split. Throws (via buildRlDataset) if nothing
  * survives — an empty dataset must never be published.
+ *
+ * `minScore` is applied to the GATED reward (`trainingScore`), so a gamed run
+ * cannot buy its way into the published bundle with its claimed score —
+ * `minScore` is exactly the door a reward-hacked run would otherwise clear for
+ * SFT. Unscored records are dropped before packaging: a missing label is not a
+ * zero, and it is not publishable either.
  */
 declare function buildDatasetFromCorpus(corpusPath: string, config: RlDatasetConfig, opts?: HarvestOptions): Promise<RlDatasetBundle>;
 
@@ -1611,20 +2129,12 @@ interface OffPolicyTrajectory {
      * values must come from a model cross-fitted or trained outside this row.
      */
     vHatTarget?: number | null;
-    /**
-     * @deprecated Use `qHatChosen` and `vHatTarget` together. When the new pair
-     * is absent, this scalar is used as both terms to preserve existing results.
-     * When the new pair is present, this field is ignored.
-     */
-    qHat?: number | null;
 }
 interface OffPolicyContributionCounts {
     /** Contributions using the contextual-bandit doubly-robust formula. */
     dr: number;
     /** Contributions using exact IPS because no reward-model estimate was supplied. */
     ipsFallback: number;
-    /** Contributions using the deprecated single-scalar formula. */
-    legacyScalar: number;
 }
 interface OffPolicyEstimate {
     /** Estimated value of the target policy. */
@@ -1683,9 +2193,8 @@ declare function selfNormalizedImportanceWeighting(trajectories: OffPolicyTrajec
  * default in production OPE pipelines.
  *
  * `qHatChosen` and `vHatTarget` must be supplied together. Rows with neither
- * use the exact IPS contribution. Deprecated `qHat` rows preserve the scalar
- * formula, and a complete new pair takes precedence when both forms exist.
- * `contributionCounts` makes the mix explicit in the result.
+ * use the exact IPS contribution. `contributionCounts` makes the mix explicit
+ * in the result.
  * Callers must cross-fit the Q-function or train it on independent rows;
  * fitting and evaluating Q on the same outcomes leaks the answer.
  */
@@ -1899,6 +2408,13 @@ interface GateEvidence {
     /** Median per-task USD cost across the baseline runs, for
      *  symmetric reporting. */
     medianBaselineCost: number | null;
+    /**
+     * Runs (candidate + baseline) dropped before pairing because the
+     * authenticity gate flagged them as gamed. Surfaced rather than silent: a
+     * promotion decision computed over a shrunken pool has to say by how much,
+     * and a nonzero count here is itself the finding.
+     */
+    realnessGatedRuns: number;
 }
 interface GateDecision$1 {
     /** Final promote/no-promote verdict. */
@@ -2268,12 +2784,34 @@ interface VerifiableReward {
      */
     components: Record<string, number>;
     /**
-     * @deprecated Read `components` for per-source reward values. Kept for
-     * published-API compatibility: single-source rewards carry the layer's
-     * diagnostics here (e.g. `{ tests_passed: 7 }`); composite rewards carry
-     * the same per-layer scores `components` now holds.
+     * The run carries `outcome.realness.gated` — the authenticity gate flagged
+     * its success signal as faked.
+     *
+     * With the gate applied (the default) `value` and every `components` entry
+     * are 0 on such a run; with `applyRealnessGate: false` the observed numbers
+     * come back untouched and this flag is the only marker that they are not to
+     * be trusted. Either way it distinguishes "measured a genuine failure" from
+     * "claimed a success we refuse to believe", which a bare 0 cannot.
      */
-    breakdown?: Record<string, number>;
+    realnessGated?: boolean;
+    /**
+     * Whether an authenticity screen COULD run on this reward at all — the same
+     * distinction `RolloutOutcome.realness_screened` draws, for the same reason.
+     *
+     * `false` on every reward from `extractVerifiableReward`, because a
+     * `VerificationReport` carries layer scores and nothing else: there is no
+     * `outcome.realness` to consult, so no gate has run, and `realnessGated`
+     * being absent there means "unknown", NOT "clean". Absent on the
+     * `RunRecord` path when the record itself carries no realness verdict.
+     *
+     * This matters most exactly where it is easiest to miss: a report whose
+     * deterministic layers all passed yields `determinism: 'deterministic'`,
+     * `confidence: 1` — the highest-credibility reward this module can emit —
+     * and a stubbed integration reporting green is precisely what a gamed run
+     * looks like. Consumers driving training off this shape must screen the run
+     * themselves; the flag is what tells them nobody has.
+     */
+    realnessScreened?: boolean;
 }
 interface VerifiableRewardExtractionOptions {
     /**
@@ -2300,6 +2838,18 @@ interface VerifiableRewardExtractionOptions {
      * doesn't report one. Default `0.7`.
      */
     judgeConfidenceFloor?: number;
+    /**
+     * Whether the anti-Goodhart realness gate applies. Default `true`, and the
+     * default is the one every training path must keep.
+     *
+     * Set `false` ONLY for detection and analysis. `rl/reward-hacking.ts` does,
+     * for the same reason it reads `observedScore` for its proxy: it measures the
+     * DIVERGENCE between the judge signal and the deterministic one, and a
+     * deterministic reward that another gate already forced to 0 manufactures
+     * exactly that divergence on exactly the gamed population. The detector would
+     * then be re-reporting a verdict it was supposed to reach independently.
+     */
+    applyRealnessGate?: boolean;
 }
 /**
  * Extract a `VerifiableReward` from a `VerificationReport`.
@@ -2308,6 +2858,11 @@ interface VerifiableRewardExtractionOptions {
  * schema → sandbox), fall back to the judge layer if `fallbackToJudge` is
  * true, return `null` if no signal qualifies. When multiple deterministic
  * layers contribute, return a `'composite'` source with a weighted blend.
+ *
+ * NO realness gate is applied and none can be: a `VerificationReport` carries
+ * layer scores and nothing about whether the run faked them — `realness` lives
+ * on the `RunRecord`. Use `extractVerifiableRewardsFromRecords` for anything
+ * that becomes training data; this signature is for scoring a report in hand.
  */
 declare function extractVerifiableReward(report: VerificationReport, opts?: VerifiableRewardExtractionOptions): VerifiableReward | null;
 /**
@@ -2321,12 +2876,30 @@ declare function extractVerifiableReward(report: VerificationReport, opts?: Veri
  * verifiable reward becomes a training datum, every record that doesn't
  * gets filtered out (or kept with `'probabilistic'` determinism for
  * separate downstream handling).
+ *
+ * The realness gate applies to EVERY channel here, and to the deterministic one
+ * MOST. It is tempting to reason that a decidable signal cannot be gamed, so
+ * the gate is redundant on it — that reasoning is backwards. `realness.gated`
+ * means the run's success signal was FAKED, and a test suite reporting green on
+ * a stubbed integration is precisely what that looks like: the deterministic
+ * layer is the thing that got faked. Exporting it ungated hands a trainer the
+ * highest-credibility reward the module can emit (`determinism: 'deterministic'`,
+ * `confidence: 1`) for the one population the gate exists to catch. Pass
+ * `applyRealnessGate: false` only to look at the ungated numbers for detection.
  */
 declare function extractVerifiableRewardsFromRecords(runs: RunRecord[], opts?: VerifiableRewardExtractionOptions): Array<{
     runId: string;
     reward: VerifiableReward | null;
 }>;
-/** Filter `RunRecord[]` to those with deterministic verifiable rewards. */
+/**
+ * Filter `RunRecord[]` to those with deterministic verifiable rewards.
+ *
+ * A realness-gated run is KEPT, at reward 0 with `realnessGated: true` — the
+ * same rule GRPO uses on a gated line. 0 is the honest label for a faked
+ * success and is usable signal, whereas dropping the run would move a group
+ * baseline without saying so. (SFT differs: there every row is a target to
+ * imitate, so a gated row is removed outright.)
+ */
 declare function filterDeterministicallyRewarded(runs: RunRecord[], opts?: VerifiableRewardExtractionOptions): Array<{
     run: RunRecord;
     reward: VerifiableReward;
@@ -2574,9 +3147,8 @@ type ProviderRedactor = (event: RawProviderEvent) => RawProviderEvent;
  *     { baseUrl: 'https://router.tangle.tools/v1', apiKey: process.env.KEY },
  *   )
  *
- * This is THE llm-calling seam for agent-eval primitives that need structured
- * output (semantic concept judge, reviewer directives, critic scores). Primitives
- * that need free-form text use `callLlm` and parse output themselves.
+ * `createChatClient` wraps this implementation for provider-neutral package
+ * entry points. Direct callers can use `callLlm` or `callLlmJson`.
  */
 
 type LlmThinkingMode = 'enabled' | 'disabled';
@@ -2654,8 +3226,8 @@ interface LlmClientOptions {
      * total attempts × `timeoutMs`.
      */
     deadlineMs?: number;
-    /** Total provider attempts. Legacy option name; default 3 (1 initial + 2 retries). */
-    maxRetries?: number;
+    /** Total provider attempts. Default 3. */
+    maximumAttempts?: number;
     /** Token rates used when the provider omits cost or package pricing does not cover the model. */
     customTokenPricing?: CustomTokenPricing;
     /**
@@ -3474,7 +4046,7 @@ interface InterimReleaseConfidence {
  *
  * Wires:
  *   1. `runEvalCampaign` for the matrix run (capture, integrity, hooks)
- *   2. `extractVerifiableReward` over each run, separating deterministic
+ *   2. `extractVerifiableRewardsFromRecords` over the runs, separating deterministic
  *      from probabilistic reward sources for the trainer
  *   3. `extractPreferences` to produce DPO/PPO/KTO triples
  *   4. `evaluateInterimReleaseConfidence` over paired deltas (anytime-valid)
@@ -3484,8 +4056,9 @@ interface InterimReleaseConfidence {
  *
  * The output `RLCampaignResult` is a single, audit-ready artifact: every
  * stage's output is in there. The consumer's downstream fits in a single
- * line: pass `result.preferences` to their DPO trainer, `result.grpoRows`
- * to GRPO, `result.runs` plus `result.rewardSignals` to a custom RL loop.
+ * line: pass `result.preferences.pairs` to a DPO trainer,
+ * `result.trainerRows.grpo` to GRPO, or `result.campaign.runs` plus
+ * `result.rewardSignals` to a custom RL loop.
  */
 
 interface RunRLCampaignOptions<V> extends EvalCampaignOptions<V> {
@@ -3512,7 +4085,7 @@ interface RunRLCampaignOptions<V> extends EvalCampaignOptions<V> {
         sft?: SftLookups;
     };
 }
-interface RLCampaignResult<V> {
+interface RLCampaignResult {
     campaign: EvalCampaignResult;
     /** Per-run verifiable reward (deterministic when available, probabilistic fallback otherwise). */
     rewardSignals: Array<{
@@ -3541,9 +4114,8 @@ interface RLCampaignResult<V> {
      * Convenience type-tag — consumers can branch on `result.kind`.
      */
     kind: 'agent-eval-rl-campaign';
-    unusedVariant?: V;
 }
-declare function runRLCampaign<V>(opts: RunRLCampaignOptions<V>): Promise<RLCampaignResult<V>>;
+declare function runRLCampaign<V>(opts: RunRLCampaignOptions<V>): Promise<RLCampaignResult>;
 
 /**
  * Pass A substrate types — `runCampaign` is the one primitive every
@@ -3582,7 +4154,7 @@ interface CampaignScenarioIdentity extends Pick<Scenario, 'id' | 'kind'> {
 /** The canonical judge verdict shape — one declaration, shared by campaign
  *  judges and the multishot judge runner (which re-exports this type).
  *
- *  Scale is PRODUCER-DEFINED: campaign convention is [0,1]; the legacy
+ *  Scale is PRODUCER-DEFINED: campaign convention is [0,1]; the
  *  multishot runner emits 0-10. Cross-scale comparison must go through
  *  `detectScale` (src/campaign/gates/statistical-heldout.ts, used by
  *  promotion-policy) — never renormalize a producer's values in place, as
@@ -3736,8 +4308,6 @@ interface CampaignAggregates {
     byScenario: Record<string, ScenarioAggregate>;
     /** Canonical campaign accounting, including worker and judge calls. */
     cost: CostLedgerSummary;
-    /** Compatibility alias of `cost.totalCostUsd`. */
-    totalCostUsd: number;
     /** Cells whose dispatch completed, including cells whose later judge failed. */
     cellsExecuted: number;
     cellsSkipped: number;
@@ -3748,7 +4318,7 @@ interface CampaignAggregates {
     cellsDispatchFailed?: number;
     /** Present on results that record failure stages. */
     cellsJudgeFailed?: number;
-    /** Legacy failures whose stage was not recorded. */
+    /** Failures whose stage could not be classified. */
     cellsUnclassifiedFailed?: number;
 }
 interface CampaignResult<TArtifact = unknown, TScenario extends Scenario = Scenario> {
@@ -4113,4 +4683,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 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 };
+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, DPO_CONTEXT_REQUIREMENT, type DatasetFormat, type DeploymentOutcome, type DetectRewardHackingInput, type DpoExportRow, type DpoLineContext, 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, PRM_CONTEXT_REQUIREMENT, type PairwiseOutcome, type ParetoPointInput, PredictiveValidityResearcher, type PredictiveValidityResearcherOptions, type PreferenceExtractionReport, type PreferenceStrategy, type PreferenceTriple, type PrmExportRow, type PrmLineContext, 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 RolloutLineContext, type RunAdaptationCurveOptions, type RunComputeCurveOptions, type RunRLCampaignOptions, type RunwiseStepSummary, STEP_REWARD_CONTEXT_REQUIREMENT, type ScenarioPerturbation, type ScenarioPerturbationKind, type SelfConsistencyOptions, type SelfConsistencyResult, type SftExportRow, type SftLookups, type SimFidelityOptions, type StepReward, type StepRewardJsonlRow, type StepScorer, type ThompsonCurriculumOptions, type TrainingLineSelectionOptions, type VarianceCurriculumOptions, type VerifiableReward, type VerifiableRewardExtractionOptions, type VerifiableRewardSource, appendToCorpus, applyEloUpdate, assertPrmTrainableLine, 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, validateDatasetFormats, varianceBasedCurriculum, verificationReportToRunRecord };