@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/trajectory-replay/index.js

@@ -1,251 +1,107 @@
-import { t as mulberry32 } from "../random-ByUSnV9w.js";
-import { t as certificationEvidenceDigest } from "../verdict-Dl0tiT1X.js";
+import { o as NotFoundError, s as ValidationError } from "../errors-BcOs5MKW.js";
+import { t as mulberry32 } from "../random-DDDcC7YU.js";
+import { t as certificationEvidenceDigest } from "../verdict-BGQmxQ8A.js";
 import { t as TraceEmitter } from "../emitter-DbMXUIVP.js";
-import { t as runCounterfactual } from "../counterfactual-Dn3veueY.js";
 import { n as InMemoryTraceStore } from "../store-BhNuLdJw.js";
 import { t as packageVersion } from "../package-version-D7lQHt_-.js";
-import { a as assertReplayableTrajectory, c as deriveFailureSignature, d as isRecordedTimeout, f as isSubmitAction, g as unreadableExitCount, h as parseRecordedReturncode, i as TIMEOUT_OBSERVATION_MARKER, l as finalRecordedOutcome, m as parseObservationOutput, n as FORMAT_ERROR_OBSERVATION_PREFIX, o as classifyObservation, p as isSubmitOnlyAction, r as SUBMIT_ACTION_SIGNATURE, s as decodeRecordedTurns, t as wrapActionForExec, u as isElidedField } from "../exec-ChJ6d5if.js";
+import { t as buildTrajectory } from "../trajectory-D_7rLrvE.js";
+import { a as classifyObservation, c as finalRecordedOutcome, d as isSubmitOnlyAction, f as parseObservationOutput, o as decodeRecordedTurns, p as parseRecordedReturncode, s as deriveFailureSignature, t as wrapActionForExec, u as isSubmitAction } from "../exec-CpbtOXVt.js";
 import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-//#region src/trajectory-replay/corpus.ts
+//#region src/counterfactual.ts
 /**
-* Corpus enumeration for batch replay verification.
+* Counterfactual replay — "what would have happened if we'd changed
+* exactly one thing at turn N?"
 *
-* A labeled trajectory corpus is a gold label file (array of trajectory
-* entries with `incorrect_stages[].incorrect_step_ids`) plus a prepared
-* directory:
-*   <prepared>/normalized/<traj_id>/steps.json   normalized steps
-*   <prepared>/normalized/<traj_id>/task.md      optional task statement
-*   <prepared>/extracted/<traj_id>/swe_raw/**    raw mini-SWE trajectory
+* The framework does NOT drive the agent — it sets up the replay
+* context (prior spans, prior state, mutation spec) and records the
+* resulting divergence. Consumers supply an `executeFrom(ctx)` callback
+* that runs their agent starting from turn N with the mutation applied.
 *
-* Only trajectories that record their environment are replayable: the raw
-* trajectory must carry `info.docker_config.base_image`. Every excluded case
-* is returned with a machine-readable reason — the batch report surfaces the
-* full exclusion table, never a silently shrunk denominator.
+* Counterfactual runs are recorded as a new Run with `layer='meta'` and
+* `parentRunId = originalRunId`, so downstream diff + correlation
+* pipelines see them natively.
 */
-/** Parses `name=<labelsPath>::<preparedDir>` (paths may contain `=`, not `::`). */
-function parseCorpusFlag(value) {
-	const eq = value.indexOf("=");
-	if (eq <= 0) throw new Error(`--corpus must be name=<labels>::<prepared>, got: ${value}`);
-	const name = value.slice(0, eq);
-	const rest = value.slice(eq + 1);
-	const sep = rest.indexOf("::");
-	if (sep <= 0 || sep === rest.length - 2) throw new Error(`--corpus must be name=<labels>::<prepared>, got: ${value}`);
+async function runCounterfactual(store, originalRunId, mutation, runner) {
+	const originalRun = await store.getRun(originalRunId);
+	if (!originalRun) throw new NotFoundError(`counterfactual: run ${originalRunId} not found`);
+	const trajectory = await buildTrajectory(store, originalRunId);
+	if (mutation.at < 0 || mutation.at >= trajectory.steps.length) throw new ValidationError(`counterfactual: mutation.at=${mutation.at} out of range [0, ${trajectory.steps.length})`);
+	const targetStep = trajectory.steps[mutation.at];
+	const mutatedStep = applyMutation(targetStep, mutation);
+	const cfEmitter = new TraceEmitter(store);
+	await cfEmitter.startRun({
+		scenarioId: originalRun.scenarioId,
+		variantId: originalRun.variantId ? `${originalRun.variantId}+cf:${mutation.kind}@${mutation.at}` : `cf:${mutation.kind}@${mutation.at}`,
+		projectId: originalRun.projectId,
+		parentRunId: originalRunId,
+		layer: "meta",
+		tags: {
+			counterfactual: "true",
+			mutationKind: mutation.kind,
+			mutationAt: String(mutation.at)
+		}
+	});
+	await runner.executeFrom({
+		originalRunId,
+		originalTrajectory: trajectory,
+		prefix: trajectory.steps.slice(0, mutation.at),
+		mutation,
+		mutatedStep
+	}, cfEmitter);
+	const counterfactual = await store.getRun(cfEmitter.runId);
+	const delta = {
+		originalOutcomeScore: originalRun.outcome?.score ?? null,
+		counterfactualOutcomeScore: counterfactual?.outcome?.score ?? null,
+		deltaScore: originalRun.outcome?.score !== void 0 && counterfactual?.outcome?.score !== void 0 ? counterfactual.outcome.score - originalRun.outcome.score : null
+	};
 	return {
-		name,
-		labelsPath: rest.slice(0, sep),
-		preparedDir: rest.slice(sep + 2)
+		counterfactualRunId: cfEmitter.runId,
+		originalRunId,
+		mutation,
+		delta
 	};
 }
-function readLabelEntries(labelsPath) {
-	const parsed = JSON.parse(readFileSync(labelsPath, "utf8"));
-	if (!Array.isArray(parsed)) throw new Error(`${labelsPath} is not a JSON array of label entries`);
-	for (const entry of parsed) if (typeof entry.traj_id !== "string") throw new Error(`${labelsPath} has an entry without a string traj_id`);
-	return parsed;
-}
-function goldIncorrectSteps(entry) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const stage of entry.incorrect_stages ?? []) for (const id of stage.incorrect_step_ids ?? []) ids.add(id);
-	return [...ids].sort((a, b) => a - b);
-}
-function findRawTrajFiles(sweRawDir) {
-	if (!existsSync(sweRawDir)) return [];
-	return readdirSync(sweRawDir, {
-		recursive: true,
-		encoding: "utf8"
-	}).filter((relative) => relative.endsWith(".traj.json")).map((relative) => join(sweRawDir, relative)).sort();
-}
-/** First non-empty output line of the trajectory's first bare `pwd` step. */
-function cwdFromPwdObservation(steps) {
-	for (const step of steps) {
-		if (step.action.trim() !== "pwd") continue;
-		const line = parseObservationOutput(step.observation).split("\n").map((l) => l.trim()).find((l) => l.startsWith("/"));
-		if (line) return line;
-	}
-	return null;
-}
-function taskStatementOf(preparedDir, trajId, raw) {
-	const taskPath = join(preparedDir, "normalized", trajId, "task.md");
-	if (existsSync(taskPath)) {
-		const text = readFileSync(taskPath, "utf8").trim();
-		if (text.length > 0) return text;
-	}
-	const userMessage = raw.messages?.find((m) => m.role === "user");
-	if (typeof userMessage?.content === "string" && userMessage.content.trim().length > 0) return userMessage.content.trim();
-	return null;
-}
-/**
-* Resolves the replay resources for one trajectory, independent of gold
-* labels — the finding wire uses this with a finding-supplied step instead.
-*/
-function resolveCaseResources(corpus, trajId) {
-	const sweRawDir = join(corpus.preparedDir, "extracted", trajId, "swe_raw");
-	const rawFiles = findRawTrajFiles(sweRawDir);
-	if (rawFiles.length === 0) return {
-		resolved: false,
-		reason: "no-swe-raw-trajectory",
-		detail: sweRawDir
-	};
-	if (rawFiles.length > 1) return {
-		resolved: false,
-		reason: "ambiguous-swe-raw-trajectory",
-		detail: rawFiles.join(", ")
-	};
-	let raw;
-	try {
-		raw = JSON.parse(readFileSync(rawFiles[0], "utf8"));
-	} catch (err) {
+function applyMutation(step, mutation) {
+	if (mutation.kind === "swap-model" && step.span.kind === "llm") {
+		const llm = step.span;
 		return {
-			resolved: false,
-			reason: "unreadable-raw-trajectory",
-			detail: `${rawFiles[0]}: ${err instanceof Error ? err.message : String(err)}`
+			...step,
+			span: {
+				...llm,
+				model: mutation.newModel
+			}
 		};
 	}
-	const dockerConfig = raw.info?.docker_config;
-	const image = dockerConfig?.base_image;
-	if (typeof image !== "string" || image.length === 0) return {
-		resolved: false,
-		reason: "no-docker-image",
-		detail: rawFiles[0]
-	};
-	const stepsPath = join(corpus.preparedDir, "normalized", trajId, "steps.json");
-	if (!existsSync(stepsPath)) return {
-		resolved: false,
-		reason: "missing-steps-json",
-		detail: stepsPath
-	};
-	const steps = JSON.parse(readFileSync(stepsPath, "utf8"));
-	const runConfigCwd = raw.info?.config?.environment?.cwd;
-	const dockerCwd = dockerConfig?.cwd;
-	let cwd;
-	let cwdSource;
-	if (typeof runConfigCwd === "string" && runConfigCwd.length > 0) {
-		cwd = runConfigCwd;
-		cwdSource = "run-config";
-	} else if (typeof dockerCwd === "string" && dockerCwd.length > 0) {
-		cwd = dockerCwd;
-		cwdSource = "docker-config";
-	} else {
-		const observed = cwdFromPwdObservation(steps);
-		if (!observed) return {
-			resolved: false,
-			reason: "cwd-underivable"
+	if (mutation.kind === "swap-tool-result" && step.span.kind === "tool") {
+		const tool = step.span;
+		return {
+			...step,
+			span: {
+				...tool,
+				result: mutation.newResult
+			}
 		};
-		cwd = observed;
-		cwdSource = "pwd-observation";
 	}
-	const recordedTimeout = raw.info?.config?.environment?.timeout;
-	return {
-		resolved: true,
-		resources: {
-			corpus: corpus.name,
-			trajId,
-			stepsPath,
-			steps,
-			taskStatement: taskStatementOf(corpus.preparedDir, trajId, raw),
-			image,
-			cwd,
-			cwdSource,
-			recordedStepTimeoutMs: typeof recordedTimeout === "number" && recordedTimeout > 0 ? recordedTimeout * 1e3 : null
-		}
-	};
-}
-/**
-* Replayable = a raw trajectory with a recorded image AND at least one gold
-* incorrect step that is a real mid-trajectory action. Gold steps whose action
-* is the submit command are skipped when choosing k (counted per case); a case
-* whose golds are ALL submit steps is excluded as gold-only-submit-step.
-* Exclusion reasons are reported in resolution order:
-* raw trajectory → image → gold labels → steps.json → k range → cwd.
-*/
-function enumerateReplayableCases(corpora) {
-	const replayable = [];
-	const excluded = [];
-	let labelEntryCount = 0;
-	for (const corpus of corpora) for (const entry of readLabelEntries(corpus.labelsPath)) {
-		labelEntryCount += 1;
-		const trajId = entry.traj_id;
-		const resolution = resolveCaseResources(corpus, trajId);
-		if (!resolution.resolved) {
-			excluded.push({
-				corpus: corpus.name,
-				trajId,
-				reason: resolution.reason,
-				detail: resolution.detail
-			});
-			continue;
-		}
-		const gold = goldIncorrectSteps(entry);
-		if (gold.length === 0) {
-			excluded.push({
-				corpus: corpus.name,
-				trajId,
-				reason: "no-gold-incorrect-step"
-			});
-			continue;
-		}
-		const resources = resolution.resources;
-		let submitGoldsSkipped = 0;
-		let target = null;
-		let missingGoldId = null;
-		for (const goldId of gold) {
-			const step = resources.steps.find((s) => s.step_id === goldId);
-			if (!step) {
-				missingGoldId = goldId;
-				break;
-			}
-			if (step.action.trim() === "submit" || isSubmitOnlyAction(step.action)) {
-				submitGoldsSkipped += 1;
-				continue;
+	if (mutation.kind === "inject-system-message" && step.span.kind === "llm") {
+		const llm = step.span;
+		return {
+			...step,
+			span: {
+				...llm,
+				messages: [{
+					role: "system",
+					content: mutation.content
+				}, ...llm.messages]
 			}
-			target = step;
-			break;
-		}
-		if (missingGoldId !== null) {
-			excluded.push({
-				corpus: corpus.name,
-				trajId,
-				reason: "gold-step-outside-steps",
-				detail: `k=${missingGoldId}, steps=${resources.steps.length}`
-			});
-			continue;
-		}
-		if (!target) {
-			excluded.push({
-				corpus: corpus.name,
-				trajId,
-				reason: "gold-only-submit-step",
-				detail: `${submitGoldsSkipped} gold step(s), all submit commands`
-			});
-			continue;
-		}
-		const recordedReturncodeAtK = parseRecordedReturncode(target.observation);
-		if (recordedReturncodeAtK === null) {
-			excluded.push({
-				corpus: corpus.name,
-				trajId,
-				reason: "no-recorded-returncode-at-k",
-				detail: `k=${target.step_id}; arm A cannot confirm execution without a recorded returncode`
-			});
-			continue;
-		}
-		replayable.push({
-			...resources,
-			goldIncorrectSteps: gold,
-			k: target.step_id,
-			submitGoldsSkipped,
-			recordedReturncodeAtK
-		});
+		};
 	}
-	return {
-		replayable,
-		excluded,
-		labelEntryCount
-	};
+	if (mutation.kind === "custom") return mutation.apply(step);
+	return step;
 }
 //#endregion
 //#region src/trajectory-replay/fix.ts
@@ -525,129 +381,9 @@ async function runFixLoop(caller, input, executor, options) {
 	};
 }
 //#endregion
-//#region src/trajectory-replay/image-preparer.ts
+//#region src/trajectory-replay/verify.ts
 /**
-* Replay-ready image derivation.
-*
-* A recorded trajectory names the image it ran in, but the image is not always
-* runnable as-is: sandbox platforms pin customer commands to a non-root
-* identity, so a root-owned working tree must be chowned before the replay can
-* write to it. `ImagePreparer` is that step, injectable so a consumer whose
-* images are already replay-ready supplies its own no-op or none at all.
-*/
-const execFileAsync = promisify(execFile);
-function derivedImageTag(image, cwd) {
-	return `ctb-replay:${createHash("sha256").update(`${image}\n${cwd}`).digest("hex").slice(0, 12)}-uid1000`;
-}
-/**
-* Pulls the base image when absent and builds `FROM <base>; RUN chown -R
-* 1000:1000 <cwd>` tagged by content hash, so repeated batches reuse both
-* the pull and the build. cwd `/` skips the chown (never chown -R /) and
-* replays on the base image directly.
-*/
-function dockerImagePreparer(options = {}) {
-	const pullTimeoutMs = options.pullTimeoutMs ?? 12e5;
-	const buildTimeoutMs = options.buildTimeoutMs ?? 9e5;
-	const imageExists = async (tag) => {
-		try {
-			await execFileAsync("docker", [
-				"image",
-				"inspect",
-				tag
-			], { maxBuffer: 8388608 });
-			return true;
-		} catch {
-			return false;
-		}
-	};
-	const errorTail = (err) => {
-		return (err && typeof err === "object" && "stderr" in err && typeof err.stderr === "string" && err.stderr.length > 0 ? err.stderr : err instanceof Error ? err.message : String(err)).trim().split("\n").slice(-3).join(" | ").slice(0, 400);
-	};
-	return { async ensure(image, cwd) {
-		if (cwd === "/") {
-			if (await imageExists(image)) return {
-				succeeded: true,
-				value: {
-					derivedImage: image,
-					pulled: false,
-					built: false
-				}
-			};
-			try {
-				await execFileAsync("docker", ["pull", image], {
-					timeout: pullTimeoutMs,
-					maxBuffer: 33554432
-				});
-			} catch (err) {
-				return {
-					succeeded: false,
-					error: `pull ${image}: ${errorTail(err)}`
-				};
-			}
-			return {
-				succeeded: true,
-				value: {
-					derivedImage: image,
-					pulled: true,
-					built: false
-				}
-			};
-		}
-		const derived = derivedImageTag(image, cwd);
-		if (await imageExists(derived)) return {
-			succeeded: true,
-			value: {
-				derivedImage: derived,
-				pulled: false,
-				built: false
-			}
-		};
-		let pulled = false;
-		if (!await imageExists(image)) try {
-			await execFileAsync("docker", ["pull", image], {
-				timeout: pullTimeoutMs,
-				maxBuffer: 33554432
-			});
-			pulled = true;
-		} catch (err) {
-			return {
-				succeeded: false,
-				error: `pull ${image}: ${errorTail(err)}`
-			};
-		}
-		const contextDir = mkdtempSync(join(tmpdir(), "ctb-replay-image-"));
-		const quotedCwd = `'${cwd.replaceAll("'", `'\\''`)}'`;
-		writeFileSync(join(contextDir, "Dockerfile"), `FROM ${image}\nRUN chown -R 1000:1000 ${quotedCwd}\n`);
-		try {
-			await execFileAsync("docker", [
-				"build",
-				"-t",
-				derived,
-				contextDir
-			], {
-				timeout: buildTimeoutMs,
-				maxBuffer: 33554432
-			});
-		} catch (err) {
-			return {
-				succeeded: false,
-				error: `build ${derived} from ${image}: ${errorTail(err)}`
-			};
-		}
-		return {
-			succeeded: true,
-			value: {
-				derivedImage: derived,
-				pulled,
-				built: true
-			}
-		};
-	} };
-}
-//#endregion
-//#region src/trajectory-replay/verify.ts
-/**
-* Execution-replay verification for recorded shell trajectories.
+* Execution-replay verification for recorded shell trajectories.
 *
 * Turns a cited claim ("step k is the error-critical step") into an executed
 * proof: replay steps 1..k-1 inside the trajectory's own image, then
@@ -1037,33 +773,8 @@ function renderReport(verdict, target, armA, armB) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/trajectory-replay/batch.ts
-/**
-* Batch replay verification across gold-labeled trajectory corpora.
-*
-* For every replayable case (a raw trajectory with a recorded image AND at
-* least one gold incorrect step) the batch:
-*   1. derives the replay-ready image through the injected `ImagePreparer`,
-*   2. replays the prefix and runs arm A — the recorded gold step k, and
-*   3. optionally generates a corrected command with one LLM call and runs
-*      arm B in its own fresh session.
-*
-* Headline metrics:
-*   replayability rate — fraction of replayable cases where the prefix
-*     replays within the divergence tolerance AND arm A reproduces a
-*     recorded failure at k; a zero exit without an error signature is not
-*     evidence of failure;
-*   prefix fidelity — executed prefix steps and the share of them that did
-*     not confirm the recording, split by kind. A corpus whose recordings
-*     carry no returncodes shows up here as unknown-expectation steps, never
-*     as a clean replay;
-*   fix-flip rate — fraction of arm-B-executed cases where the failure
-*     vanished (exit 0, signature absent).
-*
-* Image pulls and execs run strictly serially: pulls contend on disk and
-* registry bandwidth, and serial cases keep wall-time attribution per case
-* honest. Pull failures are report rows, never silent skips.
-*/
+//#region src/trajectory-replay/batch-fix.ts
+/** Arm B and the counterfactual fix phase of a replay batch. */
 function seededSample(items, size, seed) {
 	const pool = [...items];
 	const random = mulberry32(seed);
@@ -1116,366 +827,793 @@ async function executeArmB(replayCase, fixCommand, backend, signature, stepTimeo
 		stderr: exec.stderr
 	};
 }
-function rate(numerator, denominator) {
-	return denominator > 0 ? numerator / denominator : null;
+/** A fix outcome with nothing measured; callers name what they did measure. */
+function fixResult(measured) {
+	return {
+		attempted: true,
+		sampledOut: false,
+		command: null,
+		llmError: null,
+		usage: null,
+		armBExit: null,
+		armBPrefixExecuted: null,
+		armBPrefixDivergences: null,
+		armBPrefixDivergencePct: null,
+		failureVanished: null,
+		armBError: null,
+		attempts: null,
+		flippedAtAttempt: null,
+		...measured
+	};
 }
-async function runReplayBatch(options) {
-	const onProgress = options.onProgress ?? (() => {});
-	const enumeration = enumerateReplayableCases(options.corpora);
-	let selected = enumeration.replayable;
-	if (options.caseFilter) selected = selected.filter((c) => c.trajId.includes(options.caseFilter));
-	if (options.caseLimit !== void 0) selected = selected.slice(0, options.caseLimit);
-	onProgress(`enumerated ${enumeration.labelEntryCount} label entries → ${enumeration.replayable.length} replayable, ${enumeration.excluded.length} excluded; executing ${selected.length}`);
-	const preparer = options.preparer ?? dockerImagePreparer();
-	const backendFactory = options.backendFactory;
-	mkdirSync(options.out, { recursive: true });
-	const progressPath = join(options.out, "cases.jsonl");
-	const rows = [];
-	const pullFailures = [];
-	const verdictByTraj = /* @__PURE__ */ new Map();
-	for (const [index, replayCase] of selected.entries()) {
-		const caseStart = Date.now();
-		const label = `[${index + 1}/${selected.length}] ${replayCase.corpus}/${replayCase.trajId}`;
-		onProgress(`${label}: preparing image ${replayCase.image}`);
-		const preparation = await preparer.ensure(replayCase.image, replayCase.cwd);
-		const base = {
-			corpus: replayCase.corpus,
-			trajId: replayCase.trajId,
-			image: replayCase.image,
-			cwd: replayCase.cwd,
-			cwdSource: replayCase.cwdSource,
-			k: replayCase.k,
-			stepCount: replayCase.steps.length,
-			goldIncorrectSteps: replayCase.goldIncorrectSteps,
-			submitGoldsSkipped: replayCase.submitGoldsSkipped,
-			recordedReturncodeAtK: replayCase.recordedReturncodeAtK
+function runArmB(run, fixCase, command, label) {
+	const { options } = run;
+	return executeArmB(fixCase.replayCase, command, options.backendFactory(fixCase.row.derivedImage), fixCase.signature, fixCase.stepTimeoutMs, options.prefixLimit, (message) => run.onProgress(`${label}: ${message}`));
+}
+/** The fix summary a finished loop reports: the flipping attempt, else the last executed one, else why it stopped. */
+function loopFixResult(result, usage) {
+	const summary = (result.flippedAtAttempt !== null ? result.attempts.find((a) => a.attempt === result.flippedAtAttempt) : null) ?? [...result.attempts].reverse().find((a) => a.executed) ?? null;
+	const lastRecord = result.attempts.at(-1) ?? null;
+	if (summary) return fixResult({
+		command: summary.command,
+		usage,
+		armBExit: summary.exitCode,
+		armBPrefixExecuted: summary.prefixExecuted,
+		armBPrefixDivergences: summary.prefixDivergences,
+		armBPrefixDivergencePct: summary.prefixDivergencePct,
+		failureVanished: summary.failureVanished,
+		attempts: result.attempts,
+		flippedAtAttempt: result.flippedAtAttempt
+	});
+	if (result.aborted) return fixResult({
+		command: lastRecord?.command ?? null,
+		usage,
+		armBError: lastRecord?.armBError ?? "sandbox error",
+		attempts: result.attempts
+	});
+	return fixResult({
+		llmError: lastRecord?.llmError ?? "no attempt produced a runnable fix",
+		usage,
+		attempts: result.attempts
+	});
+}
+/** Iterative fix: failed arms feed their real output into up to `fixAttempts` prompts. */
+async function fixByLoop(run, fixCase, caller, tally) {
+	const { options, onProgress } = run;
+	const { row, label, caseOut } = fixCase;
+	const fixAttempts = options.fixAttempts ?? 3;
+	onProgress(`${label}: fix loop (budget ${fixAttempts} attempts)`);
+	const result = await runFixLoop(caller, fixCase.promptInput, async (command, attempt) => {
+		onProgress(`${label}: attempt ${attempt} arm B — ${command.split("\n")[0].slice(0, 120)}`);
+		const armB = await runArmB(run, fixCase, command, `${label}: attempt ${attempt}`);
+		mkdirSync(caseOut, { recursive: true });
+		writeFileSync(join(caseOut, `armB-attempt${attempt}-result.json`), `${JSON.stringify({
+			command,
+			...armB
+		}, null, 2)}\n`);
+		writeFileSync(join(caseOut, "armB-result.json"), `${JSON.stringify({
+			command,
+			attempt,
+			...armB
+		}, null, 2)}\n`);
+		return armB;
+	}, {
+		maxAttempts: fixAttempts,
+		onProgress: (message) => onProgress(`${label}: ${message}`)
+	});
+	tally.calls += result.llmCalls;
+	tally.failures += result.llmFailures;
+	tally.promptTokens += result.promptTokens;
+	tally.completionTokens += result.completionTokens;
+	tally.callsWithoutUsage += result.callsWithoutUsage;
+	const usage = result.promptTokens + result.completionTokens > 0 ? {
+		promptTokens: result.promptTokens,
+		completionTokens: result.completionTokens
+	} : null;
+	onProgress(`${label}: loop done — flipped=${result.flipped}` + (result.flippedAtAttempt !== null ? ` at attempt ${result.flippedAtAttempt}` : "") + ` (${result.llmCalls} calls, ${result.attempts.filter((a) => a.executed).length} arms)`);
+	return {
+		...row,
+		fix: loopFixResult(result, usage)
+	};
+}
+/** One-shot fix: a single generated command, one arm B. */
+async function fixByOneShot(run, fixCase, caller, tally) {
+	const { onProgress } = run;
+	const { row, label, caseOut } = fixCase;
+	onProgress(`${label}: generating corrected command`);
+	tally.calls += 1;
+	const generated = await generateFixCommand(caller, fixCase.promptInput);
+	if (!generated.succeeded) {
+		tally.failures += 1;
+		onProgress(`${label}: LLM failed — ${generated.error.slice(0, 200)}`);
+		return {
+			...row,
+			fix: fixResult({ llmError: generated.error })
 		};
-		if (!preparation.succeeded) {
-			pullFailures.push({
-				corpus: replayCase.corpus,
-				trajId: replayCase.trajId,
-				image: replayCase.image,
-				error: preparation.error
+	}
+	if (generated.value.usage === null || generated.value.usage === void 0) tally.callsWithoutUsage += 1;
+	tally.promptTokens += generated.value.usage?.promptTokens ?? 0;
+	tally.completionTokens += generated.value.usage?.completionTokens ?? 0;
+	onProgress(`${label}: arm B — ${generated.value.command.split("\n")[0].slice(0, 120)}`);
+	try {
+		const armB = await runArmB(run, fixCase, generated.value.command, label);
+		const fix = fixResult({
+			command: generated.value.command,
+			usage: generated.value.usage,
+			armBExit: armB.exitCode,
+			armBPrefixExecuted: armB.prefixExecuted,
+			armBPrefixDivergences: armB.prefixDivergences,
+			armBPrefixDivergencePct: armB.prefixDivergencePct,
+			failureVanished: armB.failureVanished,
+			flippedAtAttempt: armB.failureVanished ? 1 : null
+		});
+		mkdirSync(caseOut, { recursive: true });
+		writeFileSync(join(caseOut, "armB-result.json"), `${JSON.stringify({
+			command: generated.value.command,
+			...armB
+		}, null, 2)}\n`);
+		onProgress(`${label}: armB exit=${armB.exitCode} failureVanished=${armB.failureVanished}`);
+		return {
+			...row,
+			fix
+		};
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		onProgress(`${label}: arm B error — ${message.slice(0, 200)}`);
+		return {
+			...row,
+			fix: fixResult({
+				command: generated.value.command,
+				usage: generated.value.usage,
+				armBError: message.slice(0, 500)
+			})
+		};
+	}
+}
+/** Phase 2: counterfactual fixes for the cases where arm A reproduced, capped and seeded-sampled. */
+async function runFixPhase(run, selected, rows, verdicts) {
+	const { options, onProgress } = run;
+	const caller = options.fixCaller;
+	if (!caller) throw new Error(`trajectory-replay: fix=${options.fix} requires a fixCaller`);
+	const maxFixCases = options.maxFixCases ?? 30;
+	const seed = options.seed ?? 17;
+	const eligible = rows.filter((r) => r.status === "ok" && r.replayed);
+	const sampled = eligible.length > maxFixCases ? seededSample(eligible, maxFixCases, seed) : new Set(eligible);
+	if (eligible.length > maxFixCases) onProgress(`fix phase: ${eligible.length} eligible > cap ${maxFixCases}; seeded sample (seed=${seed})`);
+	const tally = {
+		calls: 0,
+		failures: 0,
+		promptTokens: 0,
+		completionTokens: 0,
+		callsWithoutUsage: 0
+	};
+	for (const row of eligible) {
+		const index = rows.indexOf(row);
+		if (!sampled.has(row)) {
+			rows[index] = {
+				...row,
+				fix: fixResult({
+					attempted: false,
+					sampledOut: true
+				})
+			};
+			continue;
+		}
+		const replayCase = selected.find((c) => c.trajId === row.trajId && c.corpus === row.corpus);
+		const fixCase = {
+			row,
+			replayCase,
+			label: `fix ${row.corpus}/${row.trajId}`,
+			signature: verdicts.get(row.trajId)?.signature ?? null,
+			stepTimeoutMs: options.stepTimeoutMs ?? replayCase.recordedStepTimeoutMs ?? 12e4,
+			caseOut: join(options.out, caseOutDirName(row)),
+			promptInput: {
+				taskStatement: replayCase.taskStatement,
+				steps: replayCase.steps,
+				k: replayCase.k
+			}
+		};
+		rows[index] = options.fix === "loop" ? await fixByLoop(run, fixCase, caller, tally) : await fixByOneShot(run, fixCase, caller, tally);
+	}
+	return {
+		model: options.fixModelLabel ?? "unknown",
+		...tally
+	};
+}
+//#endregion
+//#region src/trajectory-replay/batch-report.ts
+function pct(value) {
+	return value === null ? "—" : `${(value * 100).toFixed(1)}%`;
+}
+function renderBatchReport(report) {
+	const lines = [];
+	const { headline, totals } = report;
+	lines.push("# Replay-verify batch report");
+	lines.push("");
+	lines.push(`Generated ${report.generatedAt}.`);
+	lines.push("");
+	lines.push("## Headline");
+	lines.push("");
+	const fidelity = headline.prefixFidelity;
+	lines.push(`- **Replayability rate: ${pct(headline.replayabilityRate.value)}** (${headline.replayabilityRate.numerator}/${headline.replayabilityRate.denominator} replayable cases where the prefix replayed within ${fidelity.tolerancePct}% divergence AND arm A reproduced an observed failure at the gold step k).`);
+	lines.push(`- Signature-strict rate: ${pct(headline.signatureStrictRate.value)} (${headline.signatureStrictRate.numerator}/${headline.signatureStrictRate.denominator}; additionally requires the recorded error substring in arm A output).`);
+	lines.push(`- **Prefix divergence: ${fidelity.divergencePct === null ? "—" : `${fidelity.divergencePct}%`}** (${fidelity.divergentSteps}/${fidelity.executedSteps} executed prefix steps did not confirm the recording: ${fidelity.returncodeMismatches} returncode mismatches, ${fidelity.unknownExpectations} with no recorded returncode to check). ${fidelity.casesWithinTolerance}/${fidelity.casesExecuted} executed cases are within the ${fidelity.tolerancePct}% tolerance.`);
+	if (headline.fixFlipRate) lines.push(`- **Fix-flip rate: ${pct(headline.fixFlipRate.value)}** (${headline.fixFlipRate.numerator}/${headline.fixFlipRate.denominator} arm-B-executed cases where the generated fix made the failure vanish).`);
+	if (headline.fixFlipRateNonzeroRc) lines.push(`- Fix-flip rate on recorded-rc≠0 cases: ${pct(headline.fixFlipRateNonzeroRc.value)} (${headline.fixFlipRateNonzeroRc.numerator}/${headline.fixFlipRateNonzeroRc.denominator}; real recorded failures — a gold step recorded with rc 0 flips vacuously).`);
+	if (headline.fixFlipAttempt1) lines.push(`- Fix-flip@1: ${pct(headline.fixFlipAttempt1.value)} (${headline.fixFlipAttempt1.numerator}/${headline.fixFlipAttempt1.denominator} cases whose attempt 1 executed — the one-shot-comparable number).`);
+	if (headline.flipsByAttempt && Object.keys(headline.flipsByAttempt).length > 0) {
+		const parts = Object.entries(headline.flipsByAttempt).sort((a, b) => Number(a[0]) - Number(b[0])).map(([attempt, count]) => `attempt ${attempt}: ${count}`);
+		lines.push(`- Flips by attempt: ${parts.join(", ")}.`);
+	}
+	lines.push("");
+	lines.push("## Enumeration");
+	lines.push("");
+	lines.push(`${totals.labelEntries} label entries across ${report.corpora.length} corpora → ${totals.replayable} replayable (SWE-style docker image + ≥1 gold incorrect step), ${totals.executed} executed.`);
+	lines.push("");
+	lines.push("| exclusion reason | count |");
+	lines.push("| --- | --- |");
+	for (const [reason, count] of Object.entries(totals.excludedByReason).sort((a, b) => b[1] - a[1])) lines.push(`| ${reason} | ${count} |`);
+	const submitEntries = Object.entries(totals.submitGoldsByCorpus);
+	if (submitEntries.length > 0) {
+		lines.push("");
+		lines.push("Submit-command golds are never counterfactual targets (a gold on the submit step marks a bad submit decision, not a failed command):");
+		lines.push("");
+		lines.push("| corpus | cases excluded (all golds = submit) | golds skipped within replayable cases |");
+		lines.push("| --- | --- | --- |");
+		for (const [corpus, stats] of submitEntries.sort((a, b) => a[0].localeCompare(b[0]))) lines.push(`| ${corpus} | ${stats.submitOnlyCases} | ${stats.goldsSkippedWithinReplayable} |`);
+	}
+	if (report.pullFailures.length > 0) {
+		lines.push("");
+		lines.push("## Image pull/build failures");
+		lines.push("");
+		lines.push("| corpus | trajectory | image | error |");
+		lines.push("| --- | --- | --- | --- |");
+		for (const failure of report.pullFailures) lines.push(`| ${failure.corpus} | ${failure.trajId} | \`${failure.image}\` | ${failure.error.replaceAll("|", "\\|")} |`);
+	}
+	lines.push("");
+	lines.push("## Per-case results");
+	lines.push("");
+	lines.push("| corpus | trajectory | k | rc@k | prefix | confirmed | rc mismatch | unknown rc | div | div% | armA exit | rc match | sig match | replayed | fix | armB exit | armB div% | vanished | wall s |");
+	lines.push(`| ${Array(19).fill("---").join(" | ")} |`);
+	for (const row of report.cases) {
+		const fix = row.fix;
+		const fixCell = !fix ? "—" : fix.sampledOut ? "sampled-out" : fix.llmError ? "llm-failed" : fix.armBError ? "armB-error" : fix.attempts ? fix.flippedAtAttempt !== null ? `flip@${fix.flippedAtAttempt}` : `exhausted(${fix.attempts.length})` : "generated";
+		lines.push([
+			row.corpus,
+			row.trajId.length > 48 ? `${row.trajId.slice(0, 45)}…` : row.trajId,
+			row.k,
+			row.recordedReturncodeAtK ?? "null",
+			row.prefixExecuted ?? "—",
+			row.prefixConfirmed ?? "—",
+			row.prefixReturncodeMismatches ?? "—",
+			row.prefixUnknownExpectations ?? "—",
+			row.prefixDivergences ?? "—",
+			row.prefixDivergencePct ?? "—",
+			row.status === "ok" ? row.armAExit : row.status,
+			row.armAReturncodeMatch ? "yes" : "no",
+			row.armASignatureMatch ? "yes" : "no",
+			row.replayed ? "**yes**" : "no",
+			fixCell,
+			fix?.armBExit ?? "—",
+			fix?.armBPrefixDivergencePct ?? "—",
+			fix?.failureVanished === null || fix === null ? "—" : fix.failureVanished ? "**yes**" : "no",
+			(row.wallMs / 1e3).toFixed(1)
+		].join(" | "));
+	}
+	if (report.llm) {
+		lines.push("");
+		lines.push("## LLM fix generation");
+		lines.push("");
+		lines.push(`Model ${report.llm.model}: ${report.llm.calls} calls (${report.llm.failures} failed), ${report.llm.promptTokens} prompt + ${report.llm.completionTokens} completion tokens.`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/trajectory-replay/corpus.ts
+/**
+* Corpus enumeration for batch replay verification.
+*
+* A labeled trajectory corpus is a gold label file (array of trajectory
+* entries with `incorrect_stages[].incorrect_step_ids`) plus a prepared
+* directory:
+*   <prepared>/normalized/<traj_id>/steps.json   normalized steps
+*   <prepared>/normalized/<traj_id>/task.md      optional task statement
+*   <prepared>/extracted/<traj_id>/swe_raw/**    raw mini-SWE trajectory
+*
+* Only trajectories that record their environment are replayable: the raw
+* trajectory must carry `info.docker_config.base_image`. Every excluded case
+* is returned with a machine-readable reason — the batch report surfaces the
+* full exclusion table, never a silently shrunk denominator.
+*/
+function readLabelEntries(labelsPath) {
+	const parsed = JSON.parse(readFileSync(labelsPath, "utf8"));
+	if (!Array.isArray(parsed)) throw new Error(`${labelsPath} is not a JSON array of label entries`);
+	for (const entry of parsed) if (typeof entry.traj_id !== "string") throw new Error(`${labelsPath} has an entry without a string traj_id`);
+	return parsed;
+}
+function goldIncorrectSteps(entry) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const stage of entry.incorrect_stages ?? []) for (const id of stage.incorrect_step_ids ?? []) ids.add(id);
+	return [...ids].sort((a, b) => a - b);
+}
+function findRawTrajFiles(sweRawDir) {
+	if (!existsSync(sweRawDir)) return [];
+	return readdirSync(sweRawDir, {
+		recursive: true,
+		encoding: "utf8"
+	}).filter((relative) => relative.endsWith(".traj.json")).map((relative) => join(sweRawDir, relative)).sort();
+}
+/** First non-empty output line of the trajectory's first bare `pwd` step. */
+function cwdFromPwdObservation(steps) {
+	for (const step of steps) {
+		if (step.action.trim() !== "pwd") continue;
+		const line = parseObservationOutput(step.observation).split("\n").map((l) => l.trim()).find((l) => l.startsWith("/"));
+		if (line) return line;
+	}
+	return null;
+}
+function taskStatementOf(preparedDir, trajId, raw) {
+	const taskPath = join(preparedDir, "normalized", trajId, "task.md");
+	if (existsSync(taskPath)) {
+		const text = readFileSync(taskPath, "utf8").trim();
+		if (text.length > 0) return text;
+	}
+	const userMessage = raw.messages?.find((m) => m.role === "user");
+	if (typeof userMessage?.content === "string" && userMessage.content.trim().length > 0) return userMessage.content.trim();
+	return null;
+}
+/**
+* Resolves the replay resources for one trajectory, independent of gold
+* labels — the finding wire uses this with a finding-supplied step instead.
+*/
+function resolveCaseResources(corpus, trajId) {
+	const sweRawDir = join(corpus.preparedDir, "extracted", trajId, "swe_raw");
+	const rawFiles = findRawTrajFiles(sweRawDir);
+	if (rawFiles.length === 0) return {
+		resolved: false,
+		reason: "no-swe-raw-trajectory",
+		detail: sweRawDir
+	};
+	if (rawFiles.length > 1) return {
+		resolved: false,
+		reason: "ambiguous-swe-raw-trajectory",
+		detail: rawFiles.join(", ")
+	};
+	let raw;
+	try {
+		raw = JSON.parse(readFileSync(rawFiles[0], "utf8"));
+	} catch (err) {
+		return {
+			resolved: false,
+			reason: "unreadable-raw-trajectory",
+			detail: `${rawFiles[0]}: ${err instanceof Error ? err.message : String(err)}`
+		};
+	}
+	const dockerConfig = raw.info?.docker_config;
+	const image = dockerConfig?.base_image;
+	if (typeof image !== "string" || image.length === 0) return {
+		resolved: false,
+		reason: "no-docker-image",
+		detail: rawFiles[0]
+	};
+	const stepsPath = join(corpus.preparedDir, "normalized", trajId, "steps.json");
+	if (!existsSync(stepsPath)) return {
+		resolved: false,
+		reason: "missing-steps-json",
+		detail: stepsPath
+	};
+	const steps = JSON.parse(readFileSync(stepsPath, "utf8"));
+	const runConfigCwd = raw.info?.config?.environment?.cwd;
+	const dockerCwd = dockerConfig?.cwd;
+	let cwd;
+	let cwdSource;
+	if (typeof runConfigCwd === "string" && runConfigCwd.length > 0) {
+		cwd = runConfigCwd;
+		cwdSource = "run-config";
+	} else if (typeof dockerCwd === "string" && dockerCwd.length > 0) {
+		cwd = dockerCwd;
+		cwdSource = "docker-config";
+	} else {
+		const observed = cwdFromPwdObservation(steps);
+		if (!observed) return {
+			resolved: false,
+			reason: "cwd-underivable"
+		};
+		cwd = observed;
+		cwdSource = "pwd-observation";
+	}
+	const recordedTimeout = raw.info?.config?.environment?.timeout;
+	return {
+		resolved: true,
+		resources: {
+			corpus: corpus.name,
+			trajId,
+			stepsPath,
+			steps,
+			taskStatement: taskStatementOf(corpus.preparedDir, trajId, raw),
+			image,
+			cwd,
+			cwdSource,
+			recordedStepTimeoutMs: typeof recordedTimeout === "number" && recordedTimeout > 0 ? recordedTimeout * 1e3 : null
+		}
+	};
+}
+/**
+* Replayable = a raw trajectory with a recorded image AND at least one gold
+* incorrect step that is a real mid-trajectory action. Gold steps whose action
+* is the submit command are skipped when choosing k (counted per case); a case
+* whose golds are ALL submit steps is excluded as gold-only-submit-step.
+* Exclusion reasons are reported in resolution order:
+* raw trajectory → image → gold labels → steps.json → k range → cwd.
+*/
+function enumerateReplayableCases(corpora) {
+	const replayable = [];
+	const excluded = [];
+	let labelEntryCount = 0;
+	for (const corpus of corpora) for (const entry of readLabelEntries(corpus.labelsPath)) {
+		labelEntryCount += 1;
+		const trajId = entry.traj_id;
+		const resolution = resolveCaseResources(corpus, trajId);
+		if (!resolution.resolved) {
+			excluded.push({
+				corpus: corpus.name,
+				trajId,
+				reason: resolution.reason,
+				detail: resolution.detail
+			});
+			continue;
+		}
+		const gold = goldIncorrectSteps(entry);
+		if (gold.length === 0) {
+			excluded.push({
+				corpus: corpus.name,
+				trajId,
+				reason: "no-gold-incorrect-step"
+			});
+			continue;
+		}
+		const resources = resolution.resources;
+		let submitGoldsSkipped = 0;
+		let target = null;
+		let missingGoldId = null;
+		for (const goldId of gold) {
+			const step = resources.steps.find((s) => s.step_id === goldId);
+			if (!step) {
+				missingGoldId = goldId;
+				break;
+			}
+			if (step.action.trim() === "submit" || isSubmitOnlyAction(step.action)) {
+				submitGoldsSkipped += 1;
+				continue;
+			}
+			target = step;
+			break;
+		}
+		if (missingGoldId !== null) {
+			excluded.push({
+				corpus: corpus.name,
+				trajId,
+				reason: "gold-step-outside-steps",
+				detail: `k=${missingGoldId}, steps=${resources.steps.length}`
+			});
+			continue;
+		}
+		if (!target) {
+			excluded.push({
+				corpus: corpus.name,
+				trajId,
+				reason: "gold-only-submit-step",
+				detail: `${submitGoldsSkipped} gold step(s), all submit commands`
+			});
+			continue;
+		}
+		const recordedReturncodeAtK = parseRecordedReturncode(target.observation);
+		if (recordedReturncodeAtK === null) {
+			excluded.push({
+				corpus: corpus.name,
+				trajId,
+				reason: "no-recorded-returncode-at-k",
+				detail: `k=${target.step_id}; arm A cannot confirm execution without a recorded returncode`
+			});
+			continue;
+		}
+		replayable.push({
+			...resources,
+			goldIncorrectSteps: gold,
+			k: target.step_id,
+			submitGoldsSkipped,
+			recordedReturncodeAtK
+		});
+	}
+	return {
+		replayable,
+		excluded,
+		labelEntryCount
+	};
+}
+//#endregion
+//#region src/trajectory-replay/image-preparer.ts
+/**
+* Replay-ready image derivation.
+*
+* A recorded trajectory names the image it ran in, but the image is not always
+* runnable as-is: sandbox platforms pin customer commands to a non-root
+* identity, so a root-owned working tree must be chowned before the replay can
+* write to it. `ImagePreparer` is that step, injectable so a consumer whose
+* images are already replay-ready supplies its own no-op or none at all.
+*/
+const execFileAsync = promisify(execFile);
+function derivedImageTag(image, cwd) {
+	return `ctb-replay:${createHash("sha256").update(`${image}\n${cwd}`).digest("hex").slice(0, 12)}-uid1000`;
+}
+/**
+* Pulls the base image when absent and builds `FROM <base>; RUN chown -R
+* 1000:1000 <cwd>` tagged by content hash, so repeated batches reuse both
+* the pull and the build. cwd `/` skips the chown (never chown -R /) and
+* replays on the base image directly.
+*/
+function dockerImagePreparer(options = {}) {
+	const pullTimeoutMs = options.pullTimeoutMs ?? 12e5;
+	const buildTimeoutMs = options.buildTimeoutMs ?? 9e5;
+	const imageExists = async (tag) => {
+		try {
+			await execFileAsync("docker", [
+				"image",
+				"inspect",
+				tag
+			], { maxBuffer: 8388608 });
+			return true;
+		} catch {
+			return false;
+		}
+	};
+	const errorTail = (err) => {
+		return (err && typeof err === "object" && "stderr" in err && typeof err.stderr === "string" && err.stderr.length > 0 ? err.stderr : err instanceof Error ? err.message : String(err)).trim().split("\n").slice(-3).join(" | ").slice(0, 400);
+	};
+	return { async ensure(image, cwd) {
+		if (cwd === "/") {
+			if (await imageExists(image)) return {
+				succeeded: true,
+				value: {
+					derivedImage: image,
+					pulled: false,
+					built: false
+				}
+			};
+			try {
+				await execFileAsync("docker", ["pull", image], {
+					timeout: pullTimeoutMs,
+					maxBuffer: 33554432
+				});
+			} catch (err) {
+				return {
+					succeeded: false,
+					error: `pull ${image}: ${errorTail(err)}`
+				};
+			}
+			return {
+				succeeded: true,
+				value: {
+					derivedImage: image,
+					pulled: true,
+					built: false
+				}
+			};
+		}
+		const derived = derivedImageTag(image, cwd);
+		if (await imageExists(derived)) return {
+			succeeded: true,
+			value: {
+				derivedImage: derived,
+				pulled: false,
+				built: false
+			}
+		};
+		let pulled = false;
+		if (!await imageExists(image)) try {
+			await execFileAsync("docker", ["pull", image], {
+				timeout: pullTimeoutMs,
+				maxBuffer: 33554432
 			});
-			const row = {
-				...base,
-				derivedImage: null,
-				signature: null,
-				status: "image-unavailable",
-				error: preparation.error,
-				imagePulled: false,
-				imageBuilt: false,
-				prefixExecuted: null,
-				prefixDivergences: null,
-				prefixDivergencePct: null,
-				prefixConfirmed: null,
-				prefixReturncodeMismatches: null,
-				prefixUnknownExpectations: null,
-				armAExit: null,
-				armAReturncodeMatch: false,
-				armASignatureMatch: false,
-				replayed: false,
-				fix: null,
-				wallMs: Date.now() - caseStart
+			pulled = true;
+		} catch (err) {
+			return {
+				succeeded: false,
+				error: `pull ${image}: ${errorTail(err)}`
 			};
-			rows.push(row);
-			appendFileSync(progressPath, `${JSON.stringify(row)}\n`);
-			onProgress(`${label}: image unavailable — ${preparation.error}`);
-			continue;
 		}
-		const { derivedImage, pulled, built } = preparation.value;
-		const stepTimeoutMs = options.stepTimeoutMs ?? replayCase.recordedStepTimeoutMs ?? 12e4;
-		const caseOut = join(options.out, caseOutDirName(replayCase));
-		onProgress(`${label}: arm A on ${derivedImage} (k=${replayCase.k}, timeout ${stepTimeoutMs}ms)`);
+		const contextDir = mkdtempSync(join(tmpdir(), "ctb-replay-image-"));
+		const quotedCwd = `'${cwd.replaceAll("'", `'\\''`)}'`;
+		writeFileSync(join(contextDir, "Dockerfile"), `FROM ${image}\nRUN chown -R 1000:1000 ${quotedCwd}\n`);
 		try {
-			const verdict = await replayVerify({
-				stepsPath: replayCase.stepsPath,
-				image: derivedImage,
-				at: replayCase.k,
-				cwd: replayCase.cwd,
-				out: caseOut,
-				caseId: replayCase.trajId,
-				stepTimeoutMs,
-				prefixLimit: options.prefixLimit,
-				backend: backendFactory(derivedImage),
-				onProgress: (message) => onProgress(`${label}: ${message}`)
+			await execFileAsync("docker", [
+				"build",
+				"-t",
+				derived,
+				contextDir
+			], {
+				timeout: buildTimeoutMs,
+				maxBuffer: 33554432
 			});
-			verdictByTraj.set(replayCase.trajId, verdict);
-			const returncodeMatch = verdict.recordedReturncode !== null && verdict.armA.exitCode === verdict.recordedReturncode;
-			const row = {
-				...base,
-				derivedImage,
-				signature: verdict.signature,
-				status: "ok",
-				error: null,
-				imagePulled: pulled,
-				imageBuilt: built,
-				prefixExecuted: verdict.prefixExecuted,
-				prefixDivergences: verdict.prefixDivergences.length,
-				prefixDivergencePct: verdict.prefixDivergencePct,
-				prefixConfirmed: verdict.prefixConfirmed,
-				prefixReturncodeMismatches: verdict.prefixReturncodeMismatches,
-				prefixUnknownExpectations: verdict.prefixUnknownExpectations,
-				armAExit: verdict.armA.exitCode,
-				armAReturncodeMatch: returncodeMatch,
-				armASignatureMatch: verdict.armA.failureSignatureMatch,
-				replayed: verdict.valid,
-				fix: null,
-				wallMs: Date.now() - caseStart
-			};
-			rows.push(row);
-			appendFileSync(progressPath, `${JSON.stringify(row)}\n`);
-			onProgress(`${label}: armA exit=${verdict.armA.exitCode} rcMatch=${returncodeMatch} divergences=${verdict.prefixDivergences.length}/${verdict.prefixExecuted} (${verdict.prefixDivergencePct}%, ${verdict.prefixUnknownExpectations} unknown-expectation)`);
 		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			const row = {
-				...base,
-				derivedImage,
-				signature: null,
-				status: "replay-error",
-				error: message.slice(0, 500),
-				imagePulled: pulled,
-				imageBuilt: built,
-				prefixExecuted: null,
-				prefixDivergences: null,
-				prefixDivergencePct: null,
-				prefixConfirmed: null,
-				prefixReturncodeMismatches: null,
-				prefixUnknownExpectations: null,
-				armAExit: null,
-				armAReturncodeMatch: false,
-				armASignatureMatch: false,
-				replayed: false,
-				fix: null,
-				wallMs: Date.now() - caseStart
+			return {
+				succeeded: false,
+				error: `build ${derived} from ${image}: ${errorTail(err)}`
 			};
-			rows.push(row);
-			appendFileSync(progressPath, `${JSON.stringify(row)}\n`);
-			onProgress(`${label}: replay error — ${message.slice(0, 200)}`);
 		}
-	}
-	let llm = null;
-	if (options.fix !== "none") {
-		const caller = options.fixCaller;
-		if (!caller) throw new Error(`trajectory-replay: fix=${options.fix} requires a fixCaller`);
-		const fixAttempts = options.fixAttempts ?? 3;
-		const maxFixCases = options.maxFixCases ?? 30;
-		const seed = options.seed ?? 17;
-		const eligible = rows.filter((r) => r.status === "ok" && r.replayed);
-		const sampled = eligible.length > maxFixCases ? seededSample(eligible, maxFixCases, seed) : new Set(eligible);
-		if (eligible.length > maxFixCases) onProgress(`fix phase: ${eligible.length} eligible > cap ${maxFixCases}; seeded sample (seed=${seed})`);
-		let calls = 0;
-		let failures = 0;
-		let promptTokens = 0;
-		let completionTokens = 0;
-		let callsWithoutUsage = 0;
-		for (const row of eligible) {
-			const index = rows.indexOf(row);
-			if (!sampled.has(row)) {
-				rows[index] = {
-					...row,
-					fix: {
-						attempted: false,
-						sampledOut: true,
-						command: null,
-						llmError: null,
-						usage: null,
-						armBExit: null,
-						armBPrefixExecuted: null,
-						armBPrefixDivergences: null,
-						armBPrefixDivergencePct: null,
-						failureVanished: null,
-						armBError: null,
-						attempts: null,
-						flippedAtAttempt: null
-					}
-				};
-				continue;
-			}
-			const replayCase = selected.find((c) => c.trajId === row.trajId && c.corpus === row.corpus);
-			const label = `fix ${row.corpus}/${row.trajId}`;
-			const signature = verdictByTraj.get(row.trajId)?.signature ?? null;
-			const stepTimeoutMs = options.stepTimeoutMs ?? replayCase.recordedStepTimeoutMs ?? 12e4;
-			const promptInput = {
-				taskStatement: replayCase.taskStatement,
-				steps: replayCase.steps,
-				k: replayCase.k
-			};
-			const caseOut = join(options.out, caseOutDirName(row));
-			if (options.fix === "loop") {
-				onProgress(`${label}: fix loop (budget ${fixAttempts} attempts)`);
-				const result = await runFixLoop(caller, promptInput, async (command, attempt) => {
-					onProgress(`${label}: attempt ${attempt} arm B — ${command.split("\n")[0].slice(0, 120)}`);
-					const armB = await executeArmB(replayCase, command, backendFactory(row.derivedImage), signature, stepTimeoutMs, options.prefixLimit, (message) => onProgress(`${label}: attempt ${attempt}: ${message}`));
-					mkdirSync(caseOut, { recursive: true });
-					writeFileSync(join(caseOut, `armB-attempt${attempt}-result.json`), `${JSON.stringify({
-						command,
-						...armB
-					}, null, 2)}\n`);
-					writeFileSync(join(caseOut, "armB-result.json"), `${JSON.stringify({
-						command,
-						attempt,
-						...armB
-					}, null, 2)}\n`);
-					return armB;
-				}, {
-					maxAttempts: fixAttempts,
-					onProgress: (message) => onProgress(`${label}: ${message}`)
-				});
-				calls += result.llmCalls;
-				failures += result.llmFailures;
-				promptTokens += result.promptTokens;
-				completionTokens += result.completionTokens;
-				callsWithoutUsage += result.callsWithoutUsage;
-				const usage = result.promptTokens + result.completionTokens > 0 ? {
-					promptTokens: result.promptTokens,
-					completionTokens: result.completionTokens
-				} : null;
-				const summary = (result.flippedAtAttempt !== null ? result.attempts.find((a) => a.attempt === result.flippedAtAttempt) : null) ?? [...result.attempts].reverse().find((a) => a.executed) ?? null;
-				const lastRecord = result.attempts.at(-1) ?? null;
-				rows[index] = {
-					...row,
-					fix: summary ? {
-						attempted: true,
-						sampledOut: false,
-						command: summary.command,
-						llmError: null,
-						usage,
-						armBExit: summary.exitCode,
-						armBPrefixExecuted: summary.prefixExecuted,
-						armBPrefixDivergences: summary.prefixDivergences,
-						armBPrefixDivergencePct: summary.prefixDivergencePct,
-						failureVanished: summary.failureVanished,
-						armBError: null,
-						attempts: result.attempts,
-						flippedAtAttempt: result.flippedAtAttempt
-					} : result.aborted ? {
-						attempted: true,
-						sampledOut: false,
-						command: lastRecord?.command ?? null,
-						llmError: null,
-						usage,
-						armBExit: null,
-						armBPrefixExecuted: null,
-						armBPrefixDivergences: null,
-						armBPrefixDivergencePct: null,
-						failureVanished: null,
-						armBError: lastRecord?.armBError ?? "sandbox error",
-						attempts: result.attempts,
-						flippedAtAttempt: null
-					} : {
-						attempted: true,
-						sampledOut: false,
-						command: null,
-						llmError: lastRecord?.llmError ?? "no attempt produced a runnable fix",
-						usage,
-						armBExit: null,
-						armBPrefixExecuted: null,
-						armBPrefixDivergences: null,
-						armBPrefixDivergencePct: null,
-						failureVanished: null,
-						armBError: null,
-						attempts: result.attempts,
-						flippedAtAttempt: null
-					}
-				};
-				onProgress(`${label}: loop done — flipped=${result.flipped}` + (result.flippedAtAttempt !== null ? ` at attempt ${result.flippedAtAttempt}` : "") + ` (${result.llmCalls} calls, ${result.attempts.filter((a) => a.executed).length} arms)`);
-				continue;
-			}
-			onProgress(`${label}: generating corrected command`);
-			calls += 1;
-			const generated = await generateFixCommand(caller, promptInput);
-			if (!generated.succeeded) {
-				failures += 1;
-				rows[index] = {
-					...row,
-					fix: {
-						attempted: true,
-						sampledOut: false,
-						command: null,
-						llmError: generated.error,
-						usage: null,
-						armBExit: null,
-						armBPrefixExecuted: null,
-						armBPrefixDivergences: null,
-						armBPrefixDivergencePct: null,
-						failureVanished: null,
-						armBError: null,
-						attempts: null,
-						flippedAtAttempt: null
-					}
-				};
-				onProgress(`${label}: LLM failed — ${generated.error.slice(0, 200)}`);
-				continue;
-			}
-			if (generated.value.usage === null || generated.value.usage === void 0) callsWithoutUsage += 1;
-			promptTokens += generated.value.usage?.promptTokens ?? 0;
-			completionTokens += generated.value.usage?.completionTokens ?? 0;
-			onProgress(`${label}: arm B — ${generated.value.command.split("\n")[0].slice(0, 120)}`);
-			try {
-				const armB = await executeArmB(replayCase, generated.value.command, backendFactory(row.derivedImage), signature, stepTimeoutMs, options.prefixLimit, (message) => onProgress(`${label}: ${message}`));
-				rows[index] = {
-					...row,
-					fix: {
-						attempted: true,
-						sampledOut: false,
-						command: generated.value.command,
-						llmError: null,
-						usage: generated.value.usage,
-						armBExit: armB.exitCode,
-						armBPrefixExecuted: armB.prefixExecuted,
-						armBPrefixDivergences: armB.prefixDivergences,
-						armBPrefixDivergencePct: armB.prefixDivergencePct,
-						failureVanished: armB.failureVanished,
-						armBError: null,
-						attempts: null,
-						flippedAtAttempt: armB.failureVanished ? 1 : null
-					}
-				};
-				mkdirSync(caseOut, { recursive: true });
-				writeFileSync(join(caseOut, "armB-result.json"), `${JSON.stringify({
-					command: generated.value.command,
-					...armB
-				}, null, 2)}\n`);
-				onProgress(`${label}: armB exit=${armB.exitCode} failureVanished=${armB.failureVanished}`);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				rows[index] = {
-					...row,
-					fix: {
-						attempted: true,
-						sampledOut: false,
-						command: generated.value.command,
-						llmError: null,
-						usage: generated.value.usage,
-						armBExit: null,
-						armBPrefixExecuted: null,
-						armBPrefixDivergences: null,
-						armBPrefixDivergencePct: null,
-						failureVanished: null,
-						armBError: message.slice(0, 500),
-						attempts: null,
-						flippedAtAttempt: null
-					}
-				};
-				onProgress(`${label}: arm B error — ${message.slice(0, 200)}`);
+		return {
+			succeeded: true,
+			value: {
+				derivedImage: derived,
+				pulled,
+				built: true
 			}
-		}
-		llm = {
-			model: options.fixModelLabel ?? "unknown",
-			calls,
-			failures,
-			promptTokens,
-			completionTokens,
-			callsWithoutUsage
 		};
+	} };
+}
+//#endregion
+//#region src/trajectory-replay/batch.ts
+/**
+* Batch replay verification across gold-labeled trajectory corpora.
+*
+* For every replayable case (a raw trajectory with a recorded image AND at
+* least one gold incorrect step) the batch:
+*   1. derives the replay-ready image through the injected `ImagePreparer`,
+*   2. replays the prefix and runs arm A — the recorded gold step k, and
+*   3. optionally generates a corrected command with one LLM call and runs
+*      arm B in its own fresh session.
+*
+* Headline metrics:
+*   replayability rate — fraction of replayable cases where the prefix
+*     replays within the divergence tolerance AND arm A reproduces a
+*     recorded failure at k; a zero exit without an error signature is not
+*     evidence of failure;
+*   prefix fidelity — executed prefix steps and the share of them that did
+*     not confirm the recording, split by kind. A corpus whose recordings
+*     carry no returncodes shows up here as unknown-expectation steps, never
+*     as a clean replay;
+*   fix-flip rate — fraction of arm-B-executed cases where the failure
+*     vanished (exit 0, signature absent).
+*
+* Image pulls and execs run strictly serially: pulls contend on disk and
+* registry bandwidth, and serial cases keep wall-time attribution per case
+* honest. Pull failures are report rows, never silent skips.
+*/
+function rate(numerator, denominator) {
+	return denominator > 0 ? numerator / denominator : null;
+}
+function caseIdentity(replayCase) {
+	return {
+		corpus: replayCase.corpus,
+		trajId: replayCase.trajId,
+		image: replayCase.image,
+		cwd: replayCase.cwd,
+		cwdSource: replayCase.cwdSource,
+		k: replayCase.k,
+		stepCount: replayCase.steps.length,
+		goldIncorrectSteps: replayCase.goldIncorrectSteps,
+		submitGoldsSkipped: replayCase.submitGoldsSkipped,
+		recordedReturncodeAtK: replayCase.recordedReturncodeAtK
+	};
+}
+/** The row of a case that never produced an arm A verdict. */
+function unreplayedRow(replayCase, caseStart, failure) {
+	return {
+		...caseIdentity(replayCase),
+		derivedImage: failure.derivedImage,
+		signature: null,
+		status: failure.status,
+		error: failure.error,
+		imagePulled: failure.imagePulled,
+		imageBuilt: failure.imageBuilt,
+		prefixExecuted: null,
+		prefixDivergences: null,
+		prefixDivergencePct: null,
+		prefixConfirmed: null,
+		prefixReturncodeMismatches: null,
+		prefixUnknownExpectations: null,
+		armAExit: null,
+		armAReturncodeMatch: false,
+		armASignatureMatch: false,
+		replayed: false,
+		fix: null,
+		wallMs: Date.now() - caseStart
+	};
+}
+function verdictRow(replayCase, caseStart, image, verdict, returncodeMatch) {
+	return {
+		...caseIdentity(replayCase),
+		derivedImage: image.derivedImage,
+		signature: verdict.signature,
+		status: "ok",
+		error: null,
+		imagePulled: image.pulled,
+		imageBuilt: image.built,
+		prefixExecuted: verdict.prefixExecuted,
+		prefixDivergences: verdict.prefixDivergences.length,
+		prefixDivergencePct: verdict.prefixDivergencePct,
+		prefixConfirmed: verdict.prefixConfirmed,
+		prefixReturncodeMismatches: verdict.prefixReturncodeMismatches,
+		prefixUnknownExpectations: verdict.prefixUnknownExpectations,
+		armAExit: verdict.armA.exitCode,
+		armAReturncodeMatch: returncodeMatch,
+		armASignatureMatch: verdict.armA.failureSignatureMatch,
+		replayed: verdict.valid,
+		fix: null,
+		wallMs: Date.now() - caseStart
+	};
+}
+/** Phase 1 for one case: prepare its image and run arm A. Every outcome is a row, never a skip. */
+async function replayArmA(run, replayCase, label, verdicts, pullFailures) {
+	const { options, onProgress } = run;
+	const caseStart = Date.now();
+	onProgress(`${label}: preparing image ${replayCase.image}`);
+	const preparation = await run.preparer.ensure(replayCase.image, replayCase.cwd);
+	if (!preparation.succeeded) {
+		pullFailures.push({
+			corpus: replayCase.corpus,
+			trajId: replayCase.trajId,
+			image: replayCase.image,
+			error: preparation.error
+		});
+		const row = unreplayedRow(replayCase, caseStart, {
+			derivedImage: null,
+			status: "image-unavailable",
+			error: preparation.error,
+			imagePulled: false,
+			imageBuilt: false
+		});
+		appendFileSync(run.progressPath, `${JSON.stringify(row)}\n`);
+		onProgress(`${label}: image unavailable — ${preparation.error}`);
+		return row;
 	}
-	const executedRows = rows.filter((r) => r.status === "ok");
-	const replayed = executedRows.filter((r) => r.replayed);
+	const { derivedImage, pulled, built } = preparation.value;
+	const stepTimeoutMs = options.stepTimeoutMs ?? replayCase.recordedStepTimeoutMs ?? 12e4;
+	const caseOut = join(options.out, caseOutDirName(replayCase));
+	onProgress(`${label}: arm A on ${derivedImage} (k=${replayCase.k}, timeout ${stepTimeoutMs}ms)`);
+	try {
+		const verdict = await replayVerify({
+			stepsPath: replayCase.stepsPath,
+			image: derivedImage,
+			at: replayCase.k,
+			cwd: replayCase.cwd,
+			out: caseOut,
+			caseId: replayCase.trajId,
+			stepTimeoutMs,
+			prefixLimit: options.prefixLimit,
+			backend: options.backendFactory(derivedImage),
+			onProgress: (message) => onProgress(`${label}: ${message}`)
+		});
+		verdicts.set(replayCase.trajId, verdict);
+		const returncodeMatch = verdict.recordedReturncode !== null && verdict.armA.exitCode === verdict.recordedReturncode;
+		const row = verdictRow(replayCase, caseStart, {
+			derivedImage,
+			pulled,
+			built
+		}, verdict, returncodeMatch);
+		appendFileSync(run.progressPath, `${JSON.stringify(row)}\n`);
+		onProgress(`${label}: armA exit=${verdict.armA.exitCode} rcMatch=${returncodeMatch} divergences=${verdict.prefixDivergences.length}/${verdict.prefixExecuted} (${verdict.prefixDivergencePct}%, ${verdict.prefixUnknownExpectations} unknown-expectation)`);
+		return row;
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		const row = unreplayedRow(replayCase, caseStart, {
+			derivedImage,
+			status: "replay-error",
+			error: message.slice(0, 500),
+			imagePulled: pulled,
+			imageBuilt: built
+		});
+		appendFileSync(run.progressPath, `${JSON.stringify(row)}\n`);
+		onProgress(`${label}: replay error — ${message.slice(0, 200)}`);
+		return row;
+	}
+}
+function prefixFidelityOf(executedRows) {
 	const sumOver = (pick) => executedRows.reduce((total, row) => total + (pick(row) ?? 0), 0);
 	const executedSteps = sumOver((r) => r.prefixExecuted);
 	const divergentSteps = sumOver((r) => r.prefixDivergences);
-	const prefixFidelity = {
+	return {
 		executedSteps,
 		divergentSteps,
 		returncodeMismatches: sumOver((r) => r.prefixReturncodeMismatches),
@@ -1485,7 +1623,9 @@ async function runReplayBatch(options) {
 		casesWithinTolerance: executedRows.filter((r) => r.prefixDivergencePct !== null && r.prefixDivergencePct <= 10).length,
 		casesExecuted: executedRows.length
 	};
-	const signatureStrict = executedRows.filter((r) => r.replayed && r.armASignatureMatch);
+}
+/** Fix-flip headline rates over the cases whose arm B executed. */
+function fixFlipHeadline(rows, fix) {
 	const armBExecuted = rows.filter((r) => r.fix?.attempted && r.fix.failureVanished !== null);
 	const flipped = armBExecuted.filter((r) => r.fix.failureVanished === true);
 	const armBNonzeroRc = armBExecuted.filter((r) => r.recordedReturncodeAtK !== null && r.recordedReturncodeAtK !== 0);
@@ -1497,16 +1637,43 @@ async function runReplayBatch(options) {
 		const at = row.fix?.flippedAtAttempt;
 		if (typeof at === "number") flipsByAttempt[String(at)] = (flipsByAttempt[String(at)] ?? 0) + 1;
 	}
-	const excludedByReason = {};
-	for (const excluded of enumeration.excluded) excludedByReason[excluded.reason] = (excludedByReason[excluded.reason] ?? 0) + 1;
-	const submitGoldsByCorpus = {};
-	const submitEntry = (corpus) => submitGoldsByCorpus[corpus] ??= {
+	return {
+		fixFlipRate: fix !== "none" ? {
+			numerator: flipped.length,
+			denominator: armBExecuted.length,
+			value: rate(flipped.length, armBExecuted.length)
+		} : null,
+		fixFlipRateNonzeroRc: fix !== "none" ? {
+			numerator: flippedNonzeroRc.length,
+			denominator: armBNonzeroRc.length,
+			value: rate(flippedNonzeroRc.length, armBNonzeroRc.length)
+		} : null,
+		fixFlipAttempt1: fix === "loop" ? {
+			numerator: flippedAt1.length,
+			denominator: attempt1Executed.length,
+			value: rate(flippedAt1.length, attempt1Executed.length)
+		} : null,
+		flipsByAttempt: fix === "loop" ? flipsByAttempt : null
+	};
+}
+/** Per-corpus submit-gold accounting: cases dropped for pure-submit golds, and submit golds skipped inside replayable cases. */
+function submitGoldsOf(enumeration) {
+	const byCorpus = {};
+	const entry = (corpus) => byCorpus[corpus] ??= {
 		submitOnlyCases: 0,
 		goldsSkippedWithinReplayable: 0
 	};
-	for (const excluded of enumeration.excluded) if (excluded.reason === "gold-only-submit-step") submitEntry(excluded.corpus).submitOnlyCases += 1;
-	for (const replayCase of enumeration.replayable) if (replayCase.submitGoldsSkipped > 0) submitEntry(replayCase.corpus).goldsSkippedWithinReplayable += replayCase.submitGoldsSkipped;
-	const report = {
+	for (const excluded of enumeration.excluded) if (excluded.reason === "gold-only-submit-step") entry(excluded.corpus).submitOnlyCases += 1;
+	for (const replayCase of enumeration.replayable) if (replayCase.submitGoldsSkipped > 0) entry(replayCase.corpus).goldsSkippedWithinReplayable += replayCase.submitGoldsSkipped;
+	return byCorpus;
+}
+function buildBatchReport(options, enumeration, selected, rows, llm, pullFailures) {
+	const executedRows = rows.filter((r) => r.status === "ok");
+	const replayed = executedRows.filter((r) => r.replayed);
+	const signatureStrict = executedRows.filter((r) => r.replayed && r.armASignatureMatch);
+	const excludedByReason = {};
+	for (const excluded of enumeration.excluded) excludedByReason[excluded.reason] = (excludedByReason[excluded.reason] ?? 0) + 1;
+	return {
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		corpora: options.corpora.map((c) => ({
 			name: c.name,
@@ -1518,7 +1685,7 @@ async function runReplayBatch(options) {
 			replayable: enumeration.replayable.length,
 			executed: selected.length,
 			excludedByReason,
-			submitGoldsByCorpus
+			submitGoldsByCorpus: submitGoldsOf(enumeration)
 		},
 		headline: {
 			replayabilityRate: {
@@ -1531,120 +1698,42 @@ async function runReplayBatch(options) {
 				denominator: selected.length,
 				value: rate(signatureStrict.length, selected.length)
 			},
-			prefixFidelity,
-			fixFlipRate: options.fix !== "none" ? {
-				numerator: flipped.length,
-				denominator: armBExecuted.length,
-				value: rate(flipped.length, armBExecuted.length)
-			} : null,
-			fixFlipRateNonzeroRc: options.fix !== "none" ? {
-				numerator: flippedNonzeroRc.length,
-				denominator: armBNonzeroRc.length,
-				value: rate(flippedNonzeroRc.length, armBNonzeroRc.length)
-			} : null,
-			fixFlipAttempt1: options.fix === "loop" ? {
-				numerator: flippedAt1.length,
-				denominator: attempt1Executed.length,
-				value: rate(flippedAt1.length, attempt1Executed.length)
-			} : null,
-			flipsByAttempt: options.fix === "loop" ? flipsByAttempt : null
+			prefixFidelity: prefixFidelityOf(executedRows),
+			...fixFlipHeadline(rows, options.fix)
 		},
 		llm,
 		excluded: enumeration.excluded,
 		pullFailures,
 		cases: rows
 	};
+}
+async function runReplayBatch(options) {
+	const onProgress = options.onProgress ?? (() => {});
+	const enumeration = enumerateReplayableCases(options.corpora);
+	let selected = enumeration.replayable;
+	if (options.caseFilter) selected = selected.filter((c) => c.trajId.includes(options.caseFilter));
+	if (options.caseLimit !== void 0) selected = selected.slice(0, options.caseLimit);
+	onProgress(`enumerated ${enumeration.labelEntryCount} label entries → ${enumeration.replayable.length} replayable, ${enumeration.excluded.length} excluded; executing ${selected.length}`);
+	mkdirSync(options.out, { recursive: true });
+	const run = {
+		options,
+		onProgress,
+		progressPath: join(options.out, "cases.jsonl"),
+		preparer: options.preparer ?? dockerImagePreparer()
+	};
+	const rows = [];
+	const pullFailures = [];
+	const verdictByTraj = /* @__PURE__ */ new Map();
+	for (const [index, replayCase] of selected.entries()) {
+		const label = `[${index + 1}/${selected.length}] ${replayCase.corpus}/${replayCase.trajId}`;
+		rows.push(await replayArmA(run, replayCase, label, verdictByTraj, pullFailures));
+	}
+	const llm = options.fix !== "none" ? await runFixPhase(run, selected, rows, verdictByTraj) : null;
+	const report = buildBatchReport(options, enumeration, selected, rows, llm, pullFailures);
 	writeFileSync(join(options.out, "batch-report.json"), `${JSON.stringify(report, null, 2)}\n`);
 	writeFileSync(join(options.out, "batch-report.md"), renderBatchReport(report));
 	return report;
 }
-function pct(value) {
-	return value === null ? "—" : `${(value * 100).toFixed(1)}%`;
-}
-function renderBatchReport(report) {
-	const lines = [];
-	const { headline, totals } = report;
-	lines.push("# Replay-verify batch report");
-	lines.push("");
-	lines.push(`Generated ${report.generatedAt}.`);
-	lines.push("");
-	lines.push("## Headline");
-	lines.push("");
-	const fidelity = headline.prefixFidelity;
-	lines.push(`- **Replayability rate: ${pct(headline.replayabilityRate.value)}** (${headline.replayabilityRate.numerator}/${headline.replayabilityRate.denominator} replayable cases where the prefix replayed within ${fidelity.tolerancePct}% divergence AND arm A reproduced an observed failure at the gold step k).`);
-	lines.push(`- Signature-strict rate: ${pct(headline.signatureStrictRate.value)} (${headline.signatureStrictRate.numerator}/${headline.signatureStrictRate.denominator}; additionally requires the recorded error substring in arm A output).`);
-	lines.push(`- **Prefix divergence: ${fidelity.divergencePct === null ? "—" : `${fidelity.divergencePct}%`}** (${fidelity.divergentSteps}/${fidelity.executedSteps} executed prefix steps did not confirm the recording: ${fidelity.returncodeMismatches} returncode mismatches, ${fidelity.unknownExpectations} with no recorded returncode to check). ${fidelity.casesWithinTolerance}/${fidelity.casesExecuted} executed cases are within the ${fidelity.tolerancePct}% tolerance.`);
-	if (headline.fixFlipRate) lines.push(`- **Fix-flip rate: ${pct(headline.fixFlipRate.value)}** (${headline.fixFlipRate.numerator}/${headline.fixFlipRate.denominator} arm-B-executed cases where the generated fix made the failure vanish).`);
-	if (headline.fixFlipRateNonzeroRc) lines.push(`- Fix-flip rate on recorded-rc≠0 cases: ${pct(headline.fixFlipRateNonzeroRc.value)} (${headline.fixFlipRateNonzeroRc.numerator}/${headline.fixFlipRateNonzeroRc.denominator}; real recorded failures — a gold step recorded with rc 0 flips vacuously).`);
-	if (headline.fixFlipAttempt1) lines.push(`- Fix-flip@1: ${pct(headline.fixFlipAttempt1.value)} (${headline.fixFlipAttempt1.numerator}/${headline.fixFlipAttempt1.denominator} cases whose attempt 1 executed — the one-shot-comparable number).`);
-	if (headline.flipsByAttempt && Object.keys(headline.flipsByAttempt).length > 0) {
-		const parts = Object.entries(headline.flipsByAttempt).sort((a, b) => Number(a[0]) - Number(b[0])).map(([attempt, count]) => `attempt ${attempt}: ${count}`);
-		lines.push(`- Flips by attempt: ${parts.join(", ")}.`);
-	}
-	lines.push("");
-	lines.push("## Enumeration");
-	lines.push("");
-	lines.push(`${totals.labelEntries} label entries across ${report.corpora.length} corpora → ${totals.replayable} replayable (SWE-style docker image + ≥1 gold incorrect step), ${totals.executed} executed.`);
-	lines.push("");
-	lines.push("| exclusion reason | count |");
-	lines.push("| --- | --- |");
-	for (const [reason, count] of Object.entries(totals.excludedByReason).sort((a, b) => b[1] - a[1])) lines.push(`| ${reason} | ${count} |`);
-	const submitEntries = Object.entries(totals.submitGoldsByCorpus);
-	if (submitEntries.length > 0) {
-		lines.push("");
-		lines.push("Submit-command golds are never counterfactual targets (a gold on the submit step marks a bad submit decision, not a failed command):");
-		lines.push("");
-		lines.push("| corpus | cases excluded (all golds = submit) | golds skipped within replayable cases |");
-		lines.push("| --- | --- | --- |");
-		for (const [corpus, stats] of submitEntries.sort((a, b) => a[0].localeCompare(b[0]))) lines.push(`| ${corpus} | ${stats.submitOnlyCases} | ${stats.goldsSkippedWithinReplayable} |`);
-	}
-	if (report.pullFailures.length > 0) {
-		lines.push("");
-		lines.push("## Image pull/build failures");
-		lines.push("");
-		lines.push("| corpus | trajectory | image | error |");
-		lines.push("| --- | --- | --- | --- |");
-		for (const failure of report.pullFailures) lines.push(`| ${failure.corpus} | ${failure.trajId} | \`${failure.image}\` | ${failure.error.replaceAll("|", "\\|")} |`);
-	}
-	lines.push("");
-	lines.push("## Per-case results");
-	lines.push("");
-	lines.push("| corpus | trajectory | k | rc@k | prefix | confirmed | rc mismatch | unknown rc | div | div% | armA exit | rc match | sig match | replayed | fix | armB exit | armB div% | vanished | wall s |");
-	lines.push(`| ${Array(19).fill("---").join(" | ")} |`);
-	for (const row of report.cases) {
-		const fix = row.fix;
-		const fixCell = !fix ? "—" : fix.sampledOut ? "sampled-out" : fix.llmError ? "llm-failed" : fix.armBError ? "armB-error" : fix.attempts ? fix.flippedAtAttempt !== null ? `flip@${fix.flippedAtAttempt}` : `exhausted(${fix.attempts.length})` : "generated";
-		lines.push([
-			row.corpus,
-			row.trajId.length > 48 ? `${row.trajId.slice(0, 45)}…` : row.trajId,
-			row.k,
-			row.recordedReturncodeAtK ?? "null",
-			row.prefixExecuted ?? "—",
-			row.prefixConfirmed ?? "—",
-			row.prefixReturncodeMismatches ?? "—",
-			row.prefixUnknownExpectations ?? "—",
-			row.prefixDivergences ?? "—",
-			row.prefixDivergencePct ?? "—",
-			row.status === "ok" ? row.armAExit : row.status,
-			row.armAReturncodeMatch ? "yes" : "no",
-			row.armASignatureMatch ? "yes" : "no",
-			row.replayed ? "**yes**" : "no",
-			fixCell,
-			fix?.armBExit ?? "—",
-			fix?.armBPrefixDivergencePct ?? "—",
-			fix?.failureVanished === null || fix === null ? "—" : fix.failureVanished ? "**yes**" : "no",
-			(row.wallMs / 1e3).toFixed(1)
-		].join(" | "));
-	}
-	if (report.llm) {
-		lines.push("");
-		lines.push("## LLM fix generation");
-		lines.push("");
-		lines.push(`Model ${report.llm.model}: ${report.llm.calls} calls (${report.llm.failures} failed), ${report.llm.promptTokens} prompt + ${report.llm.completionTokens} completion tokens.`);
-	}
-	lines.push("");
-	return lines.join("\n");
-}
 //#endregion
 //#region src/trajectory-replay/wire.ts
 /**
@@ -2116,44 +2205,7 @@ async function verifyFindings(findings, options) {
 	}, null, 2)}\n`);
 	return run;
 }
-function verdictCell(verification) {
-	switch (verification.verified) {
-		case "reproduced": return "**VERIFIED** — reproduced";
-		case "fix-flipped": return "**VERIFIED** — fix-flipped";
-		case "divergent": return "DIVERGENT — recorded failure did not reproduce";
-		case "not-replayable": return `UNVERIFIABLE — ${verification.reason ?? "no reason recorded"}`;
-	}
-}
-/** Markdown section an analysis report appends when finding verification ran. */
-function renderVerifiedFindingsSection(run) {
-	const lines = ["## Verified findings (executed replay)", ""];
-	const total = run.verifications.length;
-	lines.push(`${total} finding(s) → ${run.counts.reproduced} reproduced, ${run.counts["fix-flipped"]} fix-flipped, ${run.counts.divergent} divergent, ${run.counts["not-replayable"]} not replayable (${run.executions} execution(s); findings accusing the same step share one proof).`);
-	lines.push("");
-	lines.push("| Finding | Subject | Step | Verdict | Receipt |");
-	lines.push("|---|---|---:|---|---|");
-	for (const verification of run.verifications) {
-		const shared = verification.deduplicated_with ? " (shared proof)" : "";
-		lines.push(`| \`${verification.finding_id ?? "—"}\` | \`${verification.subject ?? "—"}\` | ${verification.step ?? "—"} | ${verdictCell(verification)} | \`${verification.receipt}\`${shared} |`);
-	}
-	lines.push("");
-	lines.push("VERIFIED = the accused step was re-executed after replaying the trajectory prefix, and the recorded failure signature reproduced (fix-flipped: a corrected command additionally made it vanish). Each receipt directory carries receipt.json and, when executed, replay-verdict.json + report.md with real stdout/stderr.");
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Accepts the two shapes findings travel in: a bare JSON array of analyst
-* findings, or an object with a `findings` array (e.g. an extracted
-* `observations[n]` from a result.json).
-*/
-function readFindingsFile(path) {
-	const parsed = JSON.parse(readFileSync(path, "utf8"));
-	const array = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" && Array.isArray(parsed.findings) ? parsed.findings : null;
-	if (!array) throw new Error(`${path} is neither a findings array nor an object with a findings array`);
-	for (const entry of array) if (!entry || typeof entry !== "object") throw new Error(`${path}: every finding must be an object, got ${JSON.stringify(entry)}`);
-	return array;
-}
 //#endregion
-export { FORMAT_ERROR_OBSERVATION_PREFIX, PREFIX_DIVERGENCE_TOLERANCE_PCT, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, TIMEOUT_OBSERVATION_MARKER, assertReplayableTrajectory, buildFixPrompt, buildRetryFixPrompt, classifyObservation, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, decodeRecordedTurns, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, finalRecordedOutcome, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isElidedField, isRecordedTimeout, isSubmitAction, isSubmitOnlyAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, unreadableExitCount, verifyFindings, wrapActionForExec };
+export { PREFIX_DIVERGENCE_TOLERANCE_PCT, classifyObservation, classifyVerdict, decodeRecordedTurns, dockerImagePreparer, finalRecordedOutcome, replayVerify, replayVerifyFinding, runReplayBatch, seededSample, verifyFindings };
 
 //# sourceMappingURL=index.js.map