@tangle-network/agent-eval 0.128.2 → 0.130.0

package/dist/rl.js

@@ -1,1833 +1,2444 @@
-import {
-  doublyRobust,
-  inverseProbabilityWeighting,
-  offPolicyEstimateAll,
-  selfNormalizedImportanceWeighting
-} from "./chunk-VGRCHJON.js";
-import {
-  FileSystemOutcomeStore,
-  InMemoryOutcomeStore
-} from "./chunk-3RF76KTD.js";
-import {
-  runEvalCampaign
-} from "./chunk-TBL77AUT.js";
-import {
-  detectRewardHacking,
-  extractVerifiableReward,
-  extractVerifiableRewardsFromRecords,
-  filterDeterministicallyRewarded
-} from "./chunk-NYLOYM6N.js";
-import {
-  campaignCellToRunRecord
-} from "./chunk-2MKQIFS4.js";
-import "./chunk-PBE2LOSS.js";
-import {
-  rubricPredictiveValidity
-} from "./chunk-S5YLIBFX.js";
-import {
-  evaluateInterimReleaseConfidence
-} from "./chunk-MAZ26DC7.js";
-import "./chunk-VLOATJQ2.js";
-import "./chunk-DPUHNQLN.js";
-import {
-  benjaminiHochberg,
-  wilcoxonSignedRank
-} from "./chunk-MHELPNRP.js";
-import {
-  observationsFromRunRecords,
-  thompsonCurriculum,
-  varianceBasedCurriculum
-} from "./chunk-VZSRQ272.js";
-import "./chunk-WS3NZZQQ.js";
-import "./chunk-VI2UW6B6.js";
-import "./chunk-TT4KNT67.js";
-import "./chunk-PC4UYEBM.js";
-import "./chunk-VQMK5FMP.js";
-import {
-  runTaskScore
-} from "./chunk-2JX3CFMB.js";
-import "./chunk-MA6HLL3S.js";
-import {
-  ValidationError
-} from "./chunk-ONWEPEDO.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/rl/adaptation-eval.ts
+import { s as ValidationError } from "./errors-8YnH8WlF.js";
+import { o as runTaskScore } from "./run-record-BuoE80Dq.js";
+import { N as wilcoxonSignedRank, t as benjaminiHochberg } from "./statistics-CnnxdpOg.js";
+import { r as observedSplitScore, s as trainingScore } from "./reward-nw2xZGZG.js";
+import { l as assertRewardGate } from "./schema-C6DW4ZHR.js";
+import { t as isSplitEligible } from "./exporters-q9iL-2Jf.js";
+import { t as mintRolloutRows } from "./mint-yN2M2eh0.js";
+import { a as InMemoryTraceStore } from "./integrity-BzRbCHzi.js";
+import { c as campaignCellToRunRecord, i as filterDeterministicallyRewarded, n as extractVerifiableReward, r as extractVerifiableRewardsFromRecords, t as detectRewardHacking } from "./reward-hacking-qipEpKvY.js";
+import { t as runEvalCampaign } from "./eval-campaign-DEm6c8ru.js";
+import { t as evaluateInterimReleaseConfidence } from "./sequential-Br0mAPHA.js";
+import { t as rubricPredictiveValidity } from "./rubric-predictive-validity-B3xmbmS1.js";
+import { n as thompsonCurriculum, r as varianceBasedCurriculum, t as observationsFromRunRecords } from "./active-curriculum-C4mk67HP.js";
+import { i as selfNormalizedImportanceWeighting, n as inverseProbabilityWeighting, r as offPolicyEstimateAll, t as doublyRobust } from "./off-policy-DvgzvtIx.js";
+import { n as InMemoryOutcomeStore, t as FileSystemOutcomeStore } from "./outcome-store-ChBKlTd_.js";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+//#region src/rl/adaptation-eval.ts
 async function runAdaptationCurve(opts) {
-  const ks = opts.ks ?? [0, 1, 2, 4, 8, 16];
-  const reps = opts.reps ?? 3;
-  const passThreshold = opts.passThreshold ?? 0.5;
-  const sortedKs = [...ks].sort((a, b) => a - b);
-  const points = [];
-  for (const k of sortedKs) {
-    const perScenario = [];
-    const allScores = [];
-    let totalPasses = 0;
-    let totalAttempts = 0;
-    for (const scenario of opts.scenarios) {
-      const sid = scenario.scenarioId ?? `scenario-${opts.scenarios.indexOf(scenario)}`;
-      const scores = [];
-      let passes = 0;
-      for (let r = 0; r < reps; r++) {
-        const score = await opts.runner.run({ scenario, k, rep: r });
-        scores.push(score);
-        if (score >= passThreshold) passes++;
-        allScores.push(score);
-        if (score >= passThreshold) totalPasses++;
-        totalAttempts++;
-      }
-      const meanS = scores.reduce((s, v) => s + v, 0) / scores.length;
-      perScenario.push({ scenarioId: sid, meanScore: meanS, passes, total: scores.length });
-    }
-    const meanScore = allScores.reduce((s, v) => s + v, 0) / Math.max(1, allScores.length);
-    const variance = allScores.length < 2 ? 0 : allScores.reduce((s, v) => s + (v - meanScore) ** 2, 0) / (allScores.length - 1);
-    points.push({
-      k,
-      meanScore,
-      passRate: totalPasses / Math.max(1, totalAttempts),
-      std: Math.sqrt(variance),
-      n: allScores.length,
-      perScenario
-    });
-  }
-  const firstPassK2 = points.find((p) => p.passRate >= passThreshold)?.k ?? null;
-  const maxK = sortedKs[sortedKs.length - 1] ?? 1;
-  let area = 0;
-  for (let i = 1; i < points.length; i++) {
-    const x1 = points[i - 1].k;
-    const x2 = points[i].k;
-    const y1 = points[i - 1].meanScore;
-    const y2 = points[i].meanScore;
-    area += (y1 + y2) / 2 * (x2 - x1);
-  }
-  const adaptationArea = maxK === 0 ? 0 : area / maxK;
-  return { points, firstPassK: firstPassK2, adaptationArea };
-}
+	const ks = opts.ks ?? [
+		0,
+		1,
+		2,
+		4,
+		8,
+		16
+	];
+	const reps = opts.reps ?? 3;
+	const passThreshold = opts.passThreshold ?? .5;
+	const sortedKs = [...ks].sort((a, b) => a - b);
+	const points = [];
+	for (const k of sortedKs) {
+		const perScenario = [];
+		const allScores = [];
+		let totalPasses = 0;
+		let totalAttempts = 0;
+		for (const scenario of opts.scenarios) {
+			const sid = scenario.scenarioId ?? `scenario-${opts.scenarios.indexOf(scenario)}`;
+			const scores = [];
+			let passes = 0;
+			for (let r = 0; r < reps; r++) {
+				const score = await opts.runner.run({
+					scenario,
+					k,
+					rep: r
+				});
+				scores.push(score);
+				if (score >= passThreshold) passes++;
+				allScores.push(score);
+				if (score >= passThreshold) totalPasses++;
+				totalAttempts++;
+			}
+			const meanS = scores.reduce((s, v) => s + v, 0) / scores.length;
+			perScenario.push({
+				scenarioId: sid,
+				meanScore: meanS,
+				passes,
+				total: scores.length
+			});
+		}
+		const meanScore = allScores.reduce((s, v) => s + v, 0) / Math.max(1, allScores.length);
+		const variance = allScores.length < 2 ? 0 : allScores.reduce((s, v) => s + (v - meanScore) ** 2, 0) / (allScores.length - 1);
+		points.push({
+			k,
+			meanScore,
+			passRate: totalPasses / Math.max(1, totalAttempts),
+			std: Math.sqrt(variance),
+			n: allScores.length,
+			perScenario
+		});
+	}
+	const firstPassK = points.find((p) => p.passRate >= passThreshold)?.k ?? null;
+	const maxK = sortedKs[sortedKs.length - 1] ?? 1;
+	let area = 0;
+	for (let i = 1; i < points.length; i++) {
+		const x1 = points[i - 1].k;
+		const x2 = points[i].k;
+		const y1 = points[i - 1].meanScore;
+		const y2 = points[i].meanScore;
+		area += (y1 + y2) / 2 * (x2 - x1);
+	}
+	return {
+		points,
+		firstPassK,
+		adaptationArea: maxK === 0 ? 0 : area / maxK
+	};
+}
+/**
+* Paired comparison of two adaptation curves. Per-k deltas with 95%
+* bootstrap CIs (constructed from each curve's `perScenario` per-k means
+* — the bootstrap unit is the scenario, not the rep).
+*/
 function compareAdaptationCurves(a, b, opts = {}) {
-  const conf = opts.confidence ?? 0.95;
-  const resamples = opts.bootstrapResamples ?? 500;
-  const rng = makeRng(opts.seed);
-  const perK = [];
-  for (const ap of a.points) {
-    const bp = b.points.find((p) => p.k === ap.k);
-    if (!bp) continue;
-    const aMeans = ap.perScenario.map((s) => s.meanScore);
-    const bMeans = bp.perScenario.map((s) => s.meanScore);
-    const aCi = bootstrapMeanCi(aMeans, resamples, conf, rng);
-    const bCi = bootstrapMeanCi(bMeans, resamples, conf, rng);
-    perK.push({
-      k: ap.k,
-      deltaMean: ap.meanScore - bp.meanScore,
-      aLow: aCi.low,
-      aHigh: aCi.high,
-      bLow: bCi.low,
-      bHigh: bCi.high
-    });
-  }
-  const areaDelta = a.adaptationArea - b.adaptationArea;
-  const firstPassKDelta = a.firstPassK !== null && b.firstPassK !== null ? b.firstPassK - a.firstPassK : null;
-  const meanDelta = perK.reduce((s, p) => s + p.deltaMean, 0) / Math.max(1, perK.length);
-  let verdict;
-  if (Math.abs(meanDelta) < 0.02 && Math.abs(areaDelta) < 0.02) verdict = "similar";
-  else if (meanDelta > 0 && areaDelta > 0) verdict = "a_better";
-  else if (meanDelta < 0 && areaDelta < 0) verdict = "b_better";
-  else verdict = "similar";
-  const rationale = `mean per-k delta=${meanDelta.toFixed(3)}, area delta=${areaDelta.toFixed(3)}` + (firstPassKDelta !== null ? `, first-pass-k delta=${firstPassKDelta}` : "");
-  return { perK, areaDelta, firstPassKDelta, verdict, rationale };
-}
-function firstPassK(curve, threshold = 0.5) {
-  return curve.points.find((p) => p.passRate >= threshold)?.k ?? null;
+	const conf = opts.confidence ?? .95;
+	const resamples = opts.bootstrapResamples ?? 500;
+	const rng = makeRng(opts.seed);
+	const perK = [];
+	for (const ap of a.points) {
+		const bp = b.points.find((p) => p.k === ap.k);
+		if (!bp) continue;
+		const aMeans = ap.perScenario.map((s) => s.meanScore);
+		const bMeans = bp.perScenario.map((s) => s.meanScore);
+		const aCi = bootstrapMeanCi(aMeans, resamples, conf, rng);
+		const bCi = bootstrapMeanCi(bMeans, resamples, conf, rng);
+		perK.push({
+			k: ap.k,
+			deltaMean: ap.meanScore - bp.meanScore,
+			aLow: aCi.low,
+			aHigh: aCi.high,
+			bLow: bCi.low,
+			bHigh: bCi.high
+		});
+	}
+	const areaDelta = a.adaptationArea - b.adaptationArea;
+	const firstPassKDelta = a.firstPassK !== null && b.firstPassK !== null ? b.firstPassK - a.firstPassK : null;
+	const meanDelta = perK.reduce((s, p) => s + p.deltaMean, 0) / Math.max(1, perK.length);
+	let verdict;
+	if (Math.abs(meanDelta) < .02 && Math.abs(areaDelta) < .02) verdict = "similar";
+	else if (meanDelta > 0 && areaDelta > 0) verdict = "a_better";
+	else if (meanDelta < 0 && areaDelta < 0) verdict = "b_better";
+	else verdict = "similar";
+	const rationale = `mean per-k delta=${meanDelta.toFixed(3)}, area delta=${areaDelta.toFixed(3)}` + (firstPassKDelta !== null ? `, first-pass-k delta=${firstPassKDelta}` : "");
+	return {
+		perK,
+		areaDelta,
+		firstPassKDelta,
+		verdict,
+		rationale
+	};
+}
+/** First k at which the curve's per-scenario pass rate reliably hits the threshold. */
+function firstPassK(curve, threshold = .5) {
+	return curve.points.find((p) => p.passRate >= threshold)?.k ?? null;
 }
 function makeRng(seed) {
-  if (seed === void 0) return Math.random;
-  let s = seed >>> 0;
-  return () => {
-    s = s + 1831565813 >>> 0;
-    let t = s;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
+	if (seed === void 0) return Math.random;
+	let s = seed >>> 0;
+	return () => {
+		s = s + 1831565813 >>> 0;
+		let t = s;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
 }
 function bootstrapMeanCi(xs, resamples, confidence, rng) {
-  if (xs.length < 2) return { low: xs[0] ?? 0, high: xs[0] ?? 0 };
-  const samples = new Array(resamples);
-  for (let b = 0; b < resamples; b++) {
-    let sum = 0;
-    for (let i = 0; i < xs.length; i++) sum += xs[Math.floor(rng() * xs.length)];
-    samples[b] = sum / xs.length;
-  }
-  samples.sort((a, b) => a - b);
-  const alpha = 1 - confidence;
-  return {
-    low: samples[Math.floor(alpha / 2 * resamples)],
-    high: samples[Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1)]
-  };
-}
-
-// src/rl/compute-curves.ts
+	if (xs.length < 2) return {
+		low: xs[0] ?? 0,
+		high: xs[0] ?? 0
+	};
+	const samples = new Array(resamples);
+	for (let b = 0; b < resamples; b++) {
+		let sum = 0;
+		for (let i = 0; i < xs.length; i++) sum += xs[Math.floor(rng() * xs.length)];
+		samples[b] = sum / xs.length;
+	}
+	samples.sort((a, b) => a - b);
+	const alpha = 1 - confidence;
+	return {
+		low: samples[Math.floor(alpha / 2 * resamples)],
+		high: samples[Math.min(resamples - 1, Math.ceil((1 - alpha / 2) * resamples) - 1)]
+	};
+}
+//#endregion
+//#region src/rl/compute-curves.ts
+/**
+* Test-time compute scaling curves.
+*
+* The test-time-compute frontier paper (Snell et al. 2024) and the
+* subsequent o1-style scaling work both show that LLM-agent capability
+* is a function of the compute budget at inference, not just of the
+* training run. The right way to characterize a candidate is therefore
+* a *curve* — score at compute budgets {1×, 4×, 16×, …} — not a single
+* point.
+*
+* This module ships:
+*
+*   1. The compute-curve harness — `runComputeCurve(runner, budgets)` —
+*      that evaluates one candidate at a sequence of compute budgets
+*      and returns the (compute, score) curve.
+*   2. A best-of-N evaluator — `bestOfN(runner, n, scoreFn)` — the
+*      simplest test-time-compute scaling primitive: sample N
+*      independent rollouts, return the best.
+*   3. A self-consistency evaluator — `selfConsistency(runner, n)` —
+*      the majority-vote variant of best-of-N for tasks with a small
+*      categorical answer space.
+*   4. Pareto-frontier extraction over multiple candidates — given
+*      (candidate, compute, score) tuples, return the set of
+*      candidate-compute combinations that aren't dominated.
+*
+* Caveat: "compute" here is the caller's notion of a compute unit. For
+* agent eval that's typically wall-time × parallelism, or token budget,
+* or LLM-call count. We accept whatever the caller provides; the curve
+* is on whatever axis they pick.
+*/
 async function runComputeCurve(opts) {
-  const points = [];
-  for (const budget of opts.budgets) {
-    const r = await opts.runAtBudget(budget);
-    points.push({
-      budgetId: budget.id,
-      cost: budget.cost,
-      score: r.score,
-      samples: r.samples,
-      std: r.std,
-      metrics: r.metrics
-    });
-  }
-  const sorted = [...points].sort((a, b) => a.cost - b.cost);
-  const logSlope = sorted.length >= 2 ? fitLogSlope(sorted) : null;
-  const best = points.reduce((a, b) => b.score > a.score ? b : a);
-  return { candidateId: opts.candidateId, points: sorted, logSlope, best };
-}
+	const points = [];
+	for (const budget of opts.budgets) {
+		const r = await opts.runAtBudget(budget);
+		points.push({
+			budgetId: budget.id,
+			cost: budget.cost,
+			score: r.score,
+			samples: r.samples,
+			std: r.std,
+			metrics: r.metrics
+		});
+	}
+	const sorted = [...points].sort((a, b) => a.cost - b.cost);
+	const logSlope = sorted.length >= 2 ? fitLogSlope(sorted) : null;
+	const best = points.reduce((a, b) => b.score > a.score ? b : a);
+	return {
+		candidateId: opts.candidateId,
+		points: sorted,
+		logSlope,
+		best
+	};
+}
+/** The simplest test-time scaling primitive. */
 async function bestOfN(opts) {
-  if (opts.n <= 0) throw new ValidationError("bestOfN: n must be > 0");
-  const rollouts = [];
-  const scores = [];
-  for (let i = 0; i < opts.n; i++) {
-    const r = await opts.sample(i);
-    rollouts.push(r);
-    scores.push(await opts.scoreFn(r));
-  }
-  let bestIndex = 0;
-  for (let i = 1; i < scores.length; i++) if (scores[i] > scores[bestIndex]) bestIndex = i;
-  const meanScore = scores.reduce((s, x) => s + x, 0) / scores.length;
-  return {
-    best: rollouts[bestIndex],
-    bestScore: scores[bestIndex],
-    scores,
-    meanScore,
-    bestIndex
-  };
-}
+	if (opts.n <= 0) throw new ValidationError("bestOfN: n must be > 0");
+	const rollouts = [];
+	const scores = [];
+	for (let i = 0; i < opts.n; i++) {
+		const r = await opts.sample(i);
+		rollouts.push(r);
+		scores.push(await opts.scoreFn(r));
+	}
+	let bestIndex = 0;
+	for (let i = 1; i < scores.length; i++) if (scores[i] > scores[bestIndex]) bestIndex = i;
+	const meanScore = scores.reduce((s, x) => s + x, 0) / scores.length;
+	return {
+		best: rollouts[bestIndex],
+		bestScore: scores[bestIndex],
+		scores,
+		meanScore,
+		bestIndex
+	};
+}
+/**
+* Self-consistency / majority-vote test-time scaling. For tasks with a
+* small categorical answer space (math problems, multiple choice).
+*/
 async function selfConsistency(opts) {
-  if (opts.n <= 0) throw new ValidationError("selfConsistency: n must be > 0");
-  const rollouts = [];
-  const histogram = {};
-  for (let i = 0; i < opts.n; i++) {
-    const r = await opts.sample(i);
-    rollouts.push(r);
-    const key = opts.answerKey(r);
-    histogram[key] = (histogram[key] ?? 0) + 1;
-  }
-  let answer = "";
-  let max = -1;
-  for (const [k, v] of Object.entries(histogram)) {
-    if (v > max) {
-      max = v;
-      answer = k;
-    }
-  }
-  const representative = rollouts.find((r) => opts.answerKey(r) === answer) ?? rollouts[0];
-  return {
-    answer,
-    agreement: max / opts.n,
-    histogram,
-    representative,
-    rollouts
-  };
+	if (opts.n <= 0) throw new ValidationError("selfConsistency: n must be > 0");
+	const rollouts = [];
+	const histogram = {};
+	for (let i = 0; i < opts.n; i++) {
+		const r = await opts.sample(i);
+		rollouts.push(r);
+		const key = opts.answerKey(r);
+		histogram[key] = (histogram[key] ?? 0) + 1;
+	}
+	let answer = "";
+	let max = -1;
+	for (const [k, v] of Object.entries(histogram)) if (v > max) {
+		max = v;
+		answer = k;
+	}
+	const representative = rollouts.find((r) => opts.answerKey(r) === answer) ?? rollouts[0];
+	return {
+		answer,
+		agreement: max / opts.n,
+		histogram,
+		representative,
+		rollouts
+	};
 }
 function paretoFrontier(points) {
-  const onFrontier = [];
-  for (const p of points) {
-    const dominated = points.some(
-      (q) => q !== p && q.cost <= p.cost && q.score >= p.score && (q.cost < p.cost || q.score > p.score)
-    );
-    if (!dominated) onFrontier.push(p);
-  }
-  return onFrontier.sort((a, b) => a.cost - b.cost);
+	const onFrontier = [];
+	for (const p of points) if (!points.some((q) => q !== p && q.cost <= p.cost && q.score >= p.score && (q.cost < p.cost || q.score > p.score))) onFrontier.push(p);
+	return onFrontier.sort((a, b) => a.cost - b.cost);
 }
 function fitLogSlope(points) {
-  const xs = points.map((p) => Math.log(Math.max(1e-12, p.cost)));
-  const ys = points.map((p) => p.score);
-  const n = xs.length;
-  const mx = xs.reduce((s, x) => s + x, 0) / n;
-  const my = ys.reduce((s, y) => s + y, 0) / n;
-  let num = 0;
-  let den = 0;
-  for (let i = 0; i < n; i++) {
-    num += (xs[i] - mx) * (ys[i] - my);
-    den += (xs[i] - mx) ** 2;
-  }
-  return den === 0 ? 0 : num / den;
-}
-
-// src/rl/contamination.ts
+	const xs = points.map((p) => Math.log(Math.max(1e-12, p.cost)));
+	const ys = points.map((p) => p.score);
+	const n = xs.length;
+	const mx = xs.reduce((s, x) => s + x, 0) / n;
+	const my = ys.reduce((s, y) => s + y, 0) / n;
+	let num = 0;
+	let den = 0;
+	for (let i = 0; i < n; i++) {
+		num += (xs[i] - mx) * (ys[i] - my);
+		den += (xs[i] - mx) ** 2;
+	}
+	return den === 0 ? 0 : num / den;
+}
+//#endregion
+//#region src/rl/contamination.ts
+/**
+* Contamination probe — held-out perturbation tests.
+*
+* The bug class: once a benchmark scenario set is published, models train
+* on it, and your scores become invalid. SWE-Bench-Verified, GPQA, and
+* MMLU-Pro all exist because their predecessors got contaminated within
+* months. The right defense is to keep a held-out *perturbed* version of
+* every scenario — same task, slightly different surface — and check
+* whether scores diverge significantly. Genuine capability transfers; rote
+* memorization doesn't.
+*
+* This module ships the probe contract:
+*
+*   1. A `ScenarioPerturbation` strategy type — function that produces a
+*      perturbed scenario from an original.
+*   2. `runContaminationProbe({ originals, perturbed, scoreFn })` — runs
+*      both halves and reports per-scenario score divergence + a global
+*      contamination verdict via paired Wilcoxon.
+*   3. Several stock perturbations: `renameVariables`, `shuffleOrder`,
+*      `paraphrasePrompt`, `injectIrrelevantClause`. Each preserves the
+*      task's structural difficulty while breaking surface memorization.
+*
+* The verdict is conservative: if the perturbed-vs-original score
+* difference is statistically significant (BH-adjusted p < 0.05) AND
+* the median drop is > 5 percentage points, we flag *contamination
+* suspected*. False positives are possible (the perturbation might
+* actually be harder); the default is to flag for review, not to
+* autoreject.
+*/
 async function runContaminationProbe(input, opts = {}) {
-  const fdr = opts.fdr ?? 0.05;
-  const minMedianDrop = opts.minMedianDrop ?? 0.05;
-  const floor = opts.scoreFloor ?? 0;
-  if (!input.perturbed && !input.perturbation) {
-    throw new ValidationError(
-      "runContaminationProbe: must supply either `perturbed` or `perturbation`."
-    );
-  }
-  const perturbed = input.perturbed ?? await Promise.all(input.originals.map((s) => input.perturbation.apply(s)));
-  if (perturbed.length !== input.originals.length) {
-    throw new ValidationError(
-      `runContaminationProbe: perturbed length ${perturbed.length} \u2260 originals ${input.originals.length}`
-    );
-  }
-  const origScores = await Promise.all(input.originals.map((s) => input.scoreFn(s)));
-  const pertScores = await Promise.all(perturbed.map((s) => input.scoreFn(s)));
-  const perScenario = input.originals.map((s, i) => ({
-    scenarioId: input.scenarioId(s),
-    originalScore: origScores[i],
-    perturbedScore: pertScores[i],
-    delta: pertScores[i] - origScores[i],
-    qValue: NaN
-  }));
-  const valid = perScenario.filter((p) => p.originalScore >= floor && p.perturbedScore >= floor);
-  if (valid.length < 4) {
-    return {
-      perScenario,
-      pairedTest: { w: 0, p: 1 },
-      medianDelta: 0,
-      meanDelta: 0,
-      contaminationSuspected: false,
-      reason: `insufficient valid scenarios (n=${valid.length}, need \u2265 4)`,
-      n: valid.length
-    };
-  }
-  const origValid = valid.map((p) => p.originalScore);
-  const pertValid = valid.map((p) => p.perturbedScore);
-  const pairedTest = wilcoxonSignedRank(origValid, pertValid);
-  const deltas = valid.map((p) => p.delta);
-  const sortedDeltas = [...deltas].sort((a, b) => a - b);
-  const median = sortedDeltas[Math.floor(sortedDeltas.length / 2)];
-  const mean = deltas.reduce((s, d) => s + d, 0) / deltas.length;
-  const pseudoP = valid.map((p) => Math.min(1, Math.max(1e-6, 1 - Math.abs(p.delta) / 1)));
-  const { qValues } = benjaminiHochberg(pseudoP, fdr);
-  for (let i = 0; i < valid.length; i++) {
-    const v = valid[i];
-    const idx = perScenario.findIndex((p) => p.scenarioId === v.scenarioId);
-    if (idx >= 0) perScenario[idx].qValue = qValues[i];
-  }
-  const contaminationSuspected = pairedTest.p < fdr && median <= -minMedianDrop;
-  const reason = contaminationSuspected ? `paired p=${pairedTest.p.toFixed(4)} < ${fdr} and median drop ${median.toFixed(4)} \u2265 ${minMedianDrop}` : pairedTest.p >= fdr ? `no significant difference (paired p=${pairedTest.p.toFixed(4)})` : `significant but small effect (median delta ${median.toFixed(4)})`;
-  return {
-    perScenario,
-    pairedTest,
-    medianDelta: median,
-    meanDelta: mean,
-    contaminationSuspected,
-    reason,
-    n: valid.length
-  };
-}
+	const fdr = opts.fdr ?? .05;
+	const minMedianDrop = opts.minMedianDrop ?? .05;
+	const floor = opts.scoreFloor ?? 0;
+	if (!input.perturbed && !input.perturbation) throw new ValidationError("runContaminationProbe: must supply either `perturbed` or `perturbation`.");
+	const perturbed = input.perturbed ?? await Promise.all(input.originals.map((s) => input.perturbation.apply(s)));
+	if (perturbed.length !== input.originals.length) throw new ValidationError(`runContaminationProbe: perturbed length ${perturbed.length} ≠ originals ${input.originals.length}`);
+	const origScores = await Promise.all(input.originals.map((s) => input.scoreFn(s)));
+	const pertScores = await Promise.all(perturbed.map((s) => input.scoreFn(s)));
+	const perScenario = input.originals.map((s, i) => ({
+		scenarioId: input.scenarioId(s),
+		originalScore: origScores[i],
+		perturbedScore: pertScores[i],
+		delta: pertScores[i] - origScores[i],
+		qValue: NaN
+	}));
+	const valid = perScenario.filter((p) => p.originalScore >= floor && p.perturbedScore >= floor);
+	if (valid.length < 4) return {
+		perScenario,
+		pairedTest: {
+			w: 0,
+			p: 1
+		},
+		medianDelta: 0,
+		meanDelta: 0,
+		contaminationSuspected: false,
+		reason: `insufficient valid scenarios (n=${valid.length}, need ≥ 4)`,
+		n: valid.length
+	};
+	const pairedTest = wilcoxonSignedRank(valid.map((p) => p.originalScore), valid.map((p) => p.perturbedScore));
+	const deltas = valid.map((p) => p.delta);
+	const sortedDeltas = [...deltas].sort((a, b) => a - b);
+	const median = sortedDeltas[Math.floor(sortedDeltas.length / 2)];
+	const mean = deltas.reduce((s, d) => s + d, 0) / deltas.length;
+	const { qValues } = benjaminiHochberg(valid.map((p) => Math.min(1, Math.max(1e-6, 1 - Math.abs(p.delta) / 1))), fdr);
+	for (let i = 0; i < valid.length; i++) {
+		const v = valid[i];
+		const idx = perScenario.findIndex((p) => p.scenarioId === v.scenarioId);
+		if (idx >= 0) perScenario[idx].qValue = qValues[i];
+	}
+	const contaminationSuspected = pairedTest.p < fdr && median <= -minMedianDrop;
+	return {
+		perScenario,
+		pairedTest,
+		medianDelta: median,
+		meanDelta: mean,
+		contaminationSuspected,
+		reason: contaminationSuspected ? `paired p=${pairedTest.p.toFixed(4)} < ${fdr} and median drop ${median.toFixed(4)} ≥ ${minMedianDrop}` : pairedTest.p >= fdr ? `no significant difference (paired p=${pairedTest.p.toFixed(4)})` : `significant but small effect (median delta ${median.toFixed(4)})`,
+		n: valid.length
+	};
+}
+/**
+* Identifier-rename perturbation for code/text scenarios. Replaces every
+* occurrence of the listed identifiers with synthesized aliases. Use when
+* the scenario's structural difficulty is independent of variable names
+* (e.g. SWE-Bench-style coding tasks).
+*/
 function renameVariables(identifiers, rename = (n, i) => `${n}_${(i % 26 + 10).toString(36)}`) {
-  return {
-    kind: "rename_variables",
-    apply(scenario) {
-      let prompt = scenario.prompt;
-      identifiers.forEach((id, i) => {
-        const replacement = rename(id, i);
-        const re = new RegExp(`\\b${escapeRegex(id)}\\b`, "g");
-        prompt = prompt.replace(re, replacement);
-      });
-      return { ...scenario, prompt };
-    }
-  };
-}
+	return {
+		kind: "rename_variables",
+		apply(scenario) {
+			let prompt = scenario.prompt;
+			identifiers.forEach((id, i) => {
+				const replacement = rename(id, i);
+				const re = new RegExp(`\\b${escapeRegex(id)}\\b`, "g");
+				prompt = prompt.replace(re, replacement);
+			});
+			return {
+				...scenario,
+				prompt
+			};
+		}
+	};
+}
+/**
+* Order-shuffle perturbation. Reshuffles a list-shaped section of the
+* prompt (for QA scenarios that present options A/B/C/D — answer depends
+* on the option labels, not order). Caller provides the section extractor.
+*/
 function shuffleOrder(shuffleSection, seed) {
-  let s = seed >>> 0;
-  const rng = () => {
-    s = s + 1831565813 >>> 0;
-    let t = s;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-  return {
-    kind: "shuffle_order",
-    apply(scenario) {
-      const newPrompt = shuffleSection(scenario.prompt, rng);
-      return { ...scenario, prompt: newPrompt };
-    }
-  };
-}
+	let s = seed >>> 0;
+	const rng = () => {
+		s = s + 1831565813 >>> 0;
+		let t = s;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+	return {
+		kind: "shuffle_order",
+		apply(scenario) {
+			const newPrompt = shuffleSection(scenario.prompt, rng);
+			return {
+				...scenario,
+				prompt: newPrompt
+			};
+		}
+	};
+}
+/**
+* Inject-irrelevant-clause perturbation. Adds a benign sentence that
+* shouldn't change the answer. Tests for "did the model just memorize
+* the input string."
+*/
 function injectIrrelevantClause(clause, position = "prefix") {
-  return {
-    kind: "inject_irrelevant_clause",
-    apply(scenario) {
-      const prompt = position === "prefix" ? `${clause} ${scenario.prompt}` : `${scenario.prompt} ${clause}`;
-      return { ...scenario, prompt };
-    }
-  };
+	return {
+		kind: "inject_irrelevant_clause",
+		apply(scenario) {
+			const prompt = position === "prefix" ? `${clause} ${scenario.prompt}` : `${scenario.prompt} ${clause}`;
+			return {
+				...scenario,
+				prompt
+			};
+		}
+	};
 }
 function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// src/rl/corpus.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
-import { dirname } from "path";
-
-// src/rl/exporters.ts
-async function toDpoRows(triples, lookups) {
-  const out = [];
-  for (const t of triples) {
-    const [chosenPrompt, rejectedPrompt, chosen, rejected] = await Promise.all([
-      Promise.resolve(lookups.promptOf(t.chosenRunId)),
-      Promise.resolve(lookups.promptOf(t.rejectedRunId)),
-      Promise.resolve(lookups.completionOf(t.chosenRunId)),
-      Promise.resolve(lookups.completionOf(t.rejectedRunId))
-    ]);
-    if (chosenPrompt !== rejectedPrompt) {
-      throw new Error(
-        `toDpoRows: preference "${t.chosenRunId}"/"${t.rejectedRunId}" resolves to different prompts`
-      );
-    }
-    out.push({
-      prompt: chosenPrompt,
-      chosen,
-      rejected,
-      margin: t.marginScore,
-      meta: {
-        scenarioId: t.scenarioId,
-        chosenVariantId: t.chosenVariantId,
-        rejectedVariantId: t.rejectedVariantId,
-        chosenRunId: t.chosenRunId,
-        rejectedRunId: t.rejectedRunId,
-        chosenModel: t.meta.chosenModel,
-        rejectedModel: t.meta.rejectedModel
-      }
-    });
-  }
-  return out;
-}
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/rl/rollout-input.ts
+/**
+* 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 line's reward, with `null` meaning "no verdict exists" and never "scored
+* zero".
+*
+* The wire contract represents an absent verdict directly as `reward: null`.
+*/
+function trainableLineReward(line) {
+	assertRewardGate(line, "trainable reward");
+	const { reward } = line.outcome;
+	if (reward === null || !Number.isFinite(reward)) return null;
+	return reward;
+}
+/** The anti-Goodhart flag as it travels on the line. */
+function isLineRealnessGated(line) {
+	return line.outcome.realness_gated === true;
+}
+function push(index, key, line) {
+	const existing = index.get(key);
+	if (existing === void 0) index.set(key, [line]);
+	else existing.push(line);
+}
+function invocationIndex(lines) {
+	const byRollout = /* @__PURE__ */ new Map();
+	const byRun = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		push(byRollout, line.rollout_id, line);
+		push(byRun, line.run_id, line);
+	}
+	return {
+		byRollout,
+		byRun
+	};
+}
+/**
+* Resolve one referenced id to exactly ONE invocation, or refuse to guess.
+*
+* The previous implementation was `new Map(lines.map((l) => [l.run_id, l]))`,
+* which is LAST-WINS: with a gated supervisor node and an ungated worker sharing
+* a `run_id`, the answer depended on which one appeared later in the array, so
+* `[gatedRoot, worker, rival]` emitted the gamed trajectory as `chosen` and
+* simply reordering the same input suppressed it. An order-dependent security
+* property passes every test whose fixture happens to be ordered favourably,
+* which is the worst possible failure mode for a gate.
+*
+* The rule that removes order from the answer: an id resolves only when it names
+* one invocation. `rollout_id` is tried first because it IS the invocation id;
+* `run_id` is accepted only when the run holds a single invocation, and a
+* cross-index disagreement (an id that is one line's `rollout_id` and a
+* different line's `run_id`) is ambiguous rather than silently preferring
+* either.
+*/
+function resolveInvocation(index, id) {
+	const rollouts = index.byRollout.get(id) ?? [];
+	const runs = index.byRun.get(id) ?? [];
+	if (rollouts.length > 1) return {
+		kind: "ambiguous",
+		count: rollouts.length
+	};
+	const exact = rollouts[0];
+	if (exact !== void 0) {
+		if (runs.some((line) => line !== exact)) return {
+			kind: "ambiguous",
+			count: 1 + runs.filter((line) => line !== exact).length
+		};
+		return {
+			kind: "resolved",
+			line: exact
+		};
+	}
+	if (runs.length > 1) return {
+		kind: "ambiguous",
+		count: runs.length
+	};
+	const only = runs[0];
+	return only === void 0 ? { kind: "missing" } : {
+		kind: "resolved",
+		line: only
+	};
+}
+/**
+* THE admission rule for every exporter whose input is line-less — one
+* implementation, because two siblings over the same input class with different
+* gating is the defect being eliminated, and it has now happened twice
+* (`toPrmRows` hardened while `toDpoRows` was left open; `toGrpoRows`'
+* `rewardOf` gated while `extractPreferences`' identically-named hook was not).
+*
+* Fail-closed in five steps:
+*   1. No context at all → throw. A two-argument call used to be accepted and
+*      produced rows with no gate applied whatsoever.
+*   2. A referenced id with NO line → throw. Its gate status is unknown, and
+*      unknown is not clean. Thrown rather than dropped because it means the
+*      caller did not supply the context it was asked for, which is a defect in
+*      the call, not in the data.
+*   3. A referenced id naming MORE THAN ONE invocation → DROP the item and count
+*      it. Dropped rather than thrown because, unlike (2), this is ordinary data
+*      — a supervision episode legitimately holds a supervisor invocation and
+*      several workers under one `run_id` — and throwing would make these
+*      exporters unusable on any supervisor corpus, whose only workaround is for
+*      the caller to hand-filter `context.lines` down to one line per run. That
+*      workaround IS the leak, performed by hand. The count is surfaced by
+*      `admitUngatedByInvocation` so the drop is never silent.
+*   4. Every resolved line goes through `assertRewardGate`, so the line-less
+*      exporters compose the same check list as the waist exporters instead of
+*      relying on `realness_gated` alone (which is one of three checks).
+*   5. Either side realness-gated → DROP the item. Dropped rather than zeroed
+*      because these shapes have no honest zero: a preference pair is a
+*      statement that one trajectory is better than another, and a gamed
+*      trajectory belongs on neither side of it — as the chosen one it teaches
+*      the gaming move outright, and as the rejected one it still ships the
+*      gaming trajectory's text into the training file as a contrast example
+*      nobody asked for.
+*
+* `inspect` is the per-exporter extra check (PRM's trajectory-completeness
+* rules). It runs on every resolved line before any item is admitted, so the
+* whole batch fails before a single row is built.
+*
+* Pure: it reports what it dropped and prints nothing.
+*/
+function auditInvocationAdmission(items, idsOf, context, requirement, inspect) {
+	if (context === void 0 || context === null) throw new Error(`${requirement.exporter}: a ${requirement.contextType} is required — ${requirement.because} Pass \`{ lines: (await mintRolloutRows(...)).rows }\`.`);
+	const index = invocationIndex(context.lines);
+	const audit = {
+		admitted: [],
+		gatedDrops: 0,
+		ambiguousDrops: 0,
+		ambiguous: []
+	};
+	for (const item of items) {
+		const lines = [];
+		let ambiguous = false;
+		for (const id of idsOf(item)) {
+			const resolution = resolveInvocation(index, id);
+			if (resolution.kind === "missing") throw new Error(`${requirement.exporter}: no rollout line supplied for run ${id} — its realness gate and capture quality are unknown`);
+			if (resolution.kind === "ambiguous") {
+				ambiguous = true;
+				if (!audit.ambiguous.some((entry) => entry.id === id)) audit.ambiguous.push({
+					id,
+					invocations: resolution.count
+				});
+				continue;
+			}
+			lines.push(resolution.line);
+		}
+		for (const line of lines) {
+			assertRewardGate(line, requirement.exporter);
+			inspect?.(line);
+		}
+		if (ambiguous) {
+			audit.ambiguousDrops++;
+			continue;
+		}
+		if (lines.some(isLineRealnessGated)) {
+			audit.gatedDrops++;
+			continue;
+		}
+		audit.admitted.push(item);
+	}
+	return audit;
+}
+/**
+* `auditInvocationAdmission` for the exporters, which return rows and have
+* nowhere to put a count.
+*
+* The ambiguous drops are announced rather than swallowed: a caller who asked
+* for N pairs and silently received N-k has no way to notice that a chunk of
+* their preference data quietly evaporated, and "the training set got smaller
+* for a reason nobody printed" is the same class of invisible failure as the
+* gate that never ran. A gated drop is NOT announced — that one is the gate
+* doing exactly its job, on the population the caller already knows is flagged.
+*/
+function admitUngatedByInvocation(items, idsOf, context, requirement, inspect) {
+	const audit = auditInvocationAdmission(items, idsOf, context, requirement, inspect);
+	if (audit.ambiguousDrops > 0) {
+		const named = audit.ambiguous.map((e) => `${e.id} (${e.invocations} invocations)`).join(", ");
+		console.warn(`[${requirement.exporter}] dropped ${audit.ambiguousDrops} item(s): ${named} name more than one invocation in the supplied lines, so the realness gate cannot be read for the invocation the artifact meant. Reference the \`rollout_id\` instead of the \`run_id\`, or supply a context holding one invocation per run.`);
+	}
+	return audit.admitted;
+}
+//#endregion
+//#region src/rl/exporters.ts
+/**
+* Trainer-format exporters.
+*
+* 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
+* JSONL conventions. Rather than ship N adapters, this module ships the
+* canonical formats most production pipelines accept and ergonomic helpers
+* for the rest.
+*
+* Shapes:
+*   - **DPO / IPO / KTO** — `{prompt, chosen, rejected}` JSONL. Consumed
+*     by HuggingFace TRL, prime-rl's offline DPO, OpenRLHF.
+*   - **GRPO offline** — `{prompt, completions[], rewards[]}` JSONL.
+*     Consumed by prime-rl GRPO, verl, OpenRLHF.
+*   - **SFT** — `{messages[]}` JSONL with chosen completion as the final
+*     assistant turn. Consumed by HF SFT trainers, OpenAI fine-tuning,
+*     Anthropic finetuning.
+*   - **PRM** — `{prompt, prefix_steps[], chosen_step, rejected_step}` JSONL.
+*     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 (`MintedRolloutLine[]`, `PreferenceTriple[]`, etc.) are
+* agent-eval's contract; without first-party exporters consumers reverse-
+* engineer the mapping every release. The exporters codify it.
+*
+* The exporters take callbacks for any field that isn't on the canonical
+* 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.
+*/
+const DPO_CONTEXT_REQUIREMENT = {
+	exporter: "DPO export",
+	contextType: "DpoLineContext",
+	because: "a PreferenceTriple carries only run ids and a bare margin number, so without the minted rollout lines this exporter cannot see the realness gate and will write a run that faked its success onto the CHOSEN side of the pair — which is DPO trained to PREFER the gaming trajectory."
+};
+/**
+* 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.
+*/
+async function toDpoRows(triples, lookups, context) {
+	const admitted = admitUngatedByInvocation(triples, (t) => [t.chosenRunId, t.rejectedRunId], context, DPO_CONTEXT_REQUIREMENT);
+	const out = [];
+	for (const t of admitted) {
+		const [chosenPrompt, rejectedPrompt, chosen, rejected] = await Promise.all([
+			Promise.resolve(lookups.promptOf(t.chosenRunId)),
+			Promise.resolve(lookups.promptOf(t.rejectedRunId)),
+			Promise.resolve(lookups.completionOf(t.chosenRunId)),
+			Promise.resolve(lookups.completionOf(t.rejectedRunId))
+		]);
+		if (chosenPrompt !== rejectedPrompt) throw new Error(`toDpoRows: preference "${t.chosenRunId}"/"${t.rejectedRunId}" resolves to different prompts`);
+		out.push({
+			prompt: chosenPrompt,
+			chosen,
+			rejected,
+			margin: t.marginScore,
+			meta: {
+				scenarioId: t.scenarioId,
+				chosenVariantId: t.chosenVariantId,
+				rejectedVariantId: t.rejectedVariantId,
+				chosenRunId: t.chosenRunId,
+				rejectedRunId: t.rejectedRunId,
+				chosenModel: t.meta.chosenModel,
+				rejectedModel: t.meta.rejectedModel
+			}
+		});
+	}
+	return out;
+}
+/** Serialize DPO rows as JSONL. One line per row. */
 function toDpoJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-async function toGrpoRows(runs, lookups) {
-  const rewardOf2 = lookups.rewardOf ?? defaultReward;
-  const promptHashByScenario = /* @__PURE__ */ new Map();
-  const grouped = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    const reward2 = rewardOf2(r);
-    if (!isTrainingRunEligible(r, reward2, lookups)) continue;
-    const existingPromptHash = promptHashByScenario.get(r.scenarioId);
-    if (existingPromptHash !== void 0 && existingPromptHash !== r.promptHash) {
-      throw new Error(
-        `toGrpoRows: scenario "${r.scenarioId}" contains mixed prompt identities "${existingPromptHash}" and "${r.promptHash}"`
-      );
-    }
-    promptHashByScenario.set(r.scenarioId, r.promptHash);
-    const key = `${r.scenarioId}\0${r.promptHash}`;
-    const group = grouped.get(key) ?? {
-      scenarioId: r.scenarioId,
-      promptHash: r.promptHash,
-      scored: []
-    };
-    group.scored.push({ run: r, reward: reward2 });
-    grouped.set(key, group);
-  }
-  const rows = [];
-  for (const { scenarioId, promptHash, scored } of grouped.values()) {
-    if (scored.length < 2) continue;
-    const prompts = await Promise.all(
-      scored.map(({ run }) => Promise.resolve(lookups.promptOf(run.runId)))
-    );
-    const prompt = prompts[0];
-    if (prompts.some((value) => value !== prompt)) {
-      throw new Error(
-        `toGrpoRows: prompt identity "${promptHash}" resolves to different text within scenario "${scenarioId}"`
-      );
-    }
-    const completions = await Promise.all(
-      scored.map(({ run }) => Promise.resolve(lookups.completionOf(run.runId)))
-    );
-    const rewards = scored.map(({ reward: reward2 }) => reward2);
-    const runIds = scored.map(({ run }) => run.runId);
-    rows.push({
-      prompt,
-      completions,
-      rewards,
-      runIds,
-      meta: {
-        scenarioId,
-        promptHash,
-        n: completions.length,
-        meanReward: rewards.reduce((s, x) => s + x, 0) / rewards.length
-      }
-    });
-  }
-  return rows;
+	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
+}
+/**
+* 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. 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`.)
+*/
+async function toGrpoRows(lines, lookups) {
+	return grpoRowsFromLines(lines, lookups);
+}
+async function grpoRowsFromLines(lines, lookups) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		if (!isSelectedSplit(line, lookups)) continue;
+		const arr = grouped.get(line.task.instance_id) ?? [];
+		arr.push(line);
+		grouped.set(line.task.instance_id, arr);
+	}
+	const rows = [];
+	for (const [scenarioId, group] of grouped.entries()) {
+		if (group.length === 0) continue;
+		const scored = [];
+		for (const line of group) {
+			const reward = trainableLineReward(line);
+			if (reward === null) continue;
+			scored.push({
+				line,
+				reward
+			});
+		}
+		if (scored.length < 2) continue;
+		const prompts = await Promise.all(scored.map(({ line }) => Promise.resolve(lookups.promptOf(line.run_id))));
+		const prompt = prompts[0];
+		if (prompts.some((value) => value !== prompt)) throw new Error(`toGrpoRows: scenario "${scenarioId}" resolves to different prompt text within one group`);
+		const completions = await Promise.all(scored.map(({ line }) => Promise.resolve(lookups.completionOf(line.run_id))));
+		const rewards = scored.map(({ reward }) => reward);
+		const runIds = scored.map(({ line }) => line.run_id);
+		rows.push({
+			prompt,
+			completions,
+			rewards,
+			runIds,
+			meta: {
+				scenarioId,
+				n: completions.length,
+				meanReward: rewards.reduce((s, x) => s + x, 0) / rewards.length
+			}
+		});
+	}
+	return rows;
 }
 function toGrpoJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-async function toSftRows(runs, lookups) {
-  const include = lookups.include ?? (() => true);
-  const rows = [];
-  for (const r of runs) {
-    const score = runTaskScore(r);
-    if (!isTrainingRunEligible(r, score, lookups)) continue;
-    if (!include(r)) continue;
-    const system = lookups.systemOf?.(r);
-    const [prompt, completion] = await Promise.all([
-      Promise.resolve(lookups.promptOf(r.runId)),
-      Promise.resolve(lookups.completionOf(r.runId))
-    ]);
-    const messages = [];
-    if (system) messages.push({ role: "system", content: system });
-    messages.push({ role: "user", content: prompt });
-    messages.push({ role: "assistant", content: completion });
-    rows.push({
-      messages,
-      meta: {
-        runId: r.runId,
-        candidateId: r.candidateId,
-        scenarioId: r.scenarioId,
-        score,
-        model: r.model
-      }
-    });
-  }
-  return rows;
+	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
+}
+/**
+* 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.
+*/
+async function toSftRows(lines, lookups) {
+	return sftRowsFromLines(lines, lookups);
+}
+async function sftRowsFromLines(lines, lookups) {
+	const include = lookups.include ?? (() => true);
+	const minimumQualityExclusive = lookups.minimumQualityExclusive ?? 0;
+	if (!Number.isFinite(minimumQualityExclusive)) throw new Error("minimumQualityExclusive must be finite");
+	const rows = [];
+	for (const line of lines) {
+		assertRewardGate(line, "SFT export");
+		if (isLineRealnessGated(line)) continue;
+		if (!isSelectedSplit(line, lookups)) continue;
+		const score = trainableLineReward(line);
+		if (score === null || score <= minimumQualityExclusive) continue;
+		if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) continue;
+		if (!include(line)) continue;
+		const system = lookups.systemOf?.(line);
+		const [prompt, completion] = await Promise.all([Promise.resolve(lookups.promptOf(line.run_id)), Promise.resolve(lookups.completionOf(line.run_id))]);
+		const messages = [];
+		if (system) messages.push({
+			role: "system",
+			content: system
+		});
+		messages.push({
+			role: "user",
+			content: prompt
+		});
+		messages.push({
+			role: "assistant",
+			content: completion
+		});
+		rows.push({
+			messages,
+			meta: {
+				runId: line.run_id,
+				candidateId: line.candidate_id ?? null,
+				scenarioId: line.task.instance_id,
+				score,
+				model: line.policy.model
+			}
+		});
+	}
+	return rows;
 }
 function toSftJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-async function toPrmRows(triples, lookups) {
-  const rows = [];
-  for (const t of triples) {
-    const prompt = await Promise.resolve(lookups.promptOf(t.prefixRunId));
-    const prefixSpanIds = lookups.prefixOf ? await Promise.resolve(lookups.prefixOf(t.prefixRunId, t.prefixStepIndex)) : [];
-    const prefixStepText = [];
-    for (const spanId of prefixSpanIds) {
-      prefixStepText.push(await Promise.resolve(lookups.stepTextOf(t.prefixRunId, spanId)));
-    }
-    const chosenStep = await Promise.resolve(lookups.stepTextOf(t.prefixRunId, t.chosenSpanId));
-    const rejectedStep = await Promise.resolve(
-      lookups.stepTextOf(t.rejectedRunId, t.rejectedSpanId)
-    );
-    rows.push({
-      prompt,
-      prefixSpanIds,
-      prefixStepText,
-      chosenStep,
-      rejectedStep,
-      chosenReward: t.chosenReward,
-      rejectedReward: t.rejectedReward,
-      marginScore: t.marginScore,
-      meta: {
-        prefixRunId: t.prefixRunId,
-        rejectedRunId: t.rejectedRunId,
-        prefixStepIndex: t.prefixStepIndex
-      }
-    });
-  }
-  return rows;
+	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
+}
+/**
+* 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.
+*/
+async function toPrmRows(triples, lookups, context) {
+	const admitted = admitPrmTriples(triples, context);
+	const rows = [];
+	for (const t of admitted) {
+		const prompt = await Promise.resolve(lookups.promptOf(t.prefixRunId));
+		const prefixSpanIds = lookups.prefixOf ? await Promise.resolve(lookups.prefixOf(t.prefixRunId, t.prefixStepIndex)) : [];
+		const prefixStepText = [];
+		for (const spanId of prefixSpanIds) prefixStepText.push(await Promise.resolve(lookups.stepTextOf(t.prefixRunId, spanId)));
+		const chosenStep = await Promise.resolve(lookups.stepTextOf(t.prefixRunId, t.chosenSpanId));
+		const rejectedStep = await Promise.resolve(lookups.stepTextOf(t.rejectedRunId, t.rejectedSpanId));
+		rows.push({
+			prompt,
+			prefixSpanIds,
+			prefixStepText,
+			chosenStep,
+			rejectedStep,
+			chosenReward: t.chosenReward,
+			rejectedReward: t.rejectedReward,
+			marginScore: t.marginScore,
+			meta: {
+				prefixRunId: t.prefixRunId,
+				rejectedRunId: t.rejectedRunId,
+				prefixStepIndex: t.prefixStepIndex
+			}
+		});
+	}
+	return rows;
+}
+/**
+* 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.
+*/
+function assertPrmTrainableLine(line, mintedWithMaxSteps) {
+	const id = line.rollout_id;
+	if (line.provenance.gap !== void 0) throw new Error(`PRM export: rollout ${id} is a gap line (${line.provenance.gap}) — refusing to build a process-reward row from a trajectory that was never captured`);
+	if (line.steps === void 0 || line.steps.length === 0) throw new Error(`PRM export: rollout ${id} carries no steps — refusing to build a process-reward row with no trajectory`);
+	if (line.outcome.is_truncated) throw new Error(`PRM export: rollout ${id} is marked truncated — refusing to assign step-level credit over a partial trajectory`);
+	if (mintedWithMaxSteps !== void 0 && line.steps.length >= mintedWithMaxSteps) throw new Error(`PRM export: rollout ${id} has ${line.steps.length} steps at the mint cap of ${mintedWithMaxSteps} — its middle steps may have been dropped, and a capped trajectory carries no marker to prove otherwise`);
+}
+const PRM_CONTEXT_REQUIREMENT = {
+	exporter: "PRM export",
+	contextType: "PrmLineContext",
+	because: "without the minted rollout lines this exporter cannot see the realness gate (a triple carries only a bare reward number) and cannot tell a fully-captured trajectory from a capped or empty one."
+};
+/**
+* Validate every referenced line up front (fail loud, before a single row is
+* written) and then drop the triples whose evidence is realness-gated.
+*
+* The gate half is `admitUngatedByInvocation`, shared with `toDpoRows` and
+* `stepRewardsToJsonl`; only the trajectory-completeness rules are PRM's own.
+*/
+function admitPrmTriples(triples, context) {
+	return admitUngatedByInvocation(triples, (t) => [t.prefixRunId, t.rejectedRunId], context, PRM_CONTEXT_REQUIREMENT, (line) => assertPrmTrainableLine(line, context.mintedWithMaxSteps));
 }
 function toPrmJsonl(rows) {
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-function stepRewardsToJsonl(stepRewards) {
-  const rows = stepRewards.map((s) => ({
-    runId: s.runId,
-    spanId: s.spanId,
-    stepIndex: s.stepIndex,
-    reward: s.reward,
-    determinism: s.determinism,
-    weight: s.weight ?? 1
-  }));
-  return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
-}
-function defaultReward(run) {
-  return runTaskScore(run) ?? null;
-}
-function isTrainingRunEligible(run, quality, options = {}) {
-  const minimumQualityExclusive = options.minimumQualityExclusive ?? 0;
-  if (!Number.isFinite(minimumQualityExclusive)) {
-    throw new Error("minimumQualityExclusive must be finite");
-  }
-  if (quality === null || quality === void 0) return false;
-  if (!Number.isFinite(quality)) {
-    throw new Error(`training quality for run "${run.runId}" must be finite`);
-  }
-  if (quality <= minimumQualityExclusive) return false;
-  if (run.terminalOutcome !== "succeeded") return false;
-  if (run.failureClass !== void 0 || run.terminalFailureReason !== void 0) return false;
-  if (run.outcome.realness?.gated === true) return false;
-  if (run.splitTag === "search") return true;
-  return run.splitTag === "holdout" && options.allowHeldOutTrainingData === true;
+	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
 }
-
-// src/rl/dataset.ts
-var DATASET_FORMATS = ["grpo", "sft", "dpo"];
-var DATASET_FORMAT_SET = new Set(DATASET_FORMATS);
+const STEP_REWARD_CONTEXT_REQUIREMENT = {
+	exporter: "step-reward export",
+	contextType: "RolloutLineContext",
+	because: "a StepReward carries a runId and a bare per-step reward, and nothing that says whether that run faked its success — so without the minted rollout lines this exporter ships the step-level components of a gamed run at full value while the run-level scalar sits at 0 elsewhere."
+};
+/**
+* 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".
+*/
+function stepRewardsToJsonl(stepRewards, context) {
+	const rows = admitUngatedByInvocation(stepRewards, (s) => [s.runId], context, STEP_REWARD_CONTEXT_REQUIREMENT).map((s) => ({
+		runId: s.runId,
+		spanId: s.spanId,
+		stepIndex: s.stepIndex,
+		reward: s.reward,
+		determinism: s.determinism,
+		weight: s.weight ?? 1
+	}));
+	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
+}
+function isSelectedSplit(line, options) {
+	if (options.splitFilter !== void 0) return options.splitFilter.includes(line.task.split);
+	return isSplitEligible(line, options);
+}
+//#endregion
+//#region src/rl/dataset.ts
+const DATASET_FORMAT_SET = /* @__PURE__ */ new Set([
+	"grpo",
+	"sft",
+	"dpo"
+]);
 function validateDatasetFormats(value) {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error("buildRlDataset: formats must contain at least one of: grpo, sft, dpo");
-  }
-  const formats = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const format of value) {
-    if (!DATASET_FORMAT_SET.has(format)) {
-      throw new Error(
-        `buildRlDataset: unsupported format ${JSON.stringify(format)}; expected exactly one of: grpo, sft, dpo`
-      );
-    }
-    const datasetFormat = format;
-    if (seen.has(datasetFormat)) {
-      throw new Error(
-        `buildRlDataset: duplicate format ${JSON.stringify(datasetFormat)}; each format may be requested once`
-      );
-    }
-    seen.add(datasetFormat);
-    formats.push(datasetFormat);
-  }
-  return formats;
-}
-function reward(r, rewardOf2) {
-  const value = rewardOf2 ? rewardOf2(r) : runTaskScore(r) ?? null;
-  if (value !== null && !Number.isFinite(value)) {
-    throw new Error(`buildRlDataset: reward for run "${r.runId}" must be finite`);
-  }
-  return value;
+	if (!Array.isArray(value) || value.length === 0) throw new Error("buildRlDataset: formats must contain at least one of: grpo, sft, dpo");
+	const formats = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const format of value) {
+		if (!DATASET_FORMAT_SET.has(format)) throw new Error(`buildRlDataset: unsupported format ${JSON.stringify(format)}; expected exactly one of: grpo, sft, dpo`);
+		const datasetFormat = format;
+		if (seen.has(datasetFormat)) throw new Error(`buildRlDataset: duplicate format ${JSON.stringify(datasetFormat)}; each format may be requested once`);
+		seen.add(datasetFormat);
+		formats.push(datasetFormat);
+	}
+	return formats;
 }
 function distinct(xs) {
-  return [...new Set(xs)].sort();
+	return [...new Set(xs.filter((x) => typeof x === "string" && x.length > 0))].sort();
 }
 function computeRewardStats(values) {
-  if (values.length === 0) {
-    return { n: 0, mean: null, median: null, min: null, max: null, std: null };
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const n = sorted.length;
-  const mean = sorted.reduce((s, x) => s + x, 0) / n;
-  const mid = Math.floor(n / 2);
-  const median = n % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
-  const variance = sorted.reduce((s, x) => s + (x - mean) ** 2, 0) / n;
-  return { n, mean, median, min: sorted[0], max: sorted[n - 1], std: Math.sqrt(variance) };
-}
-function computeStats(records, rewardOf2) {
-  const splits = { search: 0, dev: 0, holdout: 0 };
-  let inTok = 0;
-  let outTok = 0;
-  let cost = 0;
-  const rewards = [];
-  for (const r of records) {
-    splits[r.splitTag] = (splits[r.splitTag] ?? 0) + 1;
-    inTok += r.tokenUsage.input;
-    outTok += r.tokenUsage.output;
-    cost += r.costUsd ?? 0;
-    const rw = reward(r, rewardOf2);
-    if (rw !== null) rewards.push(rw);
-  }
-  return {
-    records: records.length,
-    scoredRecords: rewards.length,
-    splits,
-    reward: computeRewardStats(rewards),
-    models: distinct(records.map((r) => r.model)),
-    promptHashes: distinct(records.map((r) => r.promptHash)),
-    commitShas: distinct(records.map((r) => r.commitSha)),
-    totalTokens: { input: inTok, output: outTok },
-    totalCostUsd: cost
-  };
-}
-async function buildRlDataset(records, lookups, config, preferences) {
-  if (records.length === 0) {
-    throw new Error("buildRlDataset: no records \u2014 refusing to package an empty dataset");
-  }
-  const formats = validateDatasetFormats(config.formats === void 0 ? ["sft"] : config.formats);
-  const files = {};
-  const rowCounts = {};
-  if (formats.includes("grpo")) {
-    const rows = await toGrpoRows(records, lookups);
-    requireRows("grpo", rows.length);
-    files["train.grpo.jsonl"] = toGrpoJsonl(rows);
-    rowCounts.grpo = rows.length;
-  }
-  if (formats.includes("sft")) {
-    const rows = await toSftRows(records, lookups);
-    requireRows("sft", rows.length);
-    files["train.sft.jsonl"] = toSftJsonl(rows);
-    rowCounts.sft = rows.length;
-  }
-  if (formats.includes("dpo")) {
-    if (!preferences) {
-      throw new Error("buildRlDataset: format 'dpo' requires `preferences` (triples + lookups)");
-    }
-    const rows = await toDpoRows(preferences.triples, preferences.lookups);
-    requireRows("dpo", rows.length);
-    files["train.dpo.jsonl"] = toDpoJsonl(rows);
-    rowCounts.dpo = rows.length;
-  }
-  if (!Object.keys(files).some((name) => name.startsWith("train.") && name.endsWith(".jsonl"))) {
-    throw new Error("buildRlDataset: no trainer file was emitted");
-  }
-  const manifest = {
-    ...config,
-    formats,
-    rowCounts,
-    stats: computeStats(records, lookups.rewardOf)
-  };
-  files["manifest.json"] = `${JSON.stringify(manifest, null, 2)}
-`;
-  files["DATASHEET.md"] = datasheetToMarkdown(manifest);
-  return { manifest, files };
+	if (values.length === 0) return {
+		n: 0,
+		mean: null,
+		median: null,
+		min: null,
+		max: null,
+		std: null
+	};
+	const sorted = [...values].sort((a, b) => a - b);
+	const n = sorted.length;
+	const mean = sorted.reduce((s, x) => s + x, 0) / n;
+	const mid = Math.floor(n / 2);
+	const median = n % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+	const variance = sorted.reduce((s, x) => s + (x - mean) ** 2, 0) / n;
+	return {
+		n,
+		mean,
+		median,
+		min: sorted[0],
+		max: sorted[n - 1],
+		std: Math.sqrt(variance)
+	};
+}
+function computeStatsFromLines(lines) {
+	const splits = {
+		search: 0,
+		dev: 0,
+		holdout: 0,
+		canary: 0
+	};
+	let inTok = 0;
+	let outTok = 0;
+	let cost = 0;
+	let rolloutsWithoutCost = 0;
+	const rewards = [];
+	for (const line of lines) {
+		splits[line.task.split] += 1;
+		inTok += line.cost.tokens_in ?? 0;
+		outTok += line.cost.tokens_out ?? 0;
+		if (line.cost.usd === null) rolloutsWithoutCost++;
+		else cost += line.cost.usd;
+		const rw = trainableLineReward(line);
+		if (rw !== null) rewards.push(rw);
+	}
+	return {
+		records: lines.length,
+		scoredRecords: rewards.length,
+		splits,
+		reward: computeRewardStats(rewards),
+		models: distinct(lines.map((l) => l.policy.model)),
+		promptHashes: distinct(lines.map((l) => l.policy.prompt_hash)),
+		commitShas: distinct(lines.map((l) => l.policy.profile_commit)),
+		totalTokens: {
+			input: inTok,
+			output: outTok
+		},
+		totalCostUsd: cost,
+		rolloutsWithoutCost
+	};
+}
+/**
+* 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 lines directly via the supplied lookups. Throws on an empty corpus —
+* an empty dataset must never be published.
+*/
+async function buildRlDataset(lines, lookups, config, preferences) {
+	if (lines.length === 0) throw new Error("buildRlDataset: no rollout lines — refusing to package an empty dataset");
+	const formats = validateDatasetFormats(config.formats === void 0 ? ["sft"] : config.formats);
+	const files = {};
+	const rowCounts = {};
+	if (formats.includes("grpo")) {
+		const rows = await toGrpoRows(lines, lookups);
+		requireRows("grpo", rows.length);
+		files["train.grpo.jsonl"] = toGrpoJsonl(rows);
+		rowCounts.grpo = rows.length;
+	}
+	if (formats.includes("sft")) {
+		const rows = await toSftRows(lines, lookups);
+		requireRows("sft", rows.length);
+		files["train.sft.jsonl"] = toSftJsonl(rows);
+		rowCounts.sft = rows.length;
+	}
+	if (formats.includes("dpo")) {
+		if (!preferences) throw new Error("buildRlDataset: format 'dpo' requires `preferences` (triples + lookups)");
+		const rows = await toDpoRows(preferences.triples, preferences.lookups, { lines });
+		requireRows("dpo", rows.length);
+		files["train.dpo.jsonl"] = toDpoJsonl(rows);
+		rowCounts.dpo = rows.length;
+	}
+	if (!Object.keys(files).some((name) => name.startsWith("train.") && name.endsWith(".jsonl"))) throw new Error("buildRlDataset: no trainer file was emitted");
+	const manifest = {
+		...config,
+		formats,
+		rowCounts,
+		stats: computeStatsFromLines(lines)
+	};
+	files["manifest.json"] = `${JSON.stringify(manifest, null, 2)}\n`;
+	files["DATASHEET.md"] = datasheetToMarkdown(manifest);
+	return {
+		manifest,
+		files
+	};
 }
 function requireRows(format, rows) {
-  if (rows === 0) {
-    throw new Error(`buildRlDataset: requested '${format}' format produced no trainable rows`);
-  }
+	if (rows === 0) throw new Error(`buildRlDataset: requested '${format}' format produced no trainable rows`);
 }
 function pct(x) {
-  return `${(x * 100).toFixed(1)}%`;
+	return `${(x * 100).toFixed(1)}%`;
 }
 function stat(value) {
-  return value === null ? "n/a" : value.toFixed(3);
+	return value === null ? "n/a" : value.toFixed(3);
 }
+/** Render the "Datasheet for Datasets" card that a buyer reads. */
 function datasheetToMarkdown(m) {
-  const s = m.stats;
-  const total = s.records || 1;
-  const splitLines = ["search", "dev", "holdout"].map((k) => `  - \`${k}\`: ${s.splits[k]} (${pct(s.splits[k] / total)})`).join("\n");
-  const deterministic = m.reward.kind === "deterministic";
-  return [
-    `# Dataset: ${m.name} \`v${m.version}\``,
-    "",
-    `**Domain:** ${m.domain} | **Created:** ${m.createdAtIso} | **License:** ${m.license}`,
-    "",
-    "## Reward provenance",
-    `- **Kind:** ${m.reward.kind}${deterministic ? " (decidable, not judge noise)" : ""}`,
-    `- **Source:** ${m.reward.source}`,
-    `- **Description:** ${m.reward.description}`,
-    "",
-    "## Composition",
-    `- **Records (trajectories):** ${s.records}`,
-    `- **Scored records:** ${s.scoredRecords}`,
-    `- **Formats:** ${m.formats.map((f) => `${f} (${m.rowCounts[f] ?? 0} rows)`).join(", ")}`,
-    "- **Splits:**",
-    splitLines,
-    "",
-    "## Reward distribution",
-    `- n=${s.reward.n} | mean=${stat(s.reward.mean)} | median=${stat(s.reward.median)} | min=${stat(s.reward.min)} | max=${stat(s.reward.max)} | std=${stat(s.reward.std)}`,
-    "",
-    "## Provenance",
-    `- **Models:** ${s.models.join(", ")}`,
-    `- **Prompt/agent versions (sha256):** ${s.promptHashes.length} distinct`,
-    `- **Commits:** ${s.commitShas.join(", ")}`,
-    `- **Tokens:** ${s.totalTokens.input} in / ${s.totalTokens.output} out | **Cost:** $${s.totalCostUsd.toFixed(2)}`,
-    "",
-    "## Quality gates",
-    `- Contamination probe: ${m.qualityGates?.contaminationProbe ?? "not-run"}`,
-    `- Dedup: ${m.qualityGates?.dedup ? "yes" : "no"} | Verifiable-reward filter: ${m.qualityGates?.verifiableRewardFilter ? "yes" : "no"}`,
-    "",
-    "## Recommended uses",
-    m.intendedUse,
-    "",
-    "## Out of scope",
-    m.outOfScope,
-    "",
-    "## Limitations",
-    m.limitations,
-    "",
-    "## Token rendering",
-    "For RL/SFT training, tokenize with the per-model renderer (DeepSeek-V3 / Kimi-K2 / Qwen3) to preserve token identity and per-token loss masks across tool-call turns. See `renderers` (PrimeIntellect). The `messages` / `completions` here are the renderer input.",
-    ""
-  ].join("\n");
-}
-
-// src/rl/corpus.ts
+	const s = m.stats;
+	const total = s.records || 1;
+	const splitLines = [
+		"search",
+		"dev",
+		"holdout",
+		"canary"
+	].map((k) => `  - \`${k}\`: ${s.splits[k]} (${pct(s.splits[k] / total)})`).join("\n");
+	const costNote = s.rolloutsWithoutCost > 0 ? ` (floor — ${s.rolloutsWithoutCost} rollout(s) never captured a cost)` : "";
+	const deterministic = m.reward.kind === "deterministic";
+	return [
+		`# Dataset: ${m.name} \`v${m.version}\``,
+		"",
+		`**Domain:** ${m.domain} | **Created:** ${m.createdAtIso} | **License:** ${m.license}`,
+		"",
+		"## Reward provenance",
+		`- **Kind:** ${m.reward.kind}${deterministic ? " (decidable, not judge noise)" : ""}`,
+		`- **Source:** ${m.reward.source}`,
+		`- **Description:** ${m.reward.description}`,
+		"",
+		"## Composition",
+		`- **Records (trajectories):** ${s.records}`,
+		`- **Scored records:** ${s.scoredRecords}`,
+		`- **Formats:** ${m.formats.map((f) => `${f} (${m.rowCounts[f] ?? 0} rows)`).join(", ")}`,
+		"- **Splits:**",
+		splitLines,
+		"",
+		"## Reward distribution",
+		`- n=${s.reward.n} | mean=${stat(s.reward.mean)} | median=${stat(s.reward.median)} | min=${stat(s.reward.min)} | max=${stat(s.reward.max)} | std=${stat(s.reward.std)}`,
+		"",
+		"## Provenance",
+		`- **Models:** ${s.models.join(", ")}`,
+		`- **Prompt/agent versions (sha256):** ${s.promptHashes.length} distinct`,
+		`- **Commits:** ${s.commitShas.join(", ")}`,
+		`- **Tokens:** ${s.totalTokens.input} in / ${s.totalTokens.output} out | **Cost:** $${s.totalCostUsd.toFixed(2)}${costNote}`,
+		"",
+		"## Quality gates",
+		`- Contamination probe: ${m.qualityGates?.contaminationProbe ?? "not-run"}`,
+		`- Dedup: ${m.qualityGates?.dedup ? "yes" : "no"} | Verifiable-reward filter: ${m.qualityGates?.verifiableRewardFilter ? "yes" : "no"}`,
+		"",
+		"## Recommended uses",
+		m.intendedUse,
+		"",
+		"## Out of scope",
+		m.outOfScope,
+		"",
+		"## Limitations",
+		m.limitations,
+		"",
+		"## Token rendering",
+		"For RL/SFT training, tokenize with the per-model renderer (DeepSeek-V3 / Kimi-K2 / Qwen3) to preserve token identity and per-token loss masks across tool-call turns. See `renderers` (PrimeIntellect). The `messages` / `completions` here are the renderer input.",
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/rl/corpus.ts
+/**
+* RL corpus — the durable, append-only accumulation of graded RunRecords that
+* every eval run deposits BY DEFAULT.
+*
+* The dataset is the free exhaust of the normal eval process: we run evals
+* constantly to get an agent production-ready, and those runs already produce
+* graded trajectories. Instead of writing them to an ephemeral run dir and
+* throwing them away, `appendToCorpus` accumulates them into a durable corpus;
+* `buildDatasetFromCorpus` later harvests the whole corpus into a publishable
+* bundle. No separate data-collection campaign — the data accrues from work we
+* do anyway. This is the "best things for free by our process" layer.
+*
+* Trajectory text rides on the record as top-level `prompt` / `completion`
+* (what the eval harnesses capture; the RunRecord validator ignores the extra
+* keys). The harvest reads them directly — no trace store round-trip needed.
+*/
+/**
+* Append graded records to the corpus (append-only JSONL). Deduplicates by
+* `runId` against what's already on disk so re-running the same harness is
+* idempotent. Creates the file and parent dir. This is the call every eval
+* harness makes by default after producing its records.
+*/
 function appendToCorpus(records, corpusPath) {
-  mkdirSync(dirname(corpusPath), { recursive: true });
-  const existing = existsSync(corpusPath) ? readCorpus(corpusPath) : [];
-  const seen = new Set(existing.map((r) => r.runId));
-  const lines = [];
-  let appended = 0;
-  let skipped = 0;
-  for (const r of records) {
-    if (seen.has(r.runId)) {
-      skipped++;
-      continue;
-    }
-    seen.add(r.runId);
-    lines.push(JSON.stringify(r));
-    appended++;
-  }
-  if (lines.length > 0) appendFileSync(corpusPath, `${lines.join("\n")}
-`);
-  return { appended, skipped, total: existing.length + appended };
-}
+	mkdirSync(dirname(corpusPath), { recursive: true });
+	const existing = existsSync(corpusPath) ? readCorpus(corpusPath) : [];
+	const seen = new Set(existing.map((r) => r.runId));
+	const lines = [];
+	let appended = 0;
+	let skipped = 0;
+	for (const r of records) {
+		if (seen.has(r.runId)) {
+			skipped++;
+			continue;
+		}
+		seen.add(r.runId);
+		lines.push(JSON.stringify(r));
+		appended++;
+	}
+	if (lines.length > 0) appendFileSync(corpusPath, `${lines.join("\n")}\n`);
+	return {
+		appended,
+		skipped,
+		total: existing.length + appended
+	};
+}
+/** Read the full corpus. Returns [] if the corpus does not exist yet. */
 function readCorpus(corpusPath) {
-  if (!existsSync(corpusPath)) return [];
-  const out = [];
-  for (const line of readFileSync(corpusPath, "utf8").split("\n")) {
-    if (line.trim()) out.push(JSON.parse(line));
-  }
-  return out;
-}
+	if (!existsSync(corpusPath)) return [];
+	const out = [];
+	for (const line of readFileSync(corpusPath, "utf8").split("\n")) if (line.trim()) out.push(JSON.parse(line));
+	return out;
+}
+/**
+* The harvest's score reader is GATED: a gamed run reads 0, so it cannot buy
+* its way past `minScore` into the published bundle with its claimed score.
+* `null` = unscored (a labeled gap, dropped before packaging, never a 0).
+*/
 function rewardOf(r) {
-  return runTaskScore(r) ?? null;
-}
+	const v = trainingScore(r);
+	return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+/**
+* Harvest the accumulated corpus into a publishable RL dataset bundle. Reads
+* trajectory text from each record's top-level `prompt`/`completion`; records
+* 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.
+*/
 async function buildDatasetFromCorpus(corpusPath, config, opts = {}) {
-  let records = readCorpus(corpusPath).filter(
-    (r) => typeof r.prompt === "string" && typeof r.completion === "string"
-  );
-  if (opts.splits) records = records.filter((r) => opts.splits.includes(r.splitTag));
-  records = records.filter((r) => rewardOf(r) !== null);
-  if (opts.minScore != null) {
-    records = records.filter((r) => {
-      const reward2 = rewardOf(r);
-      return reward2 !== null && reward2 >= opts.minScore;
-    });
-  }
-  const text = new Map(
-    records.map((r) => [r.runId, { prompt: r.prompt, completion: r.completion }])
-  );
-  const lookups = {
-    promptOf: (id) => text.get(id)?.prompt ?? "",
-    completionOf: (id) => text.get(id)?.completion ?? "",
-    allowHeldOutTrainingData: opts.allowHeldOutTrainingData
-  };
-  return buildRlDataset(records, lookups, config);
-}
-
-// src/rl/predictive-validity-researcher.ts
+	let records = readCorpus(corpusPath).filter((r) => typeof r.prompt === "string" && typeof r.completion === "string");
+	if (opts.splits) records = records.filter((r) => opts.splits.includes(r.splitTag));
+	records = records.filter((r) => rewardOf(r) !== null);
+	if (opts.minScore != null) records = records.filter((r) => {
+		const reward = rewardOf(r);
+		return reward !== null && reward >= opts.minScore;
+	});
+	const text = new Map(records.map((r) => [r.runId, {
+		prompt: r.prompt,
+		completion: r.completion
+	}]));
+	const lookups = {
+		promptOf: (id) => text.get(id)?.prompt ?? "",
+		completionOf: (id) => text.get(id)?.completion ?? "",
+		allowHeldOutTrainingData: opts.allowHeldOutTrainingData
+	};
+	const { rows } = await mintRolloutRows(records, new InMemoryTraceStore());
+	return buildRlDataset(rows, lookups, config);
+}
+//#endregion
+//#region src/rl/predictive-validity-researcher.ts
+/**
+* Concrete `Researcher` driven by `rubricPredictiveValidity`. The brain:
+* rubrics that don't predict deployment outcomes don't earn weight.
+*/
 var PredictiveValidityResearcher = class {
-  opts;
-  lastReport = null;
-  constructor(opts) {
-    this.opts = opts;
-  }
-  async inspectFailures(runs) {
-    const threshold = this.opts.failureThreshold ?? 0.5;
-    const failures = [];
-    const failingRuns = runs.filter((r) => {
-      const score = runTaskScore(r);
-      return typeof score === "number" && score < threshold;
-    });
-    if (failingRuns.length === 0) return failures;
-    const grouped = /* @__PURE__ */ new Map();
-    for (const r of failingRuns) {
-      const arr = grouped.get(r.candidateId) ?? [];
-      arr.push(r);
-      grouped.set(r.candidateId, arr);
-    }
-    for (const [candidateId, group] of grouped.entries()) {
-      const meanScore = group.reduce((s, r) => {
-        const score = runTaskScore(r);
-        if (score === void 0) {
-          throw new Error(`failing run ${r.runId} unexpectedly has no task score`);
-        }
-        return s + score;
-      }, 0) / group.length;
-      failures.push({
-        code: `low-score-${candidateId}`,
-        description: `${candidateId} scored < ${threshold} on ${group.length} run(s) (mean ${meanScore.toFixed(3)})`,
-        evidence: {
-          runIds: group.slice(0, 8).map((r) => r.runId),
-          samples: group.length
-        }
-      });
-    }
-    return failures;
-  }
-  async proposeChange(failures) {
-    if (failures.length === 0) return [];
-    if (this.lastReport === null) {
-      return [
-        {
-          kind: "threshold",
-          payload: { directive: "researcher.collect-more-outcomes" },
-          rationale: "predictive-validity researcher has no prior report; cannot recommend rubric reweighting until at least one report exists"
-        }
-      ];
-    }
-    const decorativeThreshold = this.opts.decorativeThreshold ?? 0.4;
-    const changes = [];
-    for (const ranking of this.lastReport.ranked) {
-      if (ranking.verdict === "load_bearing") continue;
-      if (Math.abs(ranking.spearman) >= decorativeThreshold) continue;
-      changes.push({
-        kind: "reviewer_prompt",
-        payload: {
-          rubric: ranking.rubric,
-          action: "down-weight",
-          spearman: ranking.spearman,
-          bestOutcome: ranking.bestOutcome
-        },
-        rationale: `predictive-validity Spearman=${ranking.spearman.toFixed(3)} vs ${ranking.bestOutcome} (decorative); recommend down-weighting`,
-        expectedDelta: -Math.max(0, 0.05 - Math.abs(ranking.spearman))
-      });
-    }
-    for (const ranking of this.lastReport.ranked.slice(0, 1)) {
-      if (ranking.verdict !== "load_bearing") continue;
-      changes.push({
-        kind: "reviewer_prompt",
-        payload: {
-          rubric: ranking.rubric,
-          action: "up-weight",
-          spearman: ranking.spearman,
-          bestOutcome: ranking.bestOutcome
-        },
-        rationale: `predictive-validity Spearman=${ranking.spearman.toFixed(3)} vs ${ranking.bestOutcome} (load-bearing); recommend up-weighting`,
-        expectedDelta: Math.max(0, Math.abs(ranking.spearman) - 0.5) * 0.1
-      });
-    }
-    return changes;
-  }
-  async applyChange(changes, baseline) {
-    return {
-      ...baseline,
-      changes: [...baseline.changes, ...changes]
-    };
-  }
-  async evaluateChange(plan) {
-    const emptyGate = {
-      promote: false,
-      candidateId: plan.proposedCandidateId,
-      baselineId: plan.baselineCandidateId,
-      evidence: {
-        productiveRuns: 0,
-        unpairedCandidateRuns: 0,
-        unpairedBaselineRuns: 0,
-        medianPairedDelta: null,
-        pairedCI: null,
-        pairedPValue: null,
-        searchScore: null,
-        holdoutScore: null,
-        overfitGap: null,
-        baselineOverfitGap: null,
-        medianCandidateCost: null,
-        medianBaselineCost: null
-      },
-      reason: "predictive-validity researcher does not execute plans; the caller is expected to run the sweep and call rubricPredictiveValidity directly with the resulting RunRecord[].",
-      rejectionCode: "few_runs"
-    };
-    return {
-      plan,
-      runs: [],
-      gateDecision: emptyGate
-    };
-  }
-  /**
-   * Run the predictive-validity check explicitly against a fresh RunRecord
-   * set. Updates the researcher's cached report so subsequent
-   * `proposeChange` calls have evidence to draw from.
-   */
-  async runValidityCheck(runs) {
-    const report = await rubricPredictiveValidity({
-      runs,
-      outcomes: this.opts.outcomes,
-      outcomeMetrics: this.opts.outcomeMetrics,
-      rubrics: this.opts.rubrics
-    });
-    if (this.opts.onReport) await this.opts.onReport(report);
-    this.lastReport = report;
-    return report;
-  }
-  /**
-   * Force-feed a predictive-validity report into the researcher state —
-   * useful when the consumer ran the report out-of-band and wants the
-   * researcher's later proposals informed by it.
-   */
-  setReport(report) {
-    this.lastReport = report;
-  }
-  getLastReport() {
-    return this.lastReport;
-  }
+	opts;
+	lastReport = null;
+	constructor(opts) {
+		this.opts = opts;
+	}
+	async inspectFailures(runs) {
+		const threshold = this.opts.failureThreshold ?? .5;
+		const failures = [];
+		const failingRuns = runs.filter((r) => {
+			const score = runTaskScore(r);
+			return typeof score === "number" && score < threshold;
+		});
+		if (failingRuns.length === 0) return failures;
+		const grouped = /* @__PURE__ */ new Map();
+		for (const r of failingRuns) {
+			const arr = grouped.get(r.candidateId) ?? [];
+			arr.push(r);
+			grouped.set(r.candidateId, arr);
+		}
+		for (const [candidateId, group] of grouped.entries()) {
+			const meanScore = group.reduce((s, r) => {
+				const score = runTaskScore(r);
+				if (score === void 0) throw new Error(`failing run ${r.runId} unexpectedly has no task score`);
+				return s + score;
+			}, 0) / group.length;
+			failures.push({
+				code: `low-score-${candidateId}`,
+				description: `${candidateId} scored < ${threshold} on ${group.length} run(s) (mean ${meanScore.toFixed(3)})`,
+				evidence: {
+					runIds: group.slice(0, 8).map((r) => r.runId),
+					samples: group.length
+				}
+			});
+		}
+		return failures;
+	}
+	async proposeChange(failures) {
+		if (failures.length === 0) return [];
+		if (this.lastReport === null) return [{
+			kind: "threshold",
+			payload: { directive: "researcher.collect-more-outcomes" },
+			rationale: "predictive-validity researcher has no prior report; cannot recommend rubric reweighting until at least one report exists"
+		}];
+		const decorativeThreshold = this.opts.decorativeThreshold ?? .4;
+		const changes = [];
+		for (const ranking of this.lastReport.ranked) {
+			if (ranking.verdict === "load_bearing") continue;
+			if (Math.abs(ranking.spearman) >= decorativeThreshold) continue;
+			changes.push({
+				kind: "reviewer_prompt",
+				payload: {
+					rubric: ranking.rubric,
+					action: "down-weight",
+					spearman: ranking.spearman,
+					bestOutcome: ranking.bestOutcome
+				},
+				rationale: `predictive-validity Spearman=${ranking.spearman.toFixed(3)} vs ${ranking.bestOutcome} (decorative); recommend down-weighting`,
+				expectedDelta: -Math.max(0, .05 - Math.abs(ranking.spearman))
+			});
+		}
+		for (const ranking of this.lastReport.ranked.slice(0, 1)) {
+			if (ranking.verdict !== "load_bearing") continue;
+			changes.push({
+				kind: "reviewer_prompt",
+				payload: {
+					rubric: ranking.rubric,
+					action: "up-weight",
+					spearman: ranking.spearman,
+					bestOutcome: ranking.bestOutcome
+				},
+				rationale: `predictive-validity Spearman=${ranking.spearman.toFixed(3)} vs ${ranking.bestOutcome} (load-bearing); recommend up-weighting`,
+				expectedDelta: Math.max(0, Math.abs(ranking.spearman) - .5) * .1
+			});
+		}
+		return changes;
+	}
+	async applyChange(changes, baseline) {
+		return {
+			...baseline,
+			changes: [...baseline.changes, ...changes]
+		};
+	}
+	async evaluateChange(plan) {
+		return {
+			plan,
+			runs: [],
+			gateDecision: {
+				promote: false,
+				candidateId: plan.proposedCandidateId,
+				baselineId: plan.baselineCandidateId,
+				evidence: {
+					productiveRuns: 0,
+					unpairedCandidateRuns: 0,
+					unpairedBaselineRuns: 0,
+					medianPairedDelta: null,
+					pairedCI: null,
+					pairedPValue: null,
+					searchScore: null,
+					holdoutScore: null,
+					overfitGap: null,
+					baselineOverfitGap: null,
+					medianCandidateCost: null,
+					medianBaselineCost: null,
+					realnessGatedRuns: 0
+				},
+				reason: "predictive-validity researcher does not execute plans; the caller is expected to run the sweep and call rubricPredictiveValidity directly with the resulting RunRecord[].",
+				rejectionCode: "few_runs"
+			}
+		};
+	}
+	/**
+	* Run the predictive-validity check explicitly against a fresh RunRecord
+	* set. Updates the researcher's cached report so subsequent
+	* `proposeChange` calls have evidence to draw from.
+	*/
+	async runValidityCheck(runs) {
+		const report = await rubricPredictiveValidity({
+			runs,
+			outcomes: this.opts.outcomes,
+			outcomeMetrics: this.opts.outcomeMetrics,
+			rubrics: this.opts.rubrics
+		});
+		if (this.opts.onReport) await this.opts.onReport(report);
+		this.lastReport = report;
+		return report;
+	}
+	/**
+	* Force-feed a predictive-validity report into the researcher state —
+	* useful when the consumer ran the report out-of-band and wants the
+	* researcher's later proposals informed by it.
+	*/
+	setReport(report) {
+		this.lastReport = report;
+	}
+	getLastReport() {
+		return this.lastReport;
+	}
 };
-
-// src/rl/preferences.ts
-var DEFAULT_REWARD = (run) => {
-  return runTaskScore(run) ?? null;
+//#endregion
+//#region src/rl/preferences.ts
+/** The split each path pairs by default: training data comes from search. */
+const SPLIT_DEFAULT = "search";
+/**
+* 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. 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`.
+*/
+function extractPreferences(lines, opts = {}) {
+	const strategy = opts.strategy ?? "paired-by-scenario-and-seed";
+	const minMargin = opts.minMargin ?? .05;
+	const requestedSplit = opts.split;
+	if (requestedSplit === "holdout" && opts.allowHeldOutTrainingData !== true) throw new Error("extractPreferences: split \"holdout\" requires allowHeldOutTrainingData: true");
+	if (requestedSplit === "dev" || requestedSplit === "canary") throw new Error(`extractPreferences: split "${requestedSplit}" is evaluation-only; train from "search"`);
+	const candidates = candidatesFromLines(lines, opts);
+	return {
+		...pairCandidates(candidates.rows, strategy, minMargin),
+		linesWithoutCandidateId: candidates.withoutCandidateId
+	};
+}
+function candidatesFromLines(lines, opts) {
+	const split = opts.split ?? SPLIT_DEFAULT;
+	const rows = [];
+	let withoutCandidateId = 0;
+	for (const line of lines) {
+		if (line.task.split !== split) continue;
+		if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) continue;
+		const score = trainableLineReward(line);
+		if (score === null) continue;
+		const candidateId = line.candidate_id;
+		if (candidateId === null || candidateId === void 0 || candidateId.length === 0) {
+			withoutCandidateId++;
+			continue;
+		}
+		rows.push({
+			scenarioId: line.task.instance_id,
+			runId: line.run_id,
+			candidateId,
+			seed: line.task.seed,
+			score,
+			promptHash: line.policy.prompt_hash ?? "",
+			configHash: line.policy.config_hash ?? "",
+			model: line.policy.model ?? ""
+		});
+	}
+	return {
+		rows,
+		withoutCandidateId
+	};
+}
+function pairCandidates(scoredEntries, strategy, minMargin) {
+	const pairs = [];
+	let pairsBelowMargin = 0;
+	let cellsSingleton = 0;
+	let cellsInspected = 0;
+	if (strategy === "paired-by-scenario-and-seed") {
+		const groups = /* @__PURE__ */ new Map();
+		for (const e of scoredEntries) {
+			const key = `${e.scenarioId}::${e.seed}`;
+			const arr = groups.get(key) ?? [];
+			arr.push(e);
+			groups.set(key, arr);
+		}
+		for (const members of groups.values()) {
+			cellsInspected++;
+			if (members.length < 2) {
+				cellsSingleton++;
+				continue;
+			}
+			for (let i = 0; i < members.length; i++) for (let j = i + 1; j < members.length; j++) {
+				const a = members[i];
+				const b = members[j];
+				if (a.candidateId === b.candidateId) continue;
+				const result = makePair(a, b, a.scenarioId, minMargin);
+				if (result.kind === "admit") pairs.push(result.pair);
+				else pairsBelowMargin++;
+			}
+		}
+	} else if (strategy === "paired-by-scenario") {
+		const byScenarioVariant = /* @__PURE__ */ new Map();
+		for (const e of scoredEntries) {
+			let perScenario = byScenarioVariant.get(e.scenarioId);
+			if (!perScenario) {
+				perScenario = /* @__PURE__ */ new Map();
+				byScenarioVariant.set(e.scenarioId, perScenario);
+			}
+			const cur = perScenario.get(e.candidateId);
+			if (cur) {
+				cur.sum += e.score;
+				cur.n++;
+			} else perScenario.set(e.candidateId, {
+				entry: e,
+				sum: e.score,
+				n: 1
+			});
+		}
+		for (const [sid, perVariant] of byScenarioVariant.entries()) {
+			cellsInspected++;
+			const arr = [...perVariant.values()].map((agg) => ({
+				...agg.entry,
+				score: agg.sum / agg.n
+			}));
+			if (arr.length < 2) {
+				cellsSingleton++;
+				continue;
+			}
+			for (let i = 0; i < arr.length; i++) for (let j = i + 1; j < arr.length; j++) {
+				const result = makePair(arr[i], arr[j], sid, minMargin);
+				if (result.kind === "admit") pairs.push(result.pair);
+				else pairsBelowMargin++;
+			}
+		}
+	} else {
+		const byScenario = /* @__PURE__ */ new Map();
+		for (const e of scoredEntries) {
+			const arr = byScenario.get(e.scenarioId) ?? [];
+			arr.push(e);
+			byScenario.set(e.scenarioId, arr);
+		}
+		for (const [sid, arr] of byScenario.entries()) {
+			cellsInspected++;
+			if (arr.length < 2) {
+				cellsSingleton++;
+				continue;
+			}
+			const sorted = [...arr].sort((a, b) => a.score - b.score);
+			const top = sorted[sorted.length - 1];
+			const bot = sorted[0];
+			if (top.candidateId === bot.candidateId) {
+				cellsSingleton++;
+				continue;
+			}
+			const result = makePair(bot, top, sid, minMargin);
+			if (result.kind === "admit") pairs.push(result.pair);
+			else pairsBelowMargin++;
+		}
+	}
+	return {
+		pairs,
+		cellsInspected,
+		pairsBelowMargin,
+		cellsSingleton,
+		strategy
+	};
+}
+const PREFERENCE_RUN_IDS = (t) => [t.chosenRunId, t.rejectedRunId];
+const TRL_CONTEXT_REQUIREMENT = {
+	exporter: "TRL preference export",
+	contextType: "RolloutLineContext",
+	because: "a PreferenceTriple carries only run ids and hashes, so without the minted rollout lines this exporter cannot see the realness gate and will put a run that faked its success on the CHOSEN side of a DPO pair."
+};
+const ANTHROPIC_CONTEXT_REQUIREMENT = {
+	exporter: "Anthropic preference export",
+	contextType: "RolloutLineContext",
+	because: "a PreferenceTriple carries only run ids and a bare margin, so without the minted rollout lines this exporter cannot see the realness gate and will name a run that faked its success as the preferred one."
 };
-function extractPreferences(runs, opts = {}) {
-  const strategy = opts.strategy ?? "paired-by-scenario-and-seed";
-  const minMargin = opts.minMargin ?? 0.05;
-  const splitTag = opts.splitTag;
-  const rewardOf2 = opts.rewardOf ?? DEFAULT_REWARD;
-  if (splitTag === "holdout" && opts.allowHeldOutTrainingData !== true) {
-    throw new Error(
-      'extractPreferences: splitTag "holdout" requires allowHeldOutTrainingData: true'
-    );
-  }
-  if (splitTag === "dev") {
-    throw new Error('extractPreferences: splitTag "dev" is evaluation-only; train from "search"');
-  }
-  const scoredEntries = [];
-  for (const run of runs) {
-    if (splitTag !== void 0 && run.splitTag !== splitTag) continue;
-    const s = rewardOf2(run);
-    if (!isTrainingRunEligible(run, s, opts)) continue;
-    scoredEntries.push({ run, score: s });
-  }
-  const pairs = [];
-  let pairsBelowMargin = 0;
-  let cellsSingleton = 0;
-  let cellsInspected = 0;
-  if (strategy === "paired-by-scenario-and-seed") {
-    const groups = /* @__PURE__ */ new Map();
-    for (const e of scoredEntries) {
-      const sid = scenarioOf(e.run);
-      const key = `${sid}::${e.run.seed}`;
-      const arr = groups.get(key) ?? [];
-      arr.push(e);
-      groups.set(key, arr);
-    }
-    for (const [key, members] of groups.entries()) {
-      cellsInspected++;
-      if (members.length < 2) {
-        cellsSingleton++;
-        continue;
-      }
-      for (let i = 0; i < members.length; i++) {
-        for (let j = i + 1; j < members.length; j++) {
-          const a = members[i];
-          const b = members[j];
-          if (a.run.candidateId === b.run.candidateId) continue;
-          const result = makePair(a, b, key.split("::")[0], minMargin);
-          if (result.kind === "admit") pairs.push(result.pair);
-          else pairsBelowMargin++;
-        }
-      }
-    }
-  } else if (strategy === "paired-by-scenario") {
-    const byScenarioVariant = /* @__PURE__ */ new Map();
-    for (const e of scoredEntries) {
-      const sid = scenarioOf(e.run);
-      let perScenario = byScenarioVariant.get(sid);
-      if (!perScenario) {
-        perScenario = /* @__PURE__ */ new Map();
-        byScenarioVariant.set(sid, perScenario);
-      }
-      const cur = perScenario.get(e.run.candidateId);
-      if (cur) {
-        cur.sum += e.score;
-        cur.n++;
-      } else perScenario.set(e.run.candidateId, { run: e.run, sum: e.score, n: 1 });
-    }
-    for (const [sid, perVariant] of byScenarioVariant.entries()) {
-      cellsInspected++;
-      const arr = [...perVariant.entries()].map(([vid, agg]) => ({
-        run: agg.run,
-        score: agg.sum / agg.n,
-        variantId: vid
-      }));
-      if (arr.length < 2) {
-        cellsSingleton++;
-        continue;
-      }
-      for (let i = 0; i < arr.length; i++) {
-        for (let j = i + 1; j < arr.length; j++) {
-          const result = makePair(arr[i], arr[j], sid, minMargin);
-          if (result.kind === "admit") pairs.push(result.pair);
-          else pairsBelowMargin++;
-        }
-      }
-    }
-  } else {
-    const byScenario = /* @__PURE__ */ new Map();
-    for (const e of scoredEntries) {
-      const sid = scenarioOf(e.run);
-      const arr = byScenario.get(sid) ?? [];
-      arr.push(e);
-      byScenario.set(sid, arr);
-    }
-    for (const [sid, arr] of byScenario.entries()) {
-      cellsInspected++;
-      if (arr.length < 2) {
-        cellsSingleton++;
-        continue;
-      }
-      const sorted = [...arr].sort((a, b) => a.score - b.score);
-      const top = sorted[sorted.length - 1];
-      const bot = sorted[0];
-      if (top.run.candidateId === bot.run.candidateId) {
-        cellsSingleton++;
-        continue;
-      }
-      const result = makePair(bot, top, sid, minMargin);
-      if (result.kind === "admit") pairs.push(result.pair);
-      else pairsBelowMargin++;
-    }
-  }
-  return { pairs, cellsInspected, pairsBelowMargin, cellsSingleton, strategy };
-}
-function toAnthropicFormat(triples) {
-  return triples.map((t) => ({
-    scenarioId: t.scenarioId,
-    chosenRunId: t.chosenRunId,
-    rejectedRunId: t.rejectedRunId,
-    margin: t.marginScore
-  }));
+/**
+* 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.
+*/
+async function toTRLFormat(triples, lookups, context) {
+	const admitted = admitUngatedByInvocation(triples, PREFERENCE_RUN_IDS, context, TRL_CONTEXT_REQUIREMENT);
+	const out = [];
+	for (const t of admitted) {
+		const [chosenPrompt, rejectedPrompt, chosen, rejected] = await Promise.all([
+			Promise.resolve(lookups.promptOf(t.chosenRunId)),
+			Promise.resolve(lookups.promptOf(t.rejectedRunId)),
+			Promise.resolve(lookups.completionOf(t.chosenRunId)),
+			Promise.resolve(lookups.completionOf(t.rejectedRunId))
+		]);
+		if (chosenPrompt !== rejectedPrompt) throw new Error(`toTRLFormat: preference "${t.chosenRunId}"/"${t.rejectedRunId}" resolves to different prompts`);
+		out.push({
+			prompt: chosenPrompt,
+			chosen,
+			rejected
+		});
+	}
+	return out;
+}
+/**
+* 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.
+*/
+function toAnthropicFormat(triples, context) {
+	return admitUngatedByInvocation(triples, PREFERENCE_RUN_IDS, context, ANTHROPIC_CONTEXT_REQUIREMENT).map((t) => ({
+		scenarioId: t.scenarioId,
+		chosenRunId: t.chosenRunId,
+		rejectedRunId: t.rejectedRunId,
+		margin: t.marginScore
+	}));
 }
 function makePair(a, b, scenarioId, minMargin) {
-  const margin = Math.abs(a.score - b.score);
-  if (margin < minMargin) return { kind: "reject" };
-  const [chosen, rejected] = a.score > b.score ? [a, b] : [b, a];
-  return {
-    kind: "admit",
-    pair: {
-      scenarioId,
-      chosenRunId: chosen.run.runId,
-      rejectedRunId: rejected.run.runId,
-      chosenVariantId: chosen.run.candidateId,
-      rejectedVariantId: rejected.run.candidateId,
-      marginScore: chosen.score - rejected.score,
-      scores: { chosen: chosen.score, rejected: rejected.score },
-      seed: chosen.run.seed === rejected.run.seed ? chosen.run.seed : void 0,
-      meta: {
-        chosenPromptHash: chosen.run.promptHash,
-        rejectedPromptHash: rejected.run.promptHash,
-        chosenConfigHash: chosen.run.configHash,
-        rejectedConfigHash: rejected.run.configHash,
-        chosenModel: chosen.run.model,
-        rejectedModel: rejected.run.model
-      }
-    }
-  };
-}
-function scenarioOf(run) {
-  return run.scenarioId;
-}
-
-// src/rl/process-reward.ts
+	if (Math.abs(a.score - b.score) < minMargin) return { kind: "reject" };
+	const [chosen, rejected] = a.score > b.score ? [a, b] : [b, a];
+	const seed = chosen.seed !== null && chosen.seed === rejected.seed ? chosen.seed : void 0;
+	return {
+		kind: "admit",
+		pair: {
+			scenarioId,
+			chosenRunId: chosen.runId,
+			rejectedRunId: rejected.runId,
+			chosenVariantId: chosen.candidateId,
+			rejectedVariantId: rejected.candidateId,
+			marginScore: chosen.score - rejected.score,
+			scores: {
+				chosen: chosen.score,
+				rejected: rejected.score
+			},
+			seed,
+			meta: {
+				chosenPromptHash: chosen.promptHash,
+				rejectedPromptHash: rejected.promptHash,
+				chosenConfigHash: chosen.configHash,
+				rejectedConfigHash: rejected.configHash,
+				chosenModel: chosen.model,
+				rejectedModel: rejected.model
+			}
+		}
+	};
+}
+//#endregion
+//#region src/rl/process-reward.ts
 async function extractStepRewards(store, runId, opts) {
-  const spans = await store.spans({ runId });
-  const ordered = [...spans].sort((a, b) => a.startedAt - b.startedAt);
-  const out = [];
-  let idx = 0;
-  for (const span of ordered) {
-    if (opts.preFilter && !opts.preFilter(span)) continue;
-    let scored = null;
-    for (const s of opts.scorers) {
-      if (!s.appliesTo.includes(span.kind)) continue;
-      const r = await s.score(span);
-      if (r) {
-        scored = r;
-        break;
-      }
-    }
-    if (!scored) continue;
-    out.push({
-      spanId: span.spanId,
-      runId,
-      stepIndex: idx++,
-      kind: span.kind,
-      name: span.name,
-      reward: scored.reward,
-      determinism: scored.determinism,
-      rationale: scored.rationale,
-      weight: scored.weight
-    });
-  }
-  return out;
+	const ordered = [...await store.spans({ runId })].sort((a, b) => a.startedAt - b.startedAt);
+	const out = [];
+	let idx = 0;
+	for (const span of ordered) {
+		if (opts.preFilter && !opts.preFilter(span)) continue;
+		let scored = null;
+		for (const s of opts.scorers) {
+			if (!s.appliesTo.includes(span.kind)) continue;
+			const r = await s.score(span);
+			if (r) {
+				scored = r;
+				break;
+			}
+		}
+		if (!scored) continue;
+		out.push({
+			spanId: span.spanId,
+			runId,
+			stepIndex: idx++,
+			kind: span.kind,
+			name: span.name,
+			reward: scored.reward,
+			determinism: scored.determinism,
+			rationale: scored.rationale,
+			weight: scored.weight
+		});
+	}
+	return out;
 }
 function runwiseStepRewardSummary(stepRewards) {
-  if (stepRewards.length === 0) {
-    return {
-      runId: "",
-      totalSteps: 0,
-      meanReward: 0,
-      sumWeightedReward: 0,
-      failureFraction: 0,
-      worstStepDelta: 0,
-      worstStepIndex: null
-    };
-  }
-  const runId = stepRewards[0].runId;
-  let sumW = 0;
-  let sumWR = 0;
-  let failures = 0;
-  let worstDelta = 0;
-  let worstIdx = null;
-  let prev = stepRewards[0].reward;
-  for (let i = 0; i < stepRewards.length; i++) {
-    const s = stepRewards[i];
-    const w = s.weight ?? 1;
-    sumW += w;
-    sumWR += w * s.reward;
-    if (s.reward < 0.5) failures++;
-    if (i > 0) {
-      const delta = s.reward - prev;
-      if (delta < worstDelta) {
-        worstDelta = delta;
-        worstIdx = i;
-      }
-      prev = s.reward;
-    } else {
-      prev = s.reward;
-    }
-  }
-  return {
-    runId,
-    totalSteps: stepRewards.length,
-    meanReward: sumW === 0 ? 0 : sumWR / sumW,
-    sumWeightedReward: sumWR,
-    failureFraction: failures / stepRewards.length,
-    worstStepDelta: worstDelta,
-    worstStepIndex: worstIdx
-  };
-}
+	if (stepRewards.length === 0) return {
+		runId: "",
+		totalSteps: 0,
+		meanReward: 0,
+		sumWeightedReward: 0,
+		failureFraction: 0,
+		worstStepDelta: 0,
+		worstStepIndex: null
+	};
+	const runId = stepRewards[0].runId;
+	let sumW = 0;
+	let sumWR = 0;
+	let failures = 0;
+	let worstDelta = 0;
+	let worstIdx = null;
+	let prev = stepRewards[0].reward;
+	for (let i = 0; i < stepRewards.length; i++) {
+		const s = stepRewards[i];
+		const w = s.weight ?? 1;
+		sumW += w;
+		sumWR += w * s.reward;
+		if (s.reward < .5) failures++;
+		if (i > 0) {
+			const delta = s.reward - prev;
+			if (delta < worstDelta) {
+				worstDelta = delta;
+				worstIdx = i;
+			}
+			prev = s.reward;
+		} else prev = s.reward;
+	}
+	return {
+		runId,
+		totalSteps: stepRewards.length,
+		meanReward: sumW === 0 ? 0 : sumWR / sumW,
+		sumWeightedReward: sumWR,
+		failureFraction: failures / stepRewards.length,
+		worstStepDelta: worstDelta,
+		worstStepIndex: worstIdx
+	};
+}
+/**
+* Build PRM training triples. The shape: pair runs that share an early
+* prefix (same scenario, same first N steps) and diverge later — at the
+* point of divergence, the high-reward run's next step is `chosen`, the
+* low-reward run's next step is `rejected`. This is the canonical PRM
+* training data shape from Lightman et al. and DeepSeek-R1 process
+* supervision.
+*
+* Implementation note: we don't have a way to detect "same prefix" in
+* the general agent setting (token-level prefixes require hashing model
+* outputs). The current heuristic groups by `(scenarioId, prefixSpanName
+* sequence)` — runs are paired when their first K span names match. For
+* production use this should be replaced with a proper trajectory-prefix
+* hash; the heuristic is good enough for early-stage scaffolding.
+*/
 function prmTrainingPairs(stepRewardsByRun, opts = {}) {
-  const minMargin = opts.minMargin ?? 0.2;
-  const minPrefix = opts.minPrefixLength ?? 1;
-  const runs = [...stepRewardsByRun.entries()].map(([runId, steps]) => ({ runId, steps }));
-  const triples = [];
-  for (let i = 0; i < runs.length; i++) {
-    for (let j = i + 1; j < runs.length; j++) {
-      const a = runs[i];
-      const b = runs[j];
-      const minLen = Math.min(a.steps.length, b.steps.length);
-      if (minLen < minPrefix + 1) continue;
-      let divergenceIdx = -1;
-      for (let k = 0; k < minLen; k++) {
-        const sa = a.steps[k];
-        const sb = b.steps[k];
-        const structuralDivergence = sa.kind !== sb.kind || sa.name !== sb.name;
-        const rewardGap = Math.abs(sa.reward - sb.reward);
-        if (structuralDivergence || rewardGap >= minMargin) {
-          divergenceIdx = k;
-          break;
-        }
-      }
-      if (divergenceIdx < 0) continue;
-      if (divergenceIdx < minPrefix) continue;
-      const aNext = a.steps[divergenceIdx];
-      const bNext = b.steps[divergenceIdx];
-      const margin = Math.abs(aNext.reward - bNext.reward);
-      if (margin < minMargin) continue;
-      const chosen = aNext.reward > bNext.reward ? aNext : bNext;
-      const rejected = aNext.reward > bNext.reward ? bNext : aNext;
-      const chosenRun = aNext.reward > bNext.reward ? a.runId : b.runId;
-      const rejectedRun = aNext.reward > bNext.reward ? b.runId : a.runId;
-      triples.push({
-        prefixRunId: chosenRun,
-        prefixStepIndex: divergenceIdx - 1,
-        chosenSpanId: chosen.spanId,
-        chosenReward: chosen.reward,
-        rejectedSpanId: rejected.spanId,
-        rejectedReward: rejected.reward,
-        rejectedRunId: rejectedRun,
-        marginScore: chosen.reward - rejected.reward
-      });
-    }
-  }
-  return triples;
-}
-
-// src/rl/rl-campaign.ts
+	const minMargin = opts.minMargin ?? .2;
+	const minPrefix = opts.minPrefixLength ?? 1;
+	const runs = [...stepRewardsByRun.entries()].map(([runId, steps]) => ({
+		runId,
+		steps
+	}));
+	const triples = [];
+	for (let i = 0; i < runs.length; i++) for (let j = i + 1; j < runs.length; j++) {
+		const a = runs[i];
+		const b = runs[j];
+		const minLen = Math.min(a.steps.length, b.steps.length);
+		if (minLen < minPrefix + 1) continue;
+		let divergenceIdx = -1;
+		for (let k = 0; k < minLen; k++) {
+			const sa = a.steps[k];
+			const sb = b.steps[k];
+			const structuralDivergence = sa.kind !== sb.kind || sa.name !== sb.name;
+			const rewardGap = Math.abs(sa.reward - sb.reward);
+			if (structuralDivergence || rewardGap >= minMargin) {
+				divergenceIdx = k;
+				break;
+			}
+		}
+		if (divergenceIdx < 0) continue;
+		if (divergenceIdx < minPrefix) continue;
+		const aNext = a.steps[divergenceIdx];
+		const bNext = b.steps[divergenceIdx];
+		if (Math.abs(aNext.reward - bNext.reward) < minMargin) continue;
+		const chosen = aNext.reward > bNext.reward ? aNext : bNext;
+		const rejected = aNext.reward > bNext.reward ? bNext : aNext;
+		const chosenRun = aNext.reward > bNext.reward ? a.runId : b.runId;
+		const rejectedRun = aNext.reward > bNext.reward ? b.runId : a.runId;
+		triples.push({
+			prefixRunId: chosenRun,
+			prefixStepIndex: divergenceIdx - 1,
+			chosenSpanId: chosen.spanId,
+			chosenReward: chosen.reward,
+			rejectedSpanId: rejected.spanId,
+			rejectedReward: rejected.reward,
+			rejectedRunId: rejectedRun,
+			marginScore: chosen.reward - rejected.reward
+		});
+	}
+	return triples;
+}
+//#endregion
+//#region src/rl/rl-campaign.ts
+/**
+* `runRLCampaign` — top-level orchestrator that runs the matrix and
+* produces every RL-ready artifact in one call.
+*
+* Wires:
+*   1. `runEvalCampaign` for the matrix run (capture, integrity, hooks)
+*   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)
+*   5. `rubricPredictiveValidity` against an outcome store, when provided
+*   6. `detectRewardHacking` as a standing hygiene check
+*   7. Trainer-format export rows ready for prime-rl / TRL / verl
+*
+* 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.pairs` to a DPO trainer,
+* `result.trainerRows.grpo` to GRPO, or `result.campaign.runs` plus
+* `result.rewardSignals` to a custom RL loop.
+*/
 async function runRLCampaign(opts) {
-  const splitTag = opts.splitTag ?? "search";
-  const campaign = await runEvalCampaign({ ...opts, splitTag });
-  const rewardSignals = extractVerifiableRewardsFromRecords(
-    campaign.runs,
-    opts.verifiableReward ?? {}
-  );
-  const preferences = extractPreferences(campaign.runs, {
-    ...opts.preferences,
-    strategy: opts.preferences?.strategy ?? "paired-by-scenario-and-seed",
-    minMargin: opts.preferences?.minMargin ?? 0.05,
-    splitTag: opts.preferences?.splitTag ?? splitTag
-  });
-  let interimConfidence = null;
-  if (opts.report?.comparator) {
-    const comparator = opts.report.comparator;
-    const deltaSeries = collectPairedDeltaSeries(campaign.runs, comparator);
-    if (deltaSeries.some((s) => s.deltas.length > 0)) {
-      interimConfidence = evaluateInterimReleaseConfidence({
-        deltaSeries,
-        alpha: opts.sequential?.alpha,
-        bound: opts.sequential?.bound,
-        rope: opts.sequential?.rope ?? opts.report?.rope
-      });
-    }
-  }
-  const rewardHacking = detectRewardHacking({
-    runs: campaign.runs,
-    verifiableRewardOptions: opts.verifiableReward
-  });
-  let predictiveValidity = null;
-  if (opts.outcomeStore && opts.outcomeMetrics && opts.outcomeMetrics.length > 0) {
-    predictiveValidity = await rubricPredictiveValidity({
-      runs: campaign.runs,
-      outcomes: opts.outcomeStore,
-      outcomeMetrics: opts.outcomeMetrics
-    });
-  }
-  const trainerRows = {};
-  if (opts.trainerExport?.dpo) {
-    trainerRows.dpo = await toDpoRows(preferences.pairs, opts.trainerExport.dpo);
-  }
-  if (opts.trainerExport?.grpo) {
-    trainerRows.grpo = await toGrpoRows(campaign.runs, opts.trainerExport.grpo);
-  }
-  if (opts.trainerExport?.sft) {
-    trainerRows.sft = await toSftRows(campaign.runs, opts.trainerExport.sft);
-  }
-  const summary = buildSummary({
-    campaign,
-    preferences,
-    interimConfidence,
-    rewardHacking,
-    predictiveValidity
-  });
-  return {
-    campaign,
-    rewardSignals,
-    preferences,
-    interimConfidence,
-    rewardHacking,
-    predictiveValidity,
-    trainerRows,
-    summary,
-    kind: "agent-eval-rl-campaign"
-  };
+	const splitTag = opts.splitTag ?? "search";
+	const campaign = await runEvalCampaign({
+		...opts,
+		splitTag
+	});
+	const rewardSignals = extractVerifiableRewardsFromRecords(campaign.runs, opts.verifiableReward ?? {});
+	const { rows: rolloutLines } = await mintRolloutRows(campaign.runs.filter((run) => runTaskScore(run) !== void 0), new InMemoryTraceStore());
+	const preferences = extractPreferences(rolloutLines, {
+		...opts.preferences,
+		strategy: opts.preferences?.strategy ?? "paired-by-scenario-and-seed",
+		minMargin: opts.preferences?.minMargin ?? .05,
+		split: opts.preferences?.split ?? splitTag
+	});
+	let interimConfidence = null;
+	if (opts.report?.comparator) {
+		const comparator = opts.report.comparator;
+		const deltaSeries = collectPairedDeltaSeries(campaign.runs, comparator);
+		if (deltaSeries.some((s) => s.deltas.length > 0)) interimConfidence = evaluateInterimReleaseConfidence({
+			deltaSeries,
+			alpha: opts.sequential?.alpha,
+			bound: opts.sequential?.bound,
+			rope: opts.sequential?.rope ?? opts.report?.rope
+		});
+	}
+	const rewardHacking = detectRewardHacking({
+		runs: campaign.runs,
+		verifiableRewardOptions: opts.verifiableReward
+	});
+	let predictiveValidity = null;
+	if (opts.outcomeStore && opts.outcomeMetrics && opts.outcomeMetrics.length > 0) predictiveValidity = await rubricPredictiveValidity({
+		runs: campaign.runs,
+		outcomes: opts.outcomeStore,
+		outcomeMetrics: opts.outcomeMetrics
+	});
+	const trainerRows = {};
+	if (opts.trainerExport?.dpo) trainerRows.dpo = await toDpoRows(preferences.pairs, opts.trainerExport.dpo, { lines: rolloutLines });
+	if (opts.trainerExport?.grpo) trainerRows.grpo = await toGrpoRows(rolloutLines, opts.trainerExport.grpo);
+	if (opts.trainerExport?.sft) trainerRows.sft = await toSftRows(rolloutLines, opts.trainerExport.sft);
+	const summary = buildSummary({
+		campaign,
+		preferences,
+		interimConfidence,
+		rewardHacking,
+		predictiveValidity
+	});
+	return {
+		campaign,
+		rewardSignals,
+		preferences,
+		interimConfidence,
+		rewardHacking,
+		predictiveValidity,
+		trainerRows,
+		summary,
+		kind: "agent-eval-rl-campaign"
+	};
 }
 function collectPairedDeltaSeries(runs, comparator) {
-  const baseline = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    if (r.candidateId !== comparator) continue;
-    const sid = r.scenarioId;
-    const score = runTaskScore(r);
-    if (score === void 0) continue;
-    baseline.set(`${sid}::${r.seed}`, score);
-  }
-  const byCandidate = /* @__PURE__ */ new Map();
-  for (const r of runs) {
-    if (r.candidateId === comparator) continue;
-    const sid = r.scenarioId;
-    const score = runTaskScore(r);
-    if (score === void 0) continue;
-    const baseScore = baseline.get(`${sid}::${r.seed}`);
-    if (typeof baseScore !== "number") continue;
-    const arr = byCandidate.get(r.candidateId) ?? [];
-    arr.push(score - baseScore);
-    byCandidate.set(r.candidateId, arr);
-  }
-  return [...byCandidate.entries()].map(([candidateId, deltas]) => ({ candidateId, deltas }));
+	const baseline = /* @__PURE__ */ new Map();
+	for (const r of runs) {
+		if (r.candidateId !== comparator) continue;
+		const sid = r.scenarioId;
+		const score = runTaskScore(r);
+		if (score === void 0) continue;
+		baseline.set(`${sid}::${r.seed}`, score);
+	}
+	const byCandidate = /* @__PURE__ */ new Map();
+	for (const r of runs) {
+		if (r.candidateId === comparator) continue;
+		const sid = r.scenarioId;
+		const score = runTaskScore(r);
+		if (score === void 0) continue;
+		const baseScore = baseline.get(`${sid}::${r.seed}`);
+		if (typeof baseScore !== "number") continue;
+		const arr = byCandidate.get(r.candidateId) ?? [];
+		arr.push(score - baseScore);
+		byCandidate.set(r.candidateId, arr);
+	}
+	return [...byCandidate.entries()].map(([candidateId, deltas]) => ({
+		candidateId,
+		deltas
+	}));
 }
 function buildSummary(args) {
-  const c = args.campaign;
-  const lines = [
-    `${c.campaignId}: ${c.runs.length} successful runs / ${c.failedRuns.length} failed (fingerprint ${c.campaignFingerprint.slice(0, 12)}\u2026)`,
-    `preferences: ${args.preferences.pairs.length} (${args.preferences.strategy}, ${args.preferences.pairsBelowMargin} below margin)`
-  ];
-  if (args.interimConfidence) {
-    lines.push(
-      `sequential verdict: ${args.interimConfidence.recommendation.decision}` + (args.interimConfidence.recommendation.candidateId ? ` ${args.interimConfidence.recommendation.candidateId}` : "")
-    );
-  }
-  lines.push(
-    `reward-hacking: ${args.rewardHacking.verdict} (${args.rewardHacking.findings.length} signals checked)`
-  );
-  if (args.predictiveValidity) {
-    const top = args.predictiveValidity.ranked[0];
-    lines.push(
-      `top-rubric: ${top?.rubric ?? "none"} \u03C1=${(top?.spearman ?? 0).toFixed(2)} (${top?.verdict ?? "no data"})`
-    );
-  }
-  return lines.join(" | ");
-}
-
-// src/rl/run-record-adapters.ts
+	const c = args.campaign;
+	const lines = [`${c.campaignId}: ${c.runs.length} successful runs / ${c.failedRuns.length} failed (fingerprint ${c.campaignFingerprint.slice(0, 12)}…)`, `preferences: ${args.preferences.pairs.length} (${args.preferences.strategy}, ${args.preferences.pairsBelowMargin} below margin)`];
+	if (args.interimConfidence) lines.push(`sequential verdict: ${args.interimConfidence.recommendation.decision}` + (args.interimConfidence.recommendation.candidateId ? ` ${args.interimConfidence.recommendation.candidateId}` : ""));
+	lines.push(`reward-hacking: ${args.rewardHacking.verdict} (${args.rewardHacking.findings.length} signals checked)`);
+	if (args.predictiveValidity) {
+		const top = args.predictiveValidity.ranked[0];
+		lines.push(`top-rubric: ${top?.rubric ?? "none"} ρ=${(top?.spearman ?? 0).toFixed(2)} (${top?.verdict ?? "no data"})`);
+	}
+	return lines.join(" | ");
+}
+//#endregion
+//#region src/rl/run-record-adapters.ts
+/**
+* Adapters: convert measurement outputs into the canonical `RunRecord[]`
+* artifact that `replayCache`, `pairedEvalueSequence`, and
+* `rubricPredictiveValidity` consume. Two sources:
+*   - `campaignToRunRecords` — the campaign substrate's per-cell results
+*     (the modern path: `runCampaign` / `runImprovementLoop` → records).
+*   - `verificationReportToRunRecord` — a `MultiLayerVerifier` report.
+*
+* Adapters are thin and explicit — every mandatory `RunRecord` field comes
+* from a caller-supplied context (`commitSha`, `model`, `promptHash`,
+* `configHash`) plus the cell's runtime data. The validator still rejects
+* bare-alias model strings — the caller snapshot-pins.
+*/
+/**
+* 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.
+*/
 function campaignToRunRecords(campaign, ctx) {
-  const splitTag = ctx.splitTag ?? "search";
-  const candidateId = ctx.candidateId ?? campaign.manifestHash;
-  return campaign.cells.map(
-    (cell) => campaignCellToRunRecord(cell, {
-      runId: cell.cellId,
-      experimentId: ctx.experimentId,
-      candidateId,
-      model: ctx.model,
-      promptHash: ctx.promptHash,
-      configHash: ctx.configHash,
-      commitSha: ctx.commitSha,
-      splitTag,
-      defaultCostUsd: ctx.defaultCostUsd
-    })
-  );
-}
+	const splitTag = ctx.splitTag ?? "search";
+	const candidateId = ctx.candidateId ?? campaign.manifestHash;
+	return campaign.cells.map((cell) => campaignCellToRunRecord(cell, {
+		runId: cell.cellId,
+		experimentId: ctx.experimentId,
+		candidateId,
+		model: ctx.model,
+		promptHash: ctx.promptHash,
+		configHash: ctx.configHash,
+		commitSha: ctx.commitSha,
+		splitTag,
+		defaultCostUsd: ctx.defaultCostUsd
+	}));
+}
+/**
+* Convert a `MultiLayerVerifier` `VerificationReport` into a `RunRecord`.
+* 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.
+*/
 function verificationReportToRunRecord(report, ctx, opts = {}) {
-  const splitTag = ctx.splitTag ?? "search";
-  const runId = opts.runId ?? `run-${ctx.candidateId}-${ctx.experimentId}-${report.startedAt}`;
-  const hasValidLayerMeasurement = report.layers.some(hasValidTaskMeasurement);
-  const taskScore = hasValidLayerMeasurement && isValidScore(report.taskScore) ? report.taskScore : void 0;
-  let executionErrorCount = 0;
-  let judgeErrorCount = 0;
-  let layerErrorCount = 0;
-  let layerTimeoutCount = 0;
-  let unscoredLayerCount = 0;
-  const raw = {
-    pass_count: report.passCount,
-    fail_count: report.failCount,
-    error_count: report.errorCount,
-    skipped_count: report.skippedCount,
-    duration_ms: report.durationMs,
-    execution_error_count: 0
-  };
-  for (const layer of report.layers) {
-    if (hasValidTaskMeasurement(layer)) raw[`layer.${layer.layer}`] = layer.score;
-    else unscoredLayerCount++;
-    raw[`layer_${layer.layer}_pass`] = layer.status === "pass" ? 1 : 0;
-    if (layer.status === "error" || layer.status === "timeout") {
-      if (layer.errorSource === "judge") judgeErrorCount++;
-      else executionErrorCount++;
-      if (layer.status === "error") layerErrorCount++;
-      else layerTimeoutCount++;
-    }
-    if (layer.diagnostics) {
-      for (const [k, v] of Object.entries(layer.diagnostics)) {
-        if (typeof v === "number" && Number.isFinite(v)) raw[`layer.${layer.layer}.${k}`] = v;
-      }
-    }
-  }
-  raw.execution_error_count = executionErrorCount;
-  if (judgeErrorCount > 0) raw.judge_error_count = judgeErrorCount;
-  if (layerErrorCount > 0) raw.layer_error_count = layerErrorCount;
-  if (layerTimeoutCount > 0) raw.layer_timeout_count = layerTimeoutCount;
-  if (unscoredLayerCount > 0) raw.unscored_layer_count = unscoredLayerCount;
-  if (taskScore !== void 0) raw.blended_score = taskScore;
-  const firstScoredFailure = report.layers.find(
-    (layer) => layer.status === "fail" && hasValidTaskMeasurement(layer)
-  );
-  const outcome = { raw };
-  if (taskScore !== void 0) {
-    if (splitTag === "holdout") outcome.holdoutScore = taskScore;
-    else outcome.searchScore = taskScore;
-  }
-  return {
-    runId,
-    experimentId: ctx.experimentId,
-    candidateId: ctx.candidateId,
-    seed: 0,
-    model: ctx.model,
-    promptHash: ctx.promptHash,
-    configHash: ctx.configHash,
-    commitSha: ctx.commitSha,
-    wallMs: report.durationMs,
-    costUsd: ctx.defaultCostUsd ?? null,
-    costProvenance: ctx.defaultCostUsd === void 0 ? { kind: "uncaptured", usd: null } : { kind: "estimated", usd: ctx.defaultCostUsd },
-    tokenUsage: { input: 0, output: 0 },
-    terminalOutcome: "succeeded",
-    outcome,
-    ...firstScoredFailure ? {
-      failureClass: "unknown",
-      failureMode: `layer_${firstScoredFailure.layer}_fail`
-    } : {},
-    splitTag,
-    scenarioId: ctx.scenarioId
-  };
+	const splitTag = ctx.splitTag ?? "search";
+	const runId = opts.runId ?? `run-${ctx.candidateId}-${ctx.experimentId}-${report.startedAt}`;
+	const taskScore = report.layers.some(hasValidTaskMeasurement) && isValidScore(report.taskScore) ? report.taskScore : void 0;
+	let executionErrorCount = 0;
+	let judgeErrorCount = 0;
+	let layerErrorCount = 0;
+	let layerTimeoutCount = 0;
+	let unscoredLayerCount = 0;
+	const raw = {
+		pass_count: report.passCount,
+		fail_count: report.failCount,
+		error_count: report.errorCount,
+		skipped_count: report.skippedCount,
+		duration_ms: report.durationMs,
+		execution_error_count: 0
+	};
+	for (const layer of report.layers) {
+		if (hasValidTaskMeasurement(layer)) raw[`layer.${layer.layer}`] = layer.score;
+		else unscoredLayerCount++;
+		raw[`layer_${layer.layer}_pass`] = layer.status === "pass" ? 1 : 0;
+		if (layer.status === "error" || layer.status === "timeout") {
+			if (layer.errorSource === "judge") judgeErrorCount++;
+			else executionErrorCount++;
+			if (layer.status === "error") layerErrorCount++;
+			else layerTimeoutCount++;
+		}
+		if (layer.diagnostics) {
+			for (const [k, v] of Object.entries(layer.diagnostics)) if (typeof v === "number" && Number.isFinite(v)) raw[`layer.${layer.layer}.${k}`] = v;
+		}
+	}
+	raw.execution_error_count = executionErrorCount;
+	if (judgeErrorCount > 0) raw.judge_error_count = judgeErrorCount;
+	if (layerErrorCount > 0) raw.layer_error_count = layerErrorCount;
+	if (layerTimeoutCount > 0) raw.layer_timeout_count = layerTimeoutCount;
+	if (unscoredLayerCount > 0) raw.unscored_layer_count = unscoredLayerCount;
+	if (taskScore !== void 0) raw.blended_score = taskScore;
+	const firstScoredFailure = report.layers.find((layer) => layer.status === "fail" && hasValidTaskMeasurement(layer));
+	const outcome = { raw };
+	if (taskScore !== void 0) if (splitTag === "holdout") outcome.holdoutScore = taskScore;
+	else outcome.searchScore = taskScore;
+	return {
+		runId,
+		experimentId: ctx.experimentId,
+		candidateId: ctx.candidateId,
+		seed: 0,
+		model: ctx.model,
+		promptHash: ctx.promptHash,
+		configHash: ctx.configHash,
+		commitSha: ctx.commitSha,
+		wallMs: report.durationMs,
+		costUsd: ctx.defaultCostUsd ?? null,
+		costProvenance: ctx.defaultCostUsd === void 0 ? {
+			kind: "uncaptured",
+			usd: null
+		} : {
+			kind: "estimated",
+			usd: ctx.defaultCostUsd
+		},
+		tokenUsage: {
+			input: 0,
+			output: 0
+		},
+		terminalOutcome: "succeeded",
+		outcome,
+		...firstScoredFailure ? {
+			failureClass: "unknown",
+			failureMode: `layer_${firstScoredFailure.layer}_fail`
+		} : {},
+		splitTag,
+		scenarioId: ctx.scenarioId
+	};
 }
 function hasValidTaskMeasurement(layer) {
-  return (layer.status === "pass" || layer.status === "fail") && isValidScore(layer.score);
+	return (layer.status === "pass" || layer.status === "fail") && isValidScore(layer.score);
 }
 function isValidScore(score) {
-  return typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 1;
-}
-
-// src/rl/sim-fidelity.ts
-var ABSENT_CATEGORY = "(absent)";
-var DEFAULT_MIN_N_PER_FEATURE = 20;
-var DEFAULT_QUANTILE_BUCKETS = 4;
-var REPRESENTATIVE_MIN_FIDELITY = 0.8;
-var TOP_SHIFT_COUNT = 5;
-var defaultBehaviorFeatures = (record) => {
-  const raw = record.outcome?.raw ?? {};
-  const toolErrors = finiteOrNull(raw.tool_errors);
-  const turnsAborted = finiteOrNull(raw.turns_aborted);
-  const completion = record.completion;
-  return {
-    score: finiteOrNull(record.outcome?.holdoutScore) ?? finiteOrNull(record.outcome?.searchScore),
-    failure_class: record.failureClass ?? null,
-    wall_ms: finiteOrNull(record.wallMs),
-    output_tokens: finiteOrNull(record.tokenUsage?.output),
-    turn_count: finiteOrNull(raw.turns_completed) ?? finiteOrNull(raw.assistant_messages),
-    tool_errors: toolErrors,
-    tool_error_recovery: toolErrorRecovery(toolErrors, turnsAborted, record.failureClass),
-    completion_length: typeof completion === "string" ? completion.length : null
-  };
+	return typeof score === "number" && Number.isFinite(score) && score >= 0 && score <= 1;
+}
+//#endregion
+//#region src/rl/sim-fidelity.ts
+/**
+* Simulator fidelity — score a user SIMULATOR's realism against real-user
+* trace distributions.
+*
+* Synthetic-persona evals (`PersonaConfig`-driven canonical evals, fuzz
+* user-simulator objectives) stand in for real users in most of the numbers
+* we publish. The standing threat is the Sim2Real gap: a simulator that is
+* distributionally unlike production creates "easy mode" and silently
+* inflates every score built on it. This module measures that gap from the
+* SAME artifact both sides already produce — `RunRecord`s — so no new
+* capture pipeline is needed:
+*
+*   - `simFidelityReport` — per-feature Jensen-Shannon divergence between
+*     simulated and production record distributions, collapsed into a
+*     fidelity coefficient in [0,1].
+*   - `easyModeCheck` — the headline academic failure mode (sim inflates
+*     pass-rate over production) as its own named artifact.
+*
+* Every synthetic-persona eval result should publish its fidelity
+* coefficient alongside the score — a number from an unrepresentative
+* simulator is an unlabeled estimate. Wire-in points:
+*
+*   - canonical persona evals: pass the campaign's `RunRecord`s as
+*     `simulated` and intake-adapter output (`contract/intake`: OTel spans,
+*     feedback tables, coding-agent sessions) as `production`
+*   - the fuzz user-sim objective: use `1 - report.fidelity` as a realism
+*     penalty when searching over generated personas
+*   - the durable corpus (`./corpus`): both sides read straight from
+*     `readCorpus` — tag sim vs production by `experimentId`
+*/
+/** Reserved histogram category for `null` feature values. A capture-rate
+*  difference (one side instruments a signal, the other does not) registers
+*  as divergence by design: a simulator that produces no tool traces is not
+*  representative of production that does. */
+const ABSENT_CATEGORY = "(absent)";
+/** Minimum non-null observations PER SIDE for a feature to enter the
+*  fidelity mean. Below this the JSD estimate is sampling noise. */
+const DEFAULT_MIN_N_PER_FEATURE = 20;
+/** Quantile buckets used to discretize numeric features. Quartiles balance
+*  resolution against per-bucket sample size at the default minN. */
+const DEFAULT_QUANTILE_BUCKETS = 4;
+/** Fidelity at or above this → 'representative'; below → 'skewed'.
+*  1 − 0.8 = mean JSD 0.2 ≈ distributions that mostly overlap with one
+*  clearly shifted mode — the point where per-feature shifts start changing
+*  which failure classes an eval can even observe. */
+const REPRESENTATIVE_MIN_FIDELITY = .8;
+const TOP_SHIFT_COUNT = 5;
+/**
+* Default feature set — ONLY fields verified present on both simulated and
+* production records:
+*
+*   - `score`, `wall_ms`, `output_tokens` — mandatory per the `RunRecord`
+*     validator (non-finite values read as absent rather than poisoning a
+*     bucket).
+*   - `failure_class` — optional taxonomy field; absent counted explicitly.
+*   - `turn_count`, `tool_errors`, `tool_error_recovery` — derived from the
+*     `outcome.raw` counters the intake adapters and eval harnesses write
+*     (`turns_completed`, `assistant_messages`, `tool_errors`,
+*     `turns_aborted`); absent on records whose producer did not capture
+*     them, counted explicitly.
+*   - `completion_length` — from the optional `CorpusRecord` trajectory
+*     text; the message-length proxy when records come from the corpus.
+*
+* `RunRecord` carries event COUNTS, not event ordering, so
+* `tool_error_recovery` is a counts-only derivation: errors occurred and the
+* run still completed cleanly ('recovered') vs aborted or classified as a
+* failure ('unrecovered') — not a literal error→retry sequence check.
+*/
+const defaultBehaviorFeatures = (record) => {
+	const raw = record.outcome?.raw ?? {};
+	const toolErrors = finiteOrNull(raw.tool_errors);
+	const turnsAborted = finiteOrNull(raw.turns_aborted);
+	const completion = record.completion;
+	return {
+		score: finiteOrNull(observedSplitScore(record, "holdout")) ?? finiteOrNull(observedSplitScore(record, "search")),
+		failure_class: record.failureClass ?? null,
+		wall_ms: finiteOrNull(record.wallMs),
+		output_tokens: finiteOrNull(record.tokenUsage?.output),
+		turn_count: finiteOrNull(raw.turns_completed) ?? finiteOrNull(raw.assistant_messages),
+		tool_errors: toolErrors,
+		tool_error_recovery: toolErrorRecovery(toolErrors, turnsAborted, record.failureClass),
+		completion_length: typeof completion === "string" ? completion.length : null
+	};
 };
 function toolErrorRecovery(toolErrors, turnsAborted, failureClass) {
-  if (toolErrors === null) return null;
-  if (toolErrors === 0) return "no-tool-errors";
-  const failed = (turnsAborted ?? 0) > 0 || failureClass !== void 0 && failureClass !== "success";
-  return failed ? "unrecovered" : "recovered";
+	if (toolErrors === null) return null;
+	if (toolErrors === 0) return "no-tool-errors";
+	return (turnsAborted ?? 0) > 0 || failureClass !== void 0 && failureClass !== "success" ? "unrecovered" : "recovered";
 }
 function finiteOrNull(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/**
+* Jensen-Shannon divergence between two categorical histograms (raw counts;
+* normalized internally). Log base 2 → bounded [0,1]: 0 = identical
+* distributions, 1 = disjoint support. Symmetric, defined even where the
+* supports differ — exactly the regime sim-vs-production comparison lives in.
+* Throws on zero-mass or negative/non-finite counts: an empty histogram has
+* no distribution and a silent 0 would read as "perfectly representative".
+*/
 function jsDivergence(p, q) {
-  const keys = /* @__PURE__ */ new Set([...Object.keys(p), ...Object.keys(q)]);
-  if (keys.size === 0) {
-    throw new ValidationError("jsDivergence: both histograms are empty");
-  }
-  let pSum = 0;
-  let qSum = 0;
-  for (const key of keys) {
-    const pv = p[key] ?? 0;
-    const qv = q[key] ?? 0;
-    if (!Number.isFinite(pv) || !Number.isFinite(qv) || pv < 0 || qv < 0) {
-      throw new ValidationError(`jsDivergence: negative or non-finite count for category "${key}"`);
-    }
-    pSum += pv;
-    qSum += qv;
-  }
-  if (pSum === 0 || qSum === 0) {
-    throw new ValidationError("jsDivergence: a histogram with zero total mass has no distribution");
-  }
-  let divergence = 0;
-  for (const key of keys) {
-    const pp = (p[key] ?? 0) / pSum;
-    const qp = (q[key] ?? 0) / qSum;
-    const m = (pp + qp) / 2;
-    if (pp > 0) divergence += 0.5 * pp * Math.log2(pp / m);
-    if (qp > 0) divergence += 0.5 * qp * Math.log2(qp / m);
-  }
-  return Math.min(1, Math.max(0, divergence));
-}
-function quantileEdges(values, bucketCount = DEFAULT_QUANTILE_BUCKETS) {
-  if (values.length === 0) {
-    throw new ValidationError("quantileEdges: requires at least one value");
-  }
-  if (!Number.isInteger(bucketCount) || bucketCount < 2) {
-    throw new ValidationError(
-      `quantileEdges: bucketCount must be an integer >= 2, got ${bucketCount}`
-    );
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const edges = [];
-  for (let k = 1; k < bucketCount; k++) {
-    const pos = k / bucketCount * (sorted.length - 1);
-    const lo = sorted[Math.floor(pos)];
-    const hi = sorted[Math.ceil(pos)];
-    edges.push(lo + (pos - Math.floor(pos)) * (hi - lo));
-  }
-  return [...new Set(edges)];
-}
+	const keys = /* @__PURE__ */ new Set([...Object.keys(p), ...Object.keys(q)]);
+	if (keys.size === 0) throw new ValidationError("jsDivergence: both histograms are empty");
+	let pSum = 0;
+	let qSum = 0;
+	for (const key of keys) {
+		const pv = p[key] ?? 0;
+		const qv = q[key] ?? 0;
+		if (!Number.isFinite(pv) || !Number.isFinite(qv) || pv < 0 || qv < 0) throw new ValidationError(`jsDivergence: negative or non-finite count for category "${key}"`);
+		pSum += pv;
+		qSum += qv;
+	}
+	if (pSum === 0 || qSum === 0) throw new ValidationError("jsDivergence: a histogram with zero total mass has no distribution");
+	let divergence = 0;
+	for (const key of keys) {
+		const pp = (p[key] ?? 0) / pSum;
+		const qp = (q[key] ?? 0) / qSum;
+		const m = (pp + qp) / 2;
+		if (pp > 0) divergence += .5 * pp * Math.log2(pp / m);
+		if (qp > 0) divergence += .5 * qp * Math.log2(qp / m);
+	}
+	return Math.min(1, Math.max(0, divergence));
+}
+/**
+* Deterministic quantile edges over a value set (the UNION of both sides, so
+* sim and production land in the same buckets). Linear interpolation between
+* order statistics; duplicate edges from heavy ties collapse into fewer,
+* wider buckets. Returns `bucketCount - 1` edges before deduplication.
+*/
+function quantileEdges(values, bucketCount = 4) {
+	if (values.length === 0) throw new ValidationError("quantileEdges: requires at least one value");
+	if (!Number.isInteger(bucketCount) || bucketCount < 2) throw new ValidationError(`quantileEdges: bucketCount must be an integer >= 2, got ${bucketCount}`);
+	const sorted = [...values].sort((a, b) => a - b);
+	const edges = [];
+	for (let k = 1; k < bucketCount; k++) {
+		const pos = k / bucketCount * (sorted.length - 1);
+		const lo = sorted[Math.floor(pos)];
+		const hi = sorted[Math.ceil(pos)];
+		edges.push(lo + (pos - Math.floor(pos)) * (hi - lo));
+	}
+	return [...new Set(edges)];
+}
+/** Stable half-open bucket label for a value against quantile edges:
+*  `[-inf,e0)`, `[e0,e1)`, …, `[eLast,+inf)`. */
 function bucketLabel(value, edges) {
-  let i = 0;
-  while (i < edges.length && value >= edges[i]) i++;
-  const lo = i === 0 ? "-inf" : String(edges[i - 1]);
-  const hi = i === edges.length ? "+inf" : String(edges[i]);
-  return `[${lo},${hi})`;
-}
+	let i = 0;
+	while (i < edges.length && value >= edges[i]) i++;
+	return `[${i === 0 ? "-inf" : String(edges[i - 1])},${i === edges.length ? "+inf" : String(edges[i])})`;
+}
+/**
+* Compare a simulator's RunRecords against production RunRecords, feature by
+* feature. Numeric features are bucketed by deterministic quantiles of the
+* union; nulls count as an explicit `ABSENT_CATEGORY`. Throws on empty
+* inputs — "no records" is a wiring error, not a distribution.
+*/
 function simFidelityReport(simulated, production, opts = {}) {
-  if (simulated.length === 0) {
-    throw new ValidationError("simFidelityReport: simulated records are empty");
-  }
-  if (production.length === 0) {
-    throw new ValidationError("simFidelityReport: production records are empty");
-  }
-  const extract = opts.features ?? defaultBehaviorFeatures;
-  const minN = opts.minNPerFeature ?? DEFAULT_MIN_N_PER_FEATURE;
-  const simMaps = simulated.map(extract);
-  const prodMaps = production.map(extract);
-  const featureNames = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const map of [...simMaps, ...prodMaps]) {
-    for (const name of Object.keys(map)) {
-      if (!seen.has(name)) {
-        seen.add(name);
-        featureNames.push(name);
-      }
-    }
-  }
-  const perDimension = [];
-  const insufficientData = [];
-  for (const feature of featureNames) {
-    const simVals = simMaps.map((m) => m[feature] ?? null);
-    const prodVals = prodMaps.map((m) => m[feature] ?? null);
-    const nSim = simVals.filter((v) => v !== null).length;
-    const nProd = prodVals.filter((v) => v !== null).length;
-    if (nSim < minN || nProd < minN) {
-      insufficientData.push(feature);
-      continue;
-    }
-    const { sim, prod } = histograms(feature, simVals, prodVals);
-    perDimension.push({
-      feature,
-      divergence: jsDivergence(sim, prod),
-      topShifts: topShifts(sim, simVals.length, prod, prodVals.length),
-      nSim,
-      nProd
-    });
-  }
-  if (perDimension.length === 0) {
-    return { perDimension, fidelity: Number.NaN, insufficientData, verdict: "insufficient-data" };
-  }
-  const fidelity = 1 - perDimension.reduce((sum, d) => sum + d.divergence, 0) / perDimension.length;
-  return {
-    perDimension,
-    fidelity,
-    insufficientData,
-    verdict: fidelity >= REPRESENTATIVE_MIN_FIDELITY ? "representative" : "skewed"
-  };
+	if (simulated.length === 0) throw new ValidationError("simFidelityReport: simulated records are empty");
+	if (production.length === 0) throw new ValidationError("simFidelityReport: production records are empty");
+	const extract = opts.features ?? defaultBehaviorFeatures;
+	const minN = opts.minNPerFeature ?? 20;
+	const simMaps = simulated.map(extract);
+	const prodMaps = production.map(extract);
+	const featureNames = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const map of [...simMaps, ...prodMaps]) for (const name of Object.keys(map)) if (!seen.has(name)) {
+		seen.add(name);
+		featureNames.push(name);
+	}
+	const perDimension = [];
+	const insufficientData = [];
+	for (const feature of featureNames) {
+		const simVals = simMaps.map((m) => m[feature] ?? null);
+		const prodVals = prodMaps.map((m) => m[feature] ?? null);
+		const nSim = simVals.filter((v) => v !== null).length;
+		const nProd = prodVals.filter((v) => v !== null).length;
+		if (nSim < minN || nProd < minN) {
+			insufficientData.push(feature);
+			continue;
+		}
+		const { sim, prod } = histograms(feature, simVals, prodVals);
+		perDimension.push({
+			feature,
+			divergence: jsDivergence(sim, prod),
+			topShifts: topShifts(sim, simVals.length, prod, prodVals.length),
+			nSim,
+			nProd
+		});
+	}
+	if (perDimension.length === 0) return {
+		perDimension,
+		fidelity: NaN,
+		insufficientData,
+		verdict: "insufficient-data"
+	};
+	const fidelity = 1 - perDimension.reduce((sum, d) => sum + d.divergence, 0) / perDimension.length;
+	return {
+		perDimension,
+		fidelity,
+		insufficientData,
+		verdict: fidelity >= .8 ? "representative" : "skewed"
+	};
 }
 function histograms(feature, simVals, prodVals) {
-  const kinds = /* @__PURE__ */ new Set();
-  for (const v of [...simVals, ...prodVals]) {
-    if (v !== null) kinds.add(typeof v);
-  }
-  if (kinds.size > 1) {
-    throw new ValidationError(
-      `simFidelityReport: feature "${feature}" mixes string and number values \u2014 an extractor must return one kind per feature`
-    );
-  }
-  let toCategory;
-  if (kinds.has("number")) {
-    const union = [];
-    for (const v of [...simVals, ...prodVals]) {
-      if (v !== null) union.push(v);
-    }
-    const edges = quantileEdges(union);
-    toCategory = (v) => bucketLabel(v, edges);
-  } else {
-    toCategory = (v) => v;
-  }
-  const count = (vals) => {
-    const hist = {};
-    for (const v of vals) {
-      const key = v === null ? ABSENT_CATEGORY : toCategory(v);
-      hist[key] = (hist[key] ?? 0) + 1;
-    }
-    return hist;
-  };
-  return { sim: count(simVals), prod: count(prodVals) };
+	const kinds = /* @__PURE__ */ new Set();
+	for (const v of [...simVals, ...prodVals]) if (v !== null) kinds.add(typeof v);
+	if (kinds.size > 1) throw new ValidationError(`simFidelityReport: feature "${feature}" mixes string and number values — an extractor must return one kind per feature`);
+	let toCategory;
+	if (kinds.has("number")) {
+		const union = [];
+		for (const v of [...simVals, ...prodVals]) if (v !== null) union.push(v);
+		const edges = quantileEdges(union);
+		toCategory = (v) => bucketLabel(v, edges);
+	} else toCategory = (v) => v;
+	const count = (vals) => {
+		const hist = {};
+		for (const v of vals) {
+			const key = v === null ? ABSENT_CATEGORY : toCategory(v);
+			hist[key] = (hist[key] ?? 0) + 1;
+		}
+		return hist;
+	};
+	return {
+		sim: count(simVals),
+		prod: count(prodVals)
+	};
 }
 function topShifts(sim, simTotal, prod, prodTotal) {
-  const keys = [.../* @__PURE__ */ new Set([...Object.keys(sim), ...Object.keys(prod)])];
-  const shifts = keys.map((value) => ({
-    value,
-    pSim: (sim[value] ?? 0) / simTotal,
-    pProd: (prod[value] ?? 0) / prodTotal
-  }));
-  shifts.sort((a, b) => {
-    const delta = Math.abs(b.pSim - b.pProd) - Math.abs(a.pSim - a.pProd);
-    return delta !== 0 ? delta : a.value.localeCompare(b.value);
-  });
-  return shifts.slice(0, TOP_SHIFT_COUNT);
-}
+	const shifts = [.../* @__PURE__ */ new Set([...Object.keys(sim), ...Object.keys(prod)])].map((value) => ({
+		value,
+		pSim: (sim[value] ?? 0) / simTotal,
+		pProd: (prod[value] ?? 0) / prodTotal
+	}));
+	shifts.sort((a, b) => {
+		const delta = Math.abs(b.pSim - b.pProd) - Math.abs(a.pSim - a.pProd);
+		return delta !== 0 ? delta : a.value.localeCompare(b.value);
+	});
+	return shifts.slice(0, TOP_SHIFT_COUNT);
+}
+/**
+* The headline simulator failure mode as its own named artifact: a simulator
+* that creates "easy mode" inflates pass-rate relative to production, and
+* every score measured against it overstates reality. Throws on empty inputs
+* and on records carrying neither score — a silently-skipped record would
+* bias the very rate this check exists to keep honest.
+*/
 function easyModeCheck(simulated, production, opts = {}) {
-  if (simulated.length === 0) {
-    throw new ValidationError("easyModeCheck: simulated records are empty");
-  }
-  if (production.length === 0) {
-    throw new ValidationError("easyModeCheck: production records are empty");
-  }
-  const threshold = opts.passThreshold ?? 0.5;
-  const tolerance = opts.inflationTolerance ?? 0.1;
-  const passRate = (records, side) => {
-    let passes = 0;
-    for (const r of records) {
-      const score = finiteOrNull(r.outcome?.holdoutScore) ?? finiteOrNull(r.outcome?.searchScore);
-      if (score === null) {
-        throw new ValidationError(
-          `easyModeCheck: ${side} run "${r.runId}" carries neither holdoutScore nor searchScore`
-        );
-      }
-      if (score >= threshold) passes++;
-    }
-    return passes / records.length;
-  };
-  const simPassRate = passRate(simulated, "simulated");
-  const prodPassRate = passRate(production, "production");
-  const gap = simPassRate - prodPassRate;
-  return { simPassRate, prodPassRate, gap, inflated: gap > tolerance };
-}
-
-// src/rl/tournament.ts
+	if (simulated.length === 0) throw new ValidationError("easyModeCheck: simulated records are empty");
+	if (production.length === 0) throw new ValidationError("easyModeCheck: production records are empty");
+	const threshold = opts.passThreshold ?? .5;
+	const tolerance = opts.inflationTolerance ?? .1;
+	const passRate = (records, side) => {
+		let passes = 0;
+		for (const r of records) {
+			const score = finiteOrNull(observedSplitScore(r, "holdout")) ?? finiteOrNull(observedSplitScore(r, "search"));
+			if (score === null) throw new ValidationError(`easyModeCheck: ${side} run "${r.runId}" carries neither holdoutScore nor searchScore`);
+			if (score >= threshold) passes++;
+		}
+		return passes / records.length;
+	};
+	const simPassRate = passRate(simulated, "simulated");
+	const prodPassRate = passRate(production, "production");
+	const gap = simPassRate - prodPassRate;
+	return {
+		simPassRate,
+		prodPassRate,
+		gap,
+		inflated: gap > tolerance
+	};
+}
+//#endregion
+//#region src/rl/tournament.ts
+/**
+* Bradley-Terry MLE via Hunter's MM algorithm.
+*
+* Iteration: θ_i^new = W_i / Σ_{j ≠ i} N_ij / (θ_i + θ_j)
+*   where W_i = wins by i (+ 0.5 per draw), N_ij = total comparisons.
+*
+* Returns log-strengths normalized so the smallest is 0 (any constant
+* offset is unobservable in BT — only differences are identified).
+*/
 function fitBradleyTerry(outcomes, opts = {}) {
-  const tol = opts.tolerance ?? 1e-6;
-  const maxIter = opts.maxIterations ?? 256;
-  const smoothing = opts.smoothing ?? 0.1;
-  const candidates = /* @__PURE__ */ new Set();
-  for (const o of outcomes) {
-    candidates.add(o.winner);
-    candidates.add(o.loser);
-  }
-  const ids = [...candidates].sort();
-  const idx = new Map(ids.map((id, i) => [id, i]));
-  const n = ids.length;
-  if (n === 0) return { ratings: [], iterations: 0, finalDelta: 0, converged: true };
-  if (n === 1) {
-    return {
-      ratings: [{ candidateId: ids[0], strength: 1, logStrength: 0, n: 0, wins: 0 }],
-      iterations: 0,
-      finalDelta: 0,
-      converged: true
-    };
-  }
-  const W = Array.from({ length: n }, () => new Array(n).fill(0));
-  const N = Array.from({ length: n }, () => new Array(n).fill(0));
-  for (const o of outcomes) {
-    const i = idx.get(o.winner);
-    const j = idx.get(o.loser);
-    const w = o.weight ?? 1;
-    if (o.draw) {
-      W[i][j] += 0.5 * w;
-      W[j][i] += 0.5 * w;
-    } else {
-      W[i][j] += w;
-    }
-    N[i][j] += w;
-    N[j][i] += w;
-  }
-  const winsTotal = new Array(n).fill(0);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) winsTotal[i] += W[i][j];
-    winsTotal[i] += smoothing;
-  }
-  const compsTotal = new Array(n).fill(0);
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < n; j++) compsTotal[i] += N[i][j];
-  }
-  let theta = new Array(n).fill(1);
-  let iter = 0;
-  let delta = Infinity;
-  for (; iter < maxIter; iter++) {
-    const newTheta = new Array(n);
-    for (let i = 0; i < n; i++) {
-      let denom = 0;
-      for (let j = 0; j < n; j++) {
-        if (j === i) continue;
-        if (N[i][j] === 0) continue;
-        denom += N[i][j] / (theta[i] + theta[j]);
-      }
-      newTheta[i] = denom === 0 ? theta[i] : winsTotal[i] / denom;
-    }
-    let logSum = 0;
-    for (let i = 0; i < n; i++) logSum += Math.log(Math.max(1e-300, newTheta[i]));
-    const norm = Math.exp(logSum / n);
-    for (let i = 0; i < n; i++) newTheta[i] = newTheta[i] / norm;
-    delta = 0;
-    for (let i = 0; i < n; i++) {
-      const d = Math.abs(newTheta[i] - theta[i]) / Math.max(1e-12, theta[i]);
-      if (d > delta) delta = d;
-    }
-    theta = newTheta;
-    if (delta < tol) break;
-  }
-  const minLog = Math.min(...theta.map((t) => Math.log(Math.max(1e-300, t))));
-  const ratings = ids.map((id, i) => ({
-    candidateId: id,
-    strength: theta[i],
-    logStrength: Math.log(Math.max(1e-300, theta[i])) - minLog,
-    n: compsTotal[i],
-    wins: winsTotal[i] - smoothing
-  }));
-  return {
-    ratings: ratings.sort((a, b) => b.strength - a.strength),
-    iterations: iter,
-    finalDelta: delta,
-    converged: delta < tol
-  };
+	const tol = opts.tolerance ?? 1e-6;
+	const maxIter = opts.maxIterations ?? 256;
+	const smoothing = opts.smoothing ?? .1;
+	const candidates = /* @__PURE__ */ new Set();
+	for (const o of outcomes) {
+		candidates.add(o.winner);
+		candidates.add(o.loser);
+	}
+	const ids = [...candidates].sort();
+	const idx = new Map(ids.map((id, i) => [id, i]));
+	const n = ids.length;
+	if (n === 0) return {
+		ratings: [],
+		iterations: 0,
+		finalDelta: 0,
+		converged: true
+	};
+	if (n === 1) return {
+		ratings: [{
+			candidateId: ids[0],
+			strength: 1,
+			logStrength: 0,
+			n: 0,
+			wins: 0
+		}],
+		iterations: 0,
+		finalDelta: 0,
+		converged: true
+	};
+	const W = Array.from({ length: n }, () => new Array(n).fill(0));
+	const N = Array.from({ length: n }, () => new Array(n).fill(0));
+	for (const o of outcomes) {
+		const i = idx.get(o.winner);
+		const j = idx.get(o.loser);
+		const w = o.weight ?? 1;
+		if (o.draw) {
+			W[i][j] += .5 * w;
+			W[j][i] += .5 * w;
+		} else W[i][j] += w;
+		N[i][j] += w;
+		N[j][i] += w;
+	}
+	const winsTotal = new Array(n).fill(0);
+	for (let i = 0; i < n; i++) {
+		for (let j = 0; j < n; j++) winsTotal[i] += W[i][j];
+		winsTotal[i] += smoothing;
+	}
+	const compsTotal = new Array(n).fill(0);
+	for (let i = 0; i < n; i++) for (let j = 0; j < n; j++) compsTotal[i] += N[i][j];
+	let theta = new Array(n).fill(1);
+	let iter = 0;
+	let delta = Infinity;
+	for (; iter < maxIter; iter++) {
+		const newTheta = new Array(n);
+		for (let i = 0; i < n; i++) {
+			let denom = 0;
+			for (let j = 0; j < n; j++) {
+				if (j === i) continue;
+				if (N[i][j] === 0) continue;
+				denom += N[i][j] / (theta[i] + theta[j]);
+			}
+			newTheta[i] = denom === 0 ? theta[i] : winsTotal[i] / denom;
+		}
+		let logSum = 0;
+		for (let i = 0; i < n; i++) logSum += Math.log(Math.max(1e-300, newTheta[i]));
+		const norm = Math.exp(logSum / n);
+		for (let i = 0; i < n; i++) newTheta[i] = newTheta[i] / norm;
+		delta = 0;
+		for (let i = 0; i < n; i++) {
+			const d = Math.abs(newTheta[i] - theta[i]) / Math.max(1e-12, theta[i]);
+			if (d > delta) delta = d;
+		}
+		theta = newTheta;
+		if (delta < tol) break;
+	}
+	const minLog = Math.min(...theta.map((t) => Math.log(Math.max(1e-300, t))));
+	return {
+		ratings: ids.map((id, i) => ({
+			candidateId: id,
+			strength: theta[i],
+			logStrength: Math.log(Math.max(1e-300, theta[i])) - minLog,
+			n: compsTotal[i],
+			wins: winsTotal[i] - smoothing
+		})).sort((a, b) => b.strength - a.strength),
+		iterations: iter,
+		finalDelta: delta,
+		converged: delta < tol
+	};
 }
 function applyEloUpdate(ratings, outcome, opts = {}) {
-  const defaultRating = opts.defaultRating ?? 1500;
-  const k = opts.kFactor ?? 32;
-  const rW = ratings.get(outcome.winner) ?? defaultRating;
-  const rL = ratings.get(outcome.loser) ?? defaultRating;
-  const expectedW = 1 / (1 + 10 ** ((rL - rW) / 400));
-  const scoreW = outcome.draw ? 0.5 : 1;
-  const scoreL = outcome.draw ? 0.5 : 0;
-  const w = outcome.weight ?? 1;
-  const winnerDelta = k * w * (scoreW - expectedW);
-  const loserDelta = k * w * (scoreL - (1 - expectedW));
-  ratings.set(outcome.winner, rW + winnerDelta);
-  ratings.set(outcome.loser, rL + loserDelta);
-  return { winnerDelta, loserDelta };
+	const defaultRating = opts.defaultRating ?? 1500;
+	const k = opts.kFactor ?? 32;
+	const rW = ratings.get(outcome.winner) ?? defaultRating;
+	const rL = ratings.get(outcome.loser) ?? defaultRating;
+	const expectedW = 1 / (1 + 10 ** ((rL - rW) / 400));
+	const scoreW = outcome.draw ? .5 : 1;
+	const scoreL = outcome.draw ? .5 : 0;
+	const w = outcome.weight ?? 1;
+	const winnerDelta = k * w * (scoreW - expectedW);
+	const loserDelta = k * w * (scoreL - (1 - expectedW));
+	ratings.set(outcome.winner, rW + winnerDelta);
+	ratings.set(outcome.loser, rL + loserDelta);
+	return {
+		winnerDelta,
+		loserDelta
+	};
 }
 function buildPairwiseFromCampaign(input) {
-  const drawMargin = input.drawMargin ?? 0;
-  const byKey = /* @__PURE__ */ new Map();
-  for (const r of input.runs) {
-    const arr = byKey.get(r.matchKey) ?? [];
-    arr.push({ candidateId: r.candidateId, score: r.score });
-    byKey.set(r.matchKey, arr);
-  }
-  const outcomes = [];
-  for (const arr of byKey.values()) {
-    for (let i = 0; i < arr.length; i++) {
-      for (let j = i + 1; j < arr.length; j++) {
-        const a = arr[i];
-        const b = arr[j];
-        if (a.candidateId === b.candidateId) continue;
-        const margin = Math.abs(a.score - b.score);
-        if (margin <= drawMargin) {
-          outcomes.push({ winner: a.candidateId, loser: b.candidateId, draw: true, weight: 1 });
-        } else {
-          const [winner, loser] = a.score > b.score ? [a, b] : [b, a];
-          outcomes.push({ winner: winner.candidateId, loser: loser.candidateId, weight: margin });
-        }
-      }
-    }
-  }
-  return outcomes;
-}
-export {
-  ABSENT_CATEGORY,
-  DEFAULT_MIN_N_PER_FEATURE,
-  DEFAULT_QUANTILE_BUCKETS,
-  FileSystemOutcomeStore,
-  InMemoryOutcomeStore,
-  PredictiveValidityResearcher,
-  REPRESENTATIVE_MIN_FIDELITY,
-  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
-};
+	const drawMargin = input.drawMargin ?? 0;
+	const byKey = /* @__PURE__ */ new Map();
+	for (const r of input.runs) {
+		const arr = byKey.get(r.matchKey) ?? [];
+		arr.push({
+			candidateId: r.candidateId,
+			score: r.score
+		});
+		byKey.set(r.matchKey, arr);
+	}
+	const outcomes = [];
+	for (const arr of byKey.values()) for (let i = 0; i < arr.length; i++) for (let j = i + 1; j < arr.length; j++) {
+		const a = arr[i];
+		const b = arr[j];
+		if (a.candidateId === b.candidateId) continue;
+		const margin = Math.abs(a.score - b.score);
+		if (margin <= drawMargin) outcomes.push({
+			winner: a.candidateId,
+			loser: b.candidateId,
+			draw: true,
+			weight: 1
+		});
+		else {
+			const [winner, loser] = a.score > b.score ? [a, b] : [b, a];
+			outcomes.push({
+				winner: winner.candidateId,
+				loser: loser.candidateId,
+				weight: margin
+			});
+		}
+	}
+	return outcomes;
+}
+//#endregion
+export { ABSENT_CATEGORY, DEFAULT_MIN_N_PER_FEATURE, DEFAULT_QUANTILE_BUCKETS, DPO_CONTEXT_REQUIREMENT, FileSystemOutcomeStore, InMemoryOutcomeStore, PRM_CONTEXT_REQUIREMENT, PredictiveValidityResearcher, REPRESENTATIVE_MIN_FIDELITY, STEP_REWARD_CONTEXT_REQUIREMENT, 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 };
+
 //# sourceMappingURL=rl.js.map