@tangle-network/agent-eval 0.144.6 → 0.144.7

package/dist/trajectory-replay/index.js

@@ -0,0 +1,2103 @@
+import { t as TraceEmitter } from "../emitter-CPBAhxum.js";
+import { n as InMemoryTraceStore } from "../store-DNe_Uv1Q.js";
+import { n as runCounterfactual } from "../counterfactual-CWPTrMH7.js";
+import { a as parseObservationOutput, i as isSubmitAction, n as SUBMIT_ACTION_SIGNATURE, o as parseRecordedReturncode, r as deriveFailureSignature, t as wrapActionForExec } from "../exec-BLtYZdWo.js";
+import { appendFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+//#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.
+*/
+/** 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}`);
+	return {
+		name,
+		labelsPath: rest.slice(0, sep),
+		preparedDir: rest.slice(sep + 2)
+	};
+}
+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 (isSubmitAction(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;
+		}
+		replayable.push({
+			...resources,
+			goldIncorrectSteps: gold,
+			k: target.step_id,
+			submitGoldsSkipped,
+			recordedReturncodeAtK: parseRecordedReturncode(target.observation)
+		});
+	}
+	return {
+		replayable,
+		excluded,
+		labelEntryCount
+	};
+}
+//#endregion
+//#region src/trajectory-replay/fix.ts
+/**
+* Counterfactual patch synthesis: turn a recorded incorrect step into a
+* corrected shell command for replay arm B.
+*
+* The caller is a typed outcome boundary ({ succeeded, value, error }) so a
+* provider failure is a per-case report row, never a thrown batch abort and
+* never a silent empty fix. Concrete chat transports live with the consumer;
+* this module only builds prompts and reads replies.
+*/
+/** Head+tail excerpt with an elision marker; identity below the limit. */
+function clipText(text, limit) {
+	if (text.length <= limit) return text;
+	const half = Math.floor(limit / 2);
+	return `${text.slice(0, half)}\n… [${text.length - limit} chars elided] …\n${text.slice(-half)}`;
+}
+function renderStep(step, marker) {
+	const rc = parseRecordedReturncode(step.observation);
+	const output = clipText(parseObservationOutput(step.observation).trim(), 1600);
+	return [
+		`### step ${step.step_id}${marker}`,
+		"```sh",
+		clipText(step.action, 2e3),
+		"```",
+		`returncode: ${rc ?? "none recorded"}`,
+		output.length > 0 ? `output:\n\`\`\`\n${output}\n\`\`\`` : "output: (empty)"
+	].join("\n");
+}
+/** Shared user-prompt sections: task statement, ±radius context, failing step. */
+function promptBody(input) {
+	const radius = input.contextRadius ?? 3;
+	const target = input.steps.find((s) => s.step_id === input.k);
+	if (!target) throw new Error(`trajectory-replay: no step with step_id ${input.k}`);
+	const context = input.steps.filter((s) => s.step_id !== input.k && Math.abs(s.step_id - input.k) <= radius);
+	return [
+		"## Task the agent was solving",
+		input.taskStatement ? clipText(input.taskStatement, 4e3) : "(no task statement recorded)",
+		"",
+		"## Surrounding steps",
+		...context.map((s) => renderStep(s, "")),
+		"",
+		"## Failing step to correct",
+		renderStep(target, " (INCORRECT — correct this one)")
+	];
+}
+function buildFixPrompt(input) {
+	return {
+		system: [
+			"You repair one failed shell command from a recorded coding-agent trajectory.",
+			"The trajectory replays inside the original docker image; every command runs as a fresh /bin/sh subshell from a fixed working directory.",
+			"You are given the failing step, its recorded output, surrounding steps, and the task statement.",
+			"Reply with exactly ONE corrected shell command (compound commands with && or pipes are fine) inside a single ```sh fenced block.",
+			"The corrected command must accomplish the failing step's intent and exit 0. No prose outside the fenced block."
+		].join("\n"),
+		user: [
+			...promptBody(input),
+			"",
+			"Output the single corrected replacement for the failing step now."
+		].join("\n")
+	};
+}
+function renderFailedAttempt(prior) {
+	if (prior.command === null) return [`### attempt ${prior.attempt}`, `model call failed before producing a command: ${prior.llmError ?? "unknown error"}`].join("\n");
+	const stdout = (prior.stdoutTail ?? "").trim();
+	const stderr = (prior.stderrTail ?? "").trim();
+	return [
+		`### attempt ${prior.attempt}`,
+		"```sh",
+		clipText(prior.command, 2e3),
+		"```",
+		`exit code: ${prior.exitCode ?? "not executed"}`,
+		stdout.length > 0 ? `stdout:\n\`\`\`\n${stdout}\n\`\`\`` : "stdout: (empty)",
+		stderr.length > 0 ? `stderr:\n\`\`\`\n${stderr}\n\`\`\`` : "stderr: (empty)"
+	].join("\n");
+}
+/**
+* Retry prompt for fix-loop attempts ≥2: the original context plus every prior
+* attempt with its REAL executed output, and permission to answer with a short
+* script (the block still executes as one /bin/sh unit).
+*/
+function buildRetryFixPrompt(input, priorAttempts, maxScriptCommands = 5) {
+	if (priorAttempts.length === 0) throw new Error("trajectory-replay: buildRetryFixPrompt requires at least one prior attempt");
+	return {
+		system: [
+			"You repair one failed shell command from a recorded coding-agent trajectory.",
+			"The trajectory replays inside the original docker image; every command runs as a fresh /bin/sh subshell from a fixed working directory.",
+			"Earlier corrected commands were executed for real and failed; their actual output is included below.",
+			`Reply with a corrected fix inside a single \`\`\`sh fenced block: either one command, or a short script of at most ${maxScriptCommands} commands (one per line).`,
+			"The whole block executes as ONE /bin/sh unit from the fixed working directory and must exit 0.",
+			"Do not repeat a command that already failed. Keep reasoning brief. No prose outside the fenced block."
+		].join("\n"),
+		user: [
+			...promptBody(input),
+			"",
+			"## Previous fix attempts (executed for real — all failed)",
+			...priorAttempts.map((prior) => renderFailedAttempt(prior)),
+			"",
+			`Output a corrected fix now — one \`\`\`sh block, at most ${maxScriptCommands} commands.`
+		].join("\n")
+	};
+}
+/** Non-empty, non-comment lines of a fix script — the loop's script-size cap. */
+function countScriptCommands(script) {
+	return script.split("\n").filter((line) => line.trim().length > 0 && !line.trim().startsWith("#")).length;
+}
+/** Last fenced code block, else the whole trimmed content; null when empty. */
+function extractFixCommand(content) {
+	const blocks = [...content.matchAll(/```(?:sh|bash|shell)?\n([\s\S]*?)```/g)];
+	const command = (blocks.length > 0 ? blocks[blocks.length - 1][1] : content).trim();
+	if (command.length === 0 || command.includes("```")) return null;
+	return command;
+}
+async function generateFixCommand(caller, input) {
+	const { system, user } = buildFixPrompt(input);
+	const outcome = await caller.complete(system, user);
+	if (!outcome.succeeded) return outcome;
+	const command = extractFixCommand(outcome.value.content);
+	if (command === null) return {
+		succeeded: false,
+		error: `completion carried no usable command: ${clipText(outcome.value.content, 300)}`
+	};
+	return {
+		succeeded: true,
+		value: {
+			command,
+			usage: outcome.value.usage
+		}
+	};
+}
+//#endregion
+//#region src/trajectory-replay/fix-loop.ts
+/**
+* Iterative counterfactual fix loop.
+*
+* Attempt 1 is exactly the one-shot generator (same prompt, same caller), so
+* flip@1 stays comparable to one-shot fix mode. When an attempt does not flip
+* the failure — nonzero exit, signature still present, or the model call
+* itself failed — the next attempt's prompt carries every prior command and
+* its REAL executed stdout/stderr, up to a fixed attempt budget.
+*
+* Isolation invariant: every attempt executes through the injected executor,
+* which must provide a FRESH sandbox with the same replayed prefix. A used
+* sandbox is never mutated mid-arm; a flip therefore always proves the
+* corrected step against the recorded prefix state, not against debris from
+* an earlier attempt.
+*/
+function toFailedAttempt(record) {
+	return {
+		attempt: record.attempt,
+		command: record.command,
+		exitCode: record.exitCode,
+		stdoutTail: record.stdoutTail,
+		stderrTail: record.stderrTail,
+		llmError: record.llmError ?? record.armBError
+	};
+}
+async function runFixLoop(caller, input, executor, options) {
+	if (!Number.isInteger(options.maxAttempts) || options.maxAttempts < 1) throw new Error(`trajectory-replay: maxAttempts must be a positive integer, got ${options.maxAttempts}`);
+	const scriptCap = options.maxScriptCommands ?? 5;
+	const tailChars = options.outputTailChars ?? 1600;
+	const attempts = [];
+	let llmCalls = 0;
+	let llmFailures = 0;
+	let promptTokens = 0;
+	let completionTokens = 0;
+	let callsWithoutUsage = 0;
+	const unexecuted = (attempt, llmError, usage, command, started) => ({
+		attempt,
+		command,
+		llmError,
+		usage,
+		executed: false,
+		exitCode: null,
+		prefixExecuted: null,
+		prefixDivergences: null,
+		prefixDivergencePct: null,
+		failureVanished: null,
+		stdoutTail: null,
+		stderrTail: null,
+		armBError: null,
+		wallMs: Date.now() - started
+	});
+	for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+		const started = Date.now();
+		const prompt = attempt === 1 ? buildFixPrompt(input) : buildRetryFixPrompt(input, attempts.map(toFailedAttempt), scriptCap);
+		llmCalls += 1;
+		const outcome = await caller.complete(prompt.system, prompt.user);
+		if (!outcome.succeeded) {
+			llmFailures += 1;
+			attempts.push(unexecuted(attempt, outcome.error, null, null, started));
+			options.onProgress?.(`fix-loop attempt ${attempt}: LLM failed — ${outcome.error.slice(0, 160)}`);
+			continue;
+		}
+		const usage = outcome.value.usage;
+		if (usage === null || usage === void 0) callsWithoutUsage += 1;
+		promptTokens += usage?.promptTokens ?? 0;
+		completionTokens += usage?.completionTokens ?? 0;
+		const command = extractFixCommand(outcome.value.content);
+		if (command === null) {
+			llmFailures += 1;
+			attempts.push(unexecuted(attempt, `completion carried no usable command: ${clipText(outcome.value.content, 300)}`, usage, null, started));
+			continue;
+		}
+		if (attempt > 1) {
+			const commandLines = countScriptCommands(command);
+			if (commandLines > scriptCap) {
+				llmFailures += 1;
+				attempts.push(unexecuted(attempt, `script exceeds ${scriptCap} command lines (${commandLines})`, usage, null, started));
+				options.onProgress?.(`fix-loop attempt ${attempt}: rejected script with ${commandLines} command lines`);
+				continue;
+			}
+		}
+		let execution;
+		try {
+			execution = await executor(command, attempt);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			attempts.push({
+				...unexecuted(attempt, "", usage, command, started),
+				llmError: null,
+				armBError: message.slice(0, 500)
+			});
+			options.onProgress?.(`fix-loop attempt ${attempt}: sandbox error — ${message.slice(0, 160)}`);
+			return {
+				flipped: false,
+				flippedAtAttempt: null,
+				attempts,
+				aborted: true,
+				llmCalls,
+				llmFailures,
+				promptTokens,
+				completionTokens,
+				callsWithoutUsage
+			};
+		}
+		attempts.push({
+			attempt,
+			command,
+			llmError: null,
+			usage,
+			executed: true,
+			exitCode: execution.exitCode,
+			prefixExecuted: execution.prefixExecuted,
+			prefixDivergences: execution.prefixDivergences,
+			prefixDivergencePct: execution.prefixDivergencePct,
+			failureVanished: execution.failureVanished,
+			stdoutTail: clipText(execution.stdout, tailChars),
+			stderrTail: clipText(execution.stderr, tailChars),
+			armBError: null,
+			wallMs: Date.now() - started
+		});
+		options.onProgress?.(`fix-loop attempt ${attempt}: exit=${execution.exitCode} failureVanished=${execution.failureVanished}`);
+		if (execution.failureVanished) return {
+			flipped: true,
+			flippedAtAttempt: attempt,
+			attempts,
+			aborted: false,
+			llmCalls,
+			llmFailures,
+			promptTokens,
+			completionTokens,
+			callsWithoutUsage
+		};
+	}
+	return {
+		flipped: false,
+		flippedAtAttempt: null,
+		attempts,
+		aborted: false,
+		llmCalls,
+		llmFailures,
+		promptTokens,
+		completionTokens,
+		callsWithoutUsage
+	};
+}
+//#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: 8 * 1024 * 1024 });
+			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: 32 * 1024 * 1024
+				});
+			} 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: 32 * 1024 * 1024
+			});
+			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: 32 * 1024 * 1024
+			});
+		} 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.
+*
+* 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
+*   arm A — run the recorded step k and check the recorded failure signature
+*           reproduces (returncode + a stable output substring), and
+*   arm B — run a corrected step k and check the failure vanishes.
+*
+* Built on the counterfactual scaffold: the trajectory is ingested into a
+* TraceStore, each arm is a `runCounterfactual` meta-run, and the
+* `SandboxCounterfactualRunner` here supplies the `executeFrom` callback that
+* scaffold deliberately leaves to consumers.
+*
+* Honest limits:
+* - Only trajectories that record their image can be replayed; tasks whose
+*   environment needs external compose peers cannot be replayed this way.
+* - Each arm replays the prefix in its own fresh session, so a backend
+*   without copy-on-write forks pays the prefix twice.
+* - Prefix divergence is recorded per step and surfaced in the verdict, never
+*   hidden: a high divergence rate is a finding about replayability, not an
+*   error of the harness.
+*
+* Agreement requires positive evidence. A prefix step counts as confirmed only
+* when the recording carries a returncode AND the replayed exit equals it. A
+* step the recording cannot adjudicate is a divergence of its own kind
+* (`unknown-expectation`), never silent agreement — otherwise a replay that
+* fails on every step reports a perfect prefix and every downstream verdict
+* built on it is meaningless.
+*/
+/**
+* Emit one tool span per trajectory step, in order, with a monotonic
+* injected clock so `buildTrajectory` ordering is deterministic even when
+* two spans would share a Date.now() millisecond.
+*/
+async function ingestRecordedTrajectory(store, steps, caseId) {
+	let tick = 0;
+	const emitter = new TraceEmitter(store, { now: () => ++tick });
+	await emitter.startRun({
+		scenarioId: caseId,
+		tags: {
+			source: "trajectory-replay",
+			caseId
+		}
+	});
+	for (const step of steps) {
+		if (typeof step.action !== "string" || step.action.length === 0) throw new Error(`trajectory-replay: step ${step.step_id} has no action`);
+		await (await emitter.tool({
+			name: `step:${step.step_id}`,
+			toolName: "shell",
+			args: { command: step.action },
+			result: {
+				returncode: parseRecordedReturncode(step.observation),
+				observation: step.observation
+			}
+		})).end();
+	}
+	await emitter.endRun({
+		pass: true,
+		notes: "recorded trajectory (ingested for replay)"
+	});
+	return {
+		runId: emitter.runId,
+		stepCount: steps.length
+	};
+}
+/** Admission tolerance: a prefix replay is faithful enough to build a verdict
+*  on when at most this percentage of its executed steps diverged. */
+const PREFIX_DIVERGENCE_TOLERANCE_PCT = 10;
+/**
+* Compare one replayed prefix step against its recording. Returns null only
+* when the recording positively confirms the replay.
+*/
+function classifyPrefixStep(step, expectedReturncode, actualExit) {
+	if (expectedReturncode === null) return {
+		step,
+		kind: "unknown-expectation",
+		expectedReturncode: null,
+		actualExit
+	};
+	if (expectedReturncode !== actualExit) return {
+		step,
+		kind: "returncode-mismatch",
+		expectedReturncode,
+		actualExit
+	};
+	return null;
+}
+/** Roll per-step classifications up into the rate the admission pre-pass gates on. */
+function summarizePrefixReplay(prefixExecuted, prefixDivergences, wallMs) {
+	if (prefixDivergences.length > prefixExecuted) throw new Error(`trajectory-replay: ${prefixDivergences.length} divergences over ${prefixExecuted} executed prefix steps`);
+	const pct = prefixExecuted === 0 ? 0 : Number((prefixDivergences.length / prefixExecuted * 100).toFixed(1));
+	return {
+		prefixExecuted,
+		prefixDivergences,
+		prefixConfirmed: prefixExecuted - prefixDivergences.length,
+		prefixReturncodeMismatches: prefixDivergences.filter((d) => d.kind === "returncode-mismatch").length,
+		prefixUnknownExpectations: prefixDivergences.filter((d) => d.kind === "unknown-expectation").length,
+		prefixDivergencePct: pct,
+		prefixWithinTolerance: pct <= 10,
+		wallMs
+	};
+}
+function toolCommand(span) {
+	const args = span.args;
+	if (!args || typeof args.command !== "string") throw new Error(`trajectory-replay: span ${span.name} carries no command`);
+	return args.command;
+}
+function recordedReturncodeOf(span) {
+	const result = span.result;
+	return typeof result?.returncode === "number" ? result.returncode : null;
+}
+/**
+* Replays `ctx.prefix` in a fresh session, then executes the mutated step.
+* Divergences are recorded and never abort the replay. Results land on
+* `lastPrefix` / `lastArm` for the caller; spans for every exec land in the
+* counterfactual meta-run.
+*/
+var SandboxCounterfactualRunner = class {
+	backend;
+	options;
+	lastPrefix = null;
+	lastArm = null;
+	constructor(backend, options) {
+		this.backend = backend;
+		this.options = options;
+	}
+	async executeFrom(ctx, emitter) {
+		const { cwd, stepTimeoutMs, prefixLimit, onProgress } = this.options;
+		const session = await this.backend.open();
+		try {
+			const toolSteps = ctx.prefix.filter((s) => s.span.kind === "tool");
+			const toExecute = prefixLimit !== void 0 ? toolSteps.slice(0, prefixLimit) : toolSteps;
+			const divergences = [];
+			const prefixStart = Date.now();
+			for (const step of toExecute) {
+				const command = toolCommand(step.span);
+				const expected = recordedReturncodeOf(step.span);
+				const started = Date.now();
+				const result = await session.exec(wrapActionForExec(command, cwd), stepTimeoutMs);
+				await (await emitter.sandbox({
+					name: step.span.name,
+					command,
+					exitCode: result.exitCode,
+					wallMs: Date.now() - started
+				})).end();
+				const divergence = classifyPrefixStep(step.index + 1, expected, result.exitCode);
+				if (divergence) divergences.push(divergence);
+				onProgress?.(`prefix ${step.span.name}: exit=${result.exitCode}` + (divergence ? ` (${divergence.kind}${expected === null ? "" : `, recorded ${expected}`})` : ""));
+			}
+			this.lastPrefix = summarizePrefixReplay(toExecute.length, divergences, Date.now() - prefixStart);
+			if (ctx.mutatedStep.span.kind !== "tool") throw new Error("trajectory-replay: mutation target is not a tool span");
+			const armCommand = toolCommand(ctx.mutatedStep.span);
+			const armStart = Date.now();
+			const armResult = await session.exec(wrapActionForExec(armCommand, cwd), stepTimeoutMs);
+			const armWallMs = Date.now() - armStart;
+			await (await emitter.sandbox({
+				name: `candidate:${ctx.mutatedStep.span.name}`,
+				command: armCommand,
+				exitCode: armResult.exitCode,
+				wallMs: armWallMs
+			})).end();
+			this.lastArm = {
+				command: armCommand,
+				exitCode: armResult.exitCode,
+				stdout: armResult.stdout,
+				stderr: armResult.stderr,
+				wallMs: armWallMs
+			};
+			onProgress?.(`candidate step: exit=${armResult.exitCode} in ${armWallMs}ms`);
+			await emitter.endRun({
+				pass: armResult.exitCode === 0,
+				notes: `prefix ${toExecute.length} steps, ${divergences.length} divergences (${this.lastPrefix.prefixDivergencePct}%)`
+			});
+		} finally {
+			await session.close();
+		}
+	}
+};
+function excerpt(text, limit = 2400) {
+	if (text.length <= limit) return text;
+	const head = text.slice(0, limit / 2);
+	const tail = text.slice(-limit / 2);
+	return `${head}\n… [${text.length - limit} chars elided] …\n${tail}`;
+}
+async function replayVerify(options) {
+	const totalStart = Date.now();
+	const steps = JSON.parse(readFileSync(options.stepsPath, "utf8"));
+	if (!Array.isArray(steps) || steps.length === 0) throw new Error(`trajectory-replay: ${options.stepsPath} is not a non-empty steps array`);
+	const index = options.at - 1;
+	if (index < 0 || index >= steps.length) throw new Error(`trajectory-replay: at ${options.at} out of range [1, ${steps.length}]`);
+	const target = steps[index];
+	if (target.step_id !== options.at) throw new Error(`trajectory-replay: steps[${index}].step_id=${target.step_id} != at ${options.at}; steps.json must be ordered with 1-based contiguous step_ids`);
+	const caseId = options.caseId ?? options.stepsPath;
+	const recordedReturncode = parseRecordedReturncode(target.observation);
+	const signature = options.signature ?? deriveFailureSignature(target.observation);
+	const signatureBasis = signature ? "returncode+output-substring" : "returncode-only";
+	const runnerOptions = {
+		cwd: options.cwd,
+		stepTimeoutMs: options.stepTimeoutMs ?? 3e5,
+		prefixLimit: options.prefixLimit,
+		onProgress: options.onProgress
+	};
+	const store = new InMemoryTraceStore();
+	const { runId } = await ingestRecordedTrajectory(store, steps, caseId);
+	options.onProgress?.(`arm A: replaying ${index} prefix steps then recorded step ${options.at}`);
+	const armARunner = new SandboxCounterfactualRunner(options.backend, runnerOptions);
+	const armAStart = Date.now();
+	const armAResult = await runCounterfactual(store, runId, {
+		kind: "custom",
+		at: index,
+		describe: "arm-A identity replay",
+		apply: (s) => s
+	}, armARunner);
+	const armAMs = Date.now() - armAStart;
+	const armAExec = requireExec(armARunner, "arm A");
+	const armAOutput = `${armAExec.stdout}\n${armAExec.stderr}`;
+	const failureSignatureMatch = recordedReturncode !== null && armAExec.exitCode === recordedReturncode && (signature ? armAOutput.includes(signature) : true);
+	let armBRunner = null;
+	let armBExec = null;
+	let armBRunId = null;
+	let armBMs = null;
+	if (options.fixCommand) {
+		const fixCommand = options.fixCommand;
+		options.onProgress?.("arm B: replaying prefix then corrected step");
+		armBRunner = new SandboxCounterfactualRunner(options.backend, runnerOptions);
+		const armBStart = Date.now();
+		const armBResult = await runCounterfactual(store, runId, {
+			kind: "custom",
+			at: index,
+			describe: "arm-B corrected step",
+			apply: (step) => ({
+				...step,
+				span: {
+					...step.span,
+					args: { command: fixCommand }
+				}
+			})
+		}, armBRunner);
+		armBMs = Date.now() - armBStart;
+		armBRunId = armBResult.counterfactualRunId;
+		armBExec = requireExec(armBRunner, "arm B");
+	}
+	const armBOutput = armBExec ? `${armBExec.stdout}\n${armBExec.stderr}` : null;
+	const armAPrefix = requirePrefix(armARunner, "arm A");
+	const verdict = {
+		case: caseId,
+		image: options.image,
+		driver: options.driverLabel ?? "docker",
+		k: options.at,
+		cwd: options.cwd,
+		recordedReturncode,
+		signature,
+		signatureBasis,
+		prefixExecuted: armAPrefix.prefixExecuted,
+		prefixDivergences: armAPrefix.prefixDivergences,
+		prefixDivergencePct: armAPrefix.prefixDivergencePct,
+		prefixConfirmed: armAPrefix.prefixConfirmed,
+		prefixReturncodeMismatches: armAPrefix.prefixReturncodeMismatches,
+		prefixUnknownExpectations: armAPrefix.prefixUnknownExpectations,
+		prefixWithinTolerance: armAPrefix.prefixWithinTolerance,
+		armA: {
+			command: armAExec.command,
+			exitCode: armAExec.exitCode,
+			wallMs: armAExec.wallMs,
+			prefix: armAPrefix,
+			failureSignatureMatch
+		},
+		armB: armBExec && armBRunner ? {
+			command: armBExec.command,
+			exitCode: armBExec.exitCode,
+			wallMs: armBExec.wallMs,
+			prefix: requirePrefix(armBRunner, "arm B"),
+			failureVanished: armBExec.exitCode === 0 && (signature && armBOutput ? !armBOutput.includes(signature) : true)
+		} : null,
+		timings: {
+			armAMs,
+			armBMs,
+			totalMs: Date.now() - totalStart
+		},
+		runIds: {
+			original: runId,
+			armA: armAResult.counterfactualRunId,
+			armB: armBRunId
+		}
+	};
+	mkdirSync(options.out, { recursive: true });
+	writeFileSync(join(options.out, "replay-verdict.json"), `${JSON.stringify(verdict, null, 2)}\n`);
+	writeFileSync(join(options.out, "report.md"), renderReport(verdict, target, armAExec, armBExec));
+	return verdict;
+}
+function requireExec(runner, arm) {
+	if (!runner.lastArm) throw new Error(`trajectory-replay: ${arm} finished without executing step k`);
+	return runner.lastArm;
+}
+function requirePrefix(runner, arm) {
+	if (!runner.lastPrefix) throw new Error(`trajectory-replay: ${arm} reported no prefix replay result`);
+	return runner.lastPrefix;
+}
+function renderReport(verdict, target, armA, armB) {
+	const lines = [];
+	lines.push(`# Replay verification — ${verdict.case}`);
+	lines.push("");
+	lines.push(`- image: \`${verdict.image}\` (driver: ${verdict.driver})`);
+	lines.push(`- error-critical step k = ${verdict.k}, cwd \`${verdict.cwd}\``);
+	lines.push(`- recorded returncode at k: ${verdict.recordedReturncode ?? "none recorded"}`);
+	lines.push(`- failure signature (${verdict.signatureBasis}): ${verdict.signature ? `\`${verdict.signature}\`` : "—"}`);
+	lines.push("");
+	lines.push(`## Prefix replay (steps 1..${verdict.k - 1})`);
+	lines.push("");
+	lines.push(`Executed ${verdict.prefixExecuted} steps; ${verdict.prefixConfirmed} confirmed against the recording, ${verdict.prefixDivergences.length} divergent (${verdict.prefixDivergencePct}%) — ${verdict.prefixReturncodeMismatches} returncode mismatches, ${verdict.prefixUnknownExpectations} with no recorded returncode to check.`);
+	lines.push("");
+	lines.push(`Within the 10% admission tolerance: **${verdict.prefixWithinTolerance}**.`);
+	if (verdict.prefixDivergences.length > 0) {
+		lines.push("");
+		lines.push("| step | kind | recorded rc | replayed exit |");
+		lines.push("| --- | --- | --- | --- |");
+		for (const d of verdict.prefixDivergences) lines.push(`| ${d.step} | ${d.kind} | ${d.expectedReturncode ?? "none recorded"} | ${d.actualExit} |`);
+	}
+	lines.push("");
+	lines.push("## Arm A — recorded step k, replayed");
+	lines.push("");
+	lines.push("```sh");
+	lines.push(armA.command);
+	lines.push("```");
+	lines.push("");
+	lines.push(`Exit ${armA.exitCode} in ${armA.wallMs}ms — failureSignatureMatch: **${verdict.armA.failureSignatureMatch}**`);
+	lines.push("");
+	lines.push("Recorded observation excerpt:");
+	lines.push("");
+	lines.push("```");
+	lines.push(excerpt(parseObservationOutput(target.observation)));
+	lines.push("```");
+	lines.push("");
+	lines.push("Replayed stdout+stderr excerpt:");
+	lines.push("");
+	lines.push("```");
+	lines.push(excerpt(`${armA.stdout}\n${armA.stderr}`.trim()));
+	lines.push("```");
+	if (armB && verdict.armB) {
+		lines.push("");
+		lines.push("## Arm B — corrected step k");
+		lines.push("");
+		lines.push("```sh");
+		lines.push(armB.command);
+		lines.push("```");
+		lines.push("");
+		lines.push(`Exit ${armB.exitCode} in ${armB.wallMs}ms — failureVanished: **${verdict.armB.failureVanished}** (prefix re-replayed in a fresh session: ${verdict.armB.prefix.prefixExecuted} steps, ${verdict.armB.prefix.prefixDivergences.length} divergences, ${verdict.armB.prefix.prefixDivergencePct}%)`);
+		lines.push("");
+		lines.push("Replayed stdout+stderr excerpt:");
+		lines.push("");
+		lines.push("```");
+		lines.push(excerpt(`${armB.stdout}\n${armB.stderr}`.trim()));
+		lines.push("```");
+	}
+	lines.push("");
+	lines.push("## Timings");
+	lines.push("");
+	lines.push(`arm A ${verdict.timings.armAMs}ms, arm B ${verdict.timings.armBMs ?? "—"}ms, total ${verdict.timings.totalMs}ms.`);
+	lines.push("");
+	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 the
+*     recorded returncode at k;
+*   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.
+*/
+/** Deterministic PRNG for the fix-case sample; the seed lands in the report. */
+function mulberry32(seed) {
+	let state = seed >>> 0;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let t = state;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+function seededSample(items, size, seed) {
+	const pool = [...items];
+	const random = mulberry32(seed);
+	for (let i = pool.length - 1; i > 0; i--) {
+		const j = Math.floor(random() * (i + 1));
+		[pool[i], pool[j]] = [pool[j], pool[i]];
+	}
+	return new Set(pool.slice(0, size));
+}
+function caseOutDirName(row) {
+	return `${row.corpus}--${row.trajId}`.replaceAll(/[^A-Za-z0-9._-]/g, "_").slice(0, 180);
+}
+/**
+* Arm B standalone: fresh sandbox, prefix replay, corrected step k. Reuses
+* the same counterfactual scaffold as replayVerify without re-running arm A.
+*/
+async function executeArmB(replayCase, fixCommand, backend, signature, stepTimeoutMs, prefixLimit, onProgress) {
+	const store = new InMemoryTraceStore();
+	const { runId } = await ingestRecordedTrajectory(store, replayCase.steps, replayCase.trajId);
+	const runner = new SandboxCounterfactualRunner(backend, {
+		cwd: replayCase.cwd,
+		stepTimeoutMs,
+		prefixLimit,
+		onProgress
+	});
+	await runCounterfactual(store, runId, {
+		kind: "custom",
+		at: replayCase.k - 1,
+		describe: "arm-B corrected step",
+		apply: (step) => ({
+			...step,
+			span: {
+				...step.span,
+				args: { command: fixCommand }
+			}
+		})
+	}, runner);
+	const exec = runner.lastArm;
+	if (!exec) throw new Error("arm B finished without executing the corrected step");
+	const prefix = runner.lastPrefix;
+	if (!prefix) throw new Error("arm B reported no prefix replay result");
+	const output = `${exec.stdout}\n${exec.stderr}`;
+	return {
+		exitCode: exec.exitCode,
+		prefixExecuted: prefix.prefixExecuted,
+		prefixDivergences: prefix.prefixDivergences.length,
+		prefixDivergencePct: prefix.prefixDivergencePct,
+		failureVanished: exec.exitCode === 0 && (signature ? !output.includes(signature) : true),
+		stdout: exec.stdout,
+		stderr: exec.stderr
+	};
+}
+function rate(numerator, denominator) {
+	return denominator > 0 ? numerator / denominator : null;
+}
+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
+		};
+		if (!preparation.succeeded) {
+			pullFailures.push({
+				corpus: replayCase.corpus,
+				trajId: replayCase.trajId,
+				image: replayCase.image,
+				error: preparation.error
+			});
+			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
+			};
+			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)`);
+		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}`)
+			});
+			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.prefixWithinTolerance && returncodeMatch,
+				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
+			};
+			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)}`);
+			}
+		}
+		llm = {
+			model: options.fixModelLabel ?? "unknown",
+			calls,
+			failures,
+			promptTokens,
+			completionTokens,
+			callsWithoutUsage
+		};
+	}
+	const executedRows = rows.filter((r) => r.status === "ok");
+	const replayed = executedRows.filter((r) => r.replayed);
+	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 = {
+		executedSteps,
+		divergentSteps,
+		returncodeMismatches: sumOver((r) => r.prefixReturncodeMismatches),
+		unknownExpectations: sumOver((r) => r.prefixUnknownExpectations),
+		divergencePct: executedSteps > 0 ? Number((divergentSteps / executedSteps * 100).toFixed(1)) : null,
+		tolerancePct: 10,
+		casesWithinTolerance: executedRows.filter((r) => r.prefixDivergencePct !== null && r.prefixDivergencePct <= 10).length,
+		casesExecuted: executedRows.length
+	};
+	const signatureStrict = executedRows.filter((r) => r.replayed && r.armASignatureMatch);
+	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);
+	const flippedNonzeroRc = armBNonzeroRc.filter((r) => r.fix.failureVanished === true);
+	const attempt1Executed = rows.filter((r) => r.fix?.attempts?.find((a) => a.attempt === 1)?.executed === true);
+	const flippedAt1 = rows.filter((r) => r.fix?.flippedAtAttempt === 1);
+	const flipsByAttempt = {};
+	for (const row of rows) {
+		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] ??= {
+		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 = {
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		corpora: options.corpora.map((c) => ({
+			name: c.name,
+			labelsPath: c.labelsPath,
+			preparedDir: c.preparedDir
+		})),
+		totals: {
+			labelEntries: enumeration.labelEntryCount,
+			replayable: enumeration.replayable.length,
+			executed: selected.length,
+			excludedByReason,
+			submitGoldsByCorpus
+		},
+		headline: {
+			replayabilityRate: {
+				numerator: replayed.length,
+				denominator: selected.length,
+				value: rate(replayed.length, selected.length)
+			},
+			signatureStrictRate: {
+				numerator: signatureStrict.length,
+				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
+		},
+		llm,
+		excluded: enumeration.excluded,
+		pullFailures,
+		cases: rows
+	};
+	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 the recorded returncode 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
+/**
+* Finding-to-replay wire: the entry point that turns a cited incorrect-steps
+* finding into an executed replay proof.
+*
+* An analyst finding over a labeled trajectory corpus names its trajectory and
+* carries a subject of the form
+* `incorrect-steps-<first>-<last>-<escaped|unescaped>-consequence-<step>`.
+* The wire maps that to a replay invocation: the executed step is the
+* finding's first incorrect step (which may differ from the gold label), the
+* image and cwd come from the trajectory's raw config, and — optionally — an
+* arm-B corrected command comes from the counterfactual fix generator.
+*/
+const SUBJECT_PATTERN = /^incorrect-steps-(\d+)-(\d+)-(escaped|unescaped)-consequence-(\d+)$/;
+/** Null when the subject is not an incorrect-steps finding subject. */
+function parseIncorrectStepsSubject(subject) {
+	const match = SUBJECT_PATTERN.exec(subject);
+	if (!match) return null;
+	return {
+		firstStep: Number(match[1]),
+		lastStep: Number(match[2]),
+		escapeStatus: match[3],
+		consequenceStep: Number(match[4])
+	};
+}
+/**
+* Maps a finding onto replay resources, searching the given corpora for the
+* trajectory. Throws with the precise reason when the finding cannot be
+* replayed (malformed subject, unknown trajectory, non-replayable case, step
+* out of range) — the caller surfaces that reason instead of a proof.
+*/
+function resolveFindingInvocation(finding, corpora) {
+	const subject = parseIncorrectStepsSubject(finding.subject);
+	if (!subject) throw new Error(`trajectory-replay: subject '${finding.subject}' is not incorrect-steps-<first>-<last>-<escaped|unescaped>-consequence-<step>`);
+	const failures = [];
+	for (const corpus of corpora) {
+		const resolution = resolveCaseResources(corpus, finding.trajId);
+		if (resolution.resolved) {
+			const at = subject.firstStep;
+			if (!resolution.resources.steps.find((s) => s.step_id === at)) throw new Error(`trajectory-replay: finding step ${at} is outside ${finding.trajId} (${resolution.resources.steps.length} steps)`);
+			return {
+				resources: resolution.resources,
+				subject,
+				at
+			};
+		}
+		failures.push(`${corpus.name}: ${resolution.reason}`);
+	}
+	throw new Error(`trajectory-replay: trajectory ${finding.trajId} is not replayable in any corpus — ${failures.join("; ")}`);
+}
+/**
+* Finding in, executed proof out. The image comes from the corpus resources;
+* the backend factory receives it as-is, so a factory backed by infrastructure
+* that needs a derived image must run an `ImagePreparer` first.
+*/
+async function replayVerifyFinding(finding, options) {
+	if (options.fixCaller && options.fixCommand !== void 0) throw new Error("trajectory-replay: pass fixCaller or fixCommand, not both");
+	const invocation = resolveFindingInvocation(finding, options.corpora);
+	let fixCommand = options.fixCommand ?? null;
+	if (options.fixCaller) {
+		const generated = await generateFixCommand(options.fixCaller, {
+			taskStatement: invocation.resources.taskStatement,
+			steps: invocation.resources.steps,
+			k: invocation.at
+		});
+		if (!generated.succeeded) throw new Error(`trajectory-replay: fix generation failed — ${generated.error}`);
+		fixCommand = generated.value.command;
+	}
+	const verdict = await replayVerify({
+		stepsPath: invocation.resources.stepsPath,
+		image: invocation.resources.image,
+		at: invocation.at,
+		fixCommand: fixCommand ?? void 0,
+		cwd: invocation.resources.cwd,
+		out: options.out,
+		caseId: invocation.resources.trajId,
+		stepTimeoutMs: options.stepTimeoutMs ?? invocation.resources.recordedStepTimeoutMs ?? void 0,
+		prefixLimit: options.prefixLimit,
+		backend: options.backendFactory(invocation.resources.image),
+		onProgress: options.onProgress
+	});
+	return {
+		invocation,
+		fixCommand,
+		verdict
+	};
+}
+//#endregion
+//#region src/trajectory-replay/findings.ts
+/**
+* Proof-carrying findings: execute analyst findings as replays.
+*
+* An analyst finding is a cited claim ("step 12 is where the run went
+* wrong"). This module turns each finding into an executed verdict by
+* replaying the trajectory prefix and running the accused step (arm A),
+* optionally followed by a corrected step (arm B):
+*
+*   `reproduced`     arm A re-produced the recorded failure signature
+*                    (returncode + stable output substring).
+*   `fix-flipped`    arm A reproduced AND arm B's corrected command made the
+*                    failure vanish — the strongest per-finding proof.
+*   `divergent`      arm A executed but the recorded failure did NOT
+*                    reproduce; evidence against the finding (or against
+*                    replay fidelity — the receipt carries prefix
+*                    divergences so the reader can tell which).
+*   `not-replayable` the finding could not be executed at all; the receipt
+*                    carries the precise reason (no step subject, unknown
+*                    trajectory, no recorded image, submit step, …).
+*
+* Verification is execution, not generation: no LLM is involved unless the
+* caller supplies a corrected command for arm B. A caller whose execution
+* environment must be reachable before proofs run passes `preflight`, which
+* fails loud instead of letting verification skip silently.
+*
+* Findings are matched by the shape the analyst product emits
+* (`AnalystFinding`): `subject` (`incorrect-step-<n>` or the wire's
+* `incorrect-steps-<f>-<l>-<escaped|unescaped>-consequence-<c>`),
+* `metadata.block_first_step`, and `trace://<traj>/…` evidence refs.
+*/
+const SINGLE_STEP_SUBJECT = /^incorrect-step-(\d+)$/;
+/**
+* 1-based step the finding accuses, or null when the finding names none.
+* `metadata.block_first_step` wins over the subject: the analyst records the
+* block's first incorrect step there even when the subject names a later
+* step of the same block.
+*/
+function findingReplayStep(finding) {
+	const fromMetadata = finding.metadata?.block_first_step;
+	if (typeof fromMetadata === "number" && Number.isInteger(fromMetadata) && fromMetadata >= 1) return fromMetadata;
+	const subject = finding.subject ?? "";
+	const wire = parseIncorrectStepsSubject(subject);
+	if (wire) return wire.firstStep;
+	const single = SINGLE_STEP_SUBJECT.exec(subject);
+	if (single) return Number(single[1]);
+	return null;
+}
+const TRACE_EVIDENCE_URI = /^trace:\/\/([^/]+)\//;
+/** Trajectory id from the finding's `trace://<traj>/…` evidence refs, or null. */
+function findingTrajectoryId(finding) {
+	for (const ref of finding.evidence_refs ?? []) {
+		if (typeof ref.uri !== "string") continue;
+		const match = TRACE_EVIDENCE_URI.exec(ref.uri);
+		if (match) return match[1];
+	}
+	return null;
+}
+function checkStep(steps, at) {
+	const step = steps.find((s) => s.step_id === at);
+	if (!step) return {
+		ok: false,
+		reason: `step ${at} is outside the trajectory (${steps.length} steps)`
+	};
+	if (isSubmitAction(step.action)) return {
+		ok: false,
+		reason: `step ${at} is the submit action — a submit decision has no executable failure to replay`
+	};
+	const recordedReturncode = parseRecordedReturncode(step.observation);
+	if (recordedReturncode === null) return {
+		ok: false,
+		reason: `step ${at} recorded no returncode — there is no executable failure signature to reproduce`
+	};
+	return {
+		ok: true,
+		recordedReturncode
+	};
+}
+/**
+* Decides whether one finding can be executed against the source, and with
+* what invocation. Never throws for a finding-shaped problem — every dead end
+* becomes a `not-replayable` reason the receipt can carry verbatim.
+*/
+function resolveFindingReplayability(finding, source) {
+	const at = findingReplayStep(finding);
+	if (at === null) return {
+		replayable: false,
+		reason: `subject '${finding.subject ?? "(none)"}' names no trajectory step (expected incorrect-step-<n>, incorrect-steps-<f>-<l>-…, or metadata.block_first_step)`
+	};
+	if (source.kind === "direct") {
+		const trajId = findingTrajectoryId(finding);
+		if (trajId && source.caseId && trajId !== source.caseId) return {
+			replayable: false,
+			reason: `finding cites trajectory '${trajId}' but the supplied steps are case '${source.caseId}'`
+		};
+		let steps;
+		try {
+			steps = JSON.parse(readFileSync(source.stepsPath, "utf8"));
+		} catch (err) {
+			throw new Error(`verify-findings: cannot read steps file ${source.stepsPath} — ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (!Array.isArray(steps) || steps.length === 0) throw new Error(`verify-findings: ${source.stepsPath} is not a non-empty steps array`);
+		const step = checkStep(steps, at);
+		if (!step.ok) return {
+			replayable: false,
+			reason: step.reason
+		};
+		return {
+			replayable: true,
+			resolved: {
+				caseId: source.caseId ?? trajId ?? source.stepsPath,
+				stepsPath: source.stepsPath,
+				image: source.image,
+				cwd: source.cwd,
+				at,
+				recordedReturncode: step.recordedReturncode,
+				recordedStepTimeoutMs: null
+			}
+		};
+	}
+	const trajId = findingTrajectoryId(finding);
+	if (!trajId) return {
+		replayable: false,
+		reason: "finding carries no trace://<trajectory>/ evidence ref naming its trajectory"
+	};
+	const failures = [];
+	for (const corpus of source.corpora) {
+		const resolution = resolveCaseResources(corpus, trajId);
+		if (!resolution.resolved) {
+			failures.push(`${corpus.name}: ${resolution.reason}${resolution.detail ? ` (${resolution.detail})` : ""}`);
+			continue;
+		}
+		const step = checkStep(resolution.resources.steps, at);
+		if (!step.ok) return {
+			replayable: false,
+			reason: step.reason
+		};
+		return {
+			replayable: true,
+			resolved: {
+				caseId: trajId,
+				stepsPath: resolution.resources.stepsPath,
+				image: resolution.resources.image,
+				cwd: resolution.resources.cwd,
+				at,
+				recordedReturncode: step.recordedReturncode,
+				recordedStepTimeoutMs: resolution.resources.recordedStepTimeoutMs
+			}
+		};
+	}
+	return {
+		replayable: false,
+		reason: `trajectory ${trajId} is not replayable in any corpus — ${failures.join("; ")}`
+	};
+}
+/**
+* Arm A reproduced on a prefix the recording confirmed → the fix flipping it
+* beats plain reproduction; anything else diverged. A proof standing on a
+* prefix outside the divergence tolerance is divergent no matter what arm A
+* did: the state it ran against is not the recorded state.
+*/
+function classifyVerdict(verdict) {
+	if (!verdict.prefixWithinTolerance) return "divergent";
+	if (!verdict.armA.failureSignatureMatch) return "divergent";
+	if (verdict.armB?.failureVanished) return "fix-flipped";
+	return "reproduced";
+}
+function receiptExecution(verdict) {
+	return {
+		image: verdict.image,
+		cwd: verdict.cwd,
+		recordedReturncode: verdict.recordedReturncode,
+		signature: verdict.signature,
+		signatureBasis: verdict.signatureBasis,
+		armA: {
+			command: verdict.armA.command,
+			exitCode: verdict.armA.exitCode,
+			wallMs: verdict.armA.wallMs,
+			failureSignatureMatch: verdict.armA.failureSignatureMatch
+		},
+		armB: verdict.armB ? {
+			command: verdict.armB.command,
+			exitCode: verdict.armB.exitCode,
+			wallMs: verdict.armB.wallMs,
+			failureVanished: verdict.armB.failureVanished
+		} : null,
+		prefixExecuted: verdict.prefixExecuted,
+		prefixDivergences: verdict.prefixDivergences.length,
+		prefixDivergencePct: verdict.prefixDivergencePct,
+		prefixReturncodeMismatches: verdict.prefixReturncodeMismatches,
+		prefixUnknownExpectations: verdict.prefixUnknownExpectations,
+		prefixWithinTolerance: verdict.prefixWithinTolerance,
+		totalMs: verdict.timings.totalMs
+	};
+}
+function writeReceipt(receiptDir, finding, verification, execution) {
+	const receipt = {
+		schema_version: "1.0.0",
+		produced_at: (/* @__PURE__ */ new Date()).toISOString(),
+		finding_id: verification.finding_id,
+		analyst_id: finding.analyst_id ?? null,
+		subject: verification.subject,
+		claim: typeof finding.claim === "string" ? finding.claim.slice(0, 600) : null,
+		trajectory_id: verification.trajectory_id,
+		step: verification.step,
+		verified: verification.verified,
+		reason: verification.reason,
+		execution,
+		verdict_path: verification.verdict_path,
+		deduplicated_with: verification.deduplicated_with
+	};
+	writeFileSync(join(receiptDir, "receipt.json"), `${JSON.stringify(receipt, null, 2)}\n`);
+}
+function receiptDirName(index, finding) {
+	const id = typeof finding.finding_id === "string" && finding.finding_id.length > 0 ? finding.finding_id.replace(/[^A-Za-z0-9_-]/g, "_") : "finding";
+	return `${String(index + 1).padStart(3, "0")}-${id}`;
+}
+/**
+* Verifies every finding against the source: resolves replayability, executes
+* one proof per distinct (case, step, fix) — findings accusing the same step
+* share the executed proof — and writes a receipt directory per finding plus a
+* run-level verifications.json.
+*/
+async function verifyFindings(findings, options) {
+	if (findings.length === 0) throw new Error("verify-findings: no findings to verify");
+	mkdirSync(options.out, { recursive: true });
+	const resolutions = findings.map((finding) => resolveFindingReplayability(finding, options.source));
+	if (resolutions.some((resolution) => resolution.replayable) && options.preflight) await options.preflight();
+	const preparer = options.source.kind === "corpus" ? options.source.preparer === void 0 ? dockerImagePreparer() : options.source.preparer : null;
+	const preparedImages = /* @__PURE__ */ new Map();
+	const executedByKey = /* @__PURE__ */ new Map();
+	const verifications = [];
+	let executions = 0;
+	for (let index = 0; index < findings.length; index++) {
+		const finding = findings[index];
+		const resolution = resolutions[index];
+		const receiptDir = join(options.out, receiptDirName(index, finding));
+		mkdirSync(receiptDir, { recursive: true });
+		const identity = {
+			finding_id: finding.finding_id ?? null,
+			subject: finding.subject ?? null,
+			trajectory_id: findingTrajectoryId(finding)
+		};
+		if (!resolution.replayable) {
+			const verification = {
+				...identity,
+				step: findingReplayStep(finding),
+				verified: "not-replayable",
+				reason: resolution.reason,
+				receipt: receiptDir,
+				verdict_path: null,
+				deduplicated_with: null
+			};
+			writeReceipt(receiptDir, finding, verification, null);
+			verifications.push(verification);
+			options.onProgress?.(`${identity.finding_id ?? `finding ${index + 1}`}: not-replayable — ${resolution.reason}`);
+			continue;
+		}
+		const resolved = resolution.resolved;
+		const dedupeKey = `${resolved.caseId}::${resolved.at}::${options.fixCommand ?? ""}`;
+		const prior = executedByKey.get(dedupeKey);
+		if (prior) {
+			const verification = {
+				...identity,
+				step: resolved.at,
+				verified: prior.verified,
+				reason: prior.reason,
+				receipt: receiptDir,
+				verdict_path: prior.verdict_path,
+				deduplicated_with: prior.receipt
+			};
+			const priorVerdict = prior.verdict_path ? JSON.parse(readFileSync(prior.verdict_path, "utf8")) : null;
+			writeReceipt(receiptDir, finding, verification, priorVerdict ? receiptExecution(priorVerdict) : null);
+			verifications.push(verification);
+			options.onProgress?.(`${identity.finding_id ?? `finding ${index + 1}`}: ${prior.verified} (shares proof with ${prior.finding_id ?? prior.receipt})`);
+			continue;
+		}
+		let image = resolved.image;
+		if (preparer) {
+			const preparationKey = `${resolved.image}::${resolved.cwd}`;
+			let preparation = preparedImages.get(preparationKey);
+			if (!preparation) {
+				const ensured = await preparer.ensure(resolved.image, resolved.cwd);
+				preparation = ensured.succeeded ? {
+					succeeded: true,
+					image: ensured.value.derivedImage
+				} : {
+					succeeded: false,
+					error: ensured.error
+				};
+				preparedImages.set(preparationKey, preparation);
+			}
+			if (!preparation.succeeded) {
+				const verification = {
+					...identity,
+					step: resolved.at,
+					verified: "not-replayable",
+					reason: `replay image could not be prepared — ${preparation.error}`,
+					receipt: receiptDir,
+					verdict_path: null,
+					deduplicated_with: null
+				};
+				writeReceipt(receiptDir, finding, verification, null);
+				verifications.push(verification);
+				options.onProgress?.(`${identity.finding_id ?? `finding ${index + 1}`}: not-replayable — image preparation failed`);
+				continue;
+			}
+			image = preparation.image;
+		}
+		options.onProgress?.(`${identity.finding_id ?? `finding ${index + 1}`}: executing arm A at step ${resolved.at} of ${resolved.caseId} on ${image}`);
+		const verdict = await replayVerify({
+			stepsPath: resolved.stepsPath,
+			image,
+			at: resolved.at,
+			fixCommand: options.fixCommand,
+			cwd: resolved.cwd,
+			out: receiptDir,
+			caseId: resolved.caseId,
+			stepTimeoutMs: options.stepTimeoutMs ?? resolved.recordedStepTimeoutMs ?? void 0,
+			prefixLimit: options.prefixLimit,
+			backend: options.backendFactory(image),
+			onProgress: options.onProgress
+		});
+		executions += 1;
+		const verification = {
+			...identity,
+			step: resolved.at,
+			verified: classifyVerdict(verdict),
+			reason: null,
+			receipt: receiptDir,
+			verdict_path: join(receiptDir, "replay-verdict.json"),
+			deduplicated_with: null
+		};
+		executedByKey.set(dedupeKey, verification);
+		writeReceipt(receiptDir, finding, verification, receiptExecution(verdict));
+		verifications.push(verification);
+		options.onProgress?.(`${identity.finding_id ?? `finding ${index + 1}`}: ${verification.verified}`);
+	}
+	const counts = {
+		reproduced: 0,
+		"fix-flipped": 0,
+		divergent: 0,
+		"not-replayable": 0
+	};
+	for (const verification of verifications) counts[verification.verified] += 1;
+	const run = {
+		out: options.out,
+		verifications,
+		counts,
+		executions
+	};
+	writeFileSync(join(options.out, "verifications.json"), `${JSON.stringify({
+		schema_version: "1.0.0",
+		...run
+	}, 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 { PREFIX_DIVERGENCE_TOLERANCE_PCT, SUBMIT_ACTION_SIGNATURE, SandboxCounterfactualRunner, buildFixPrompt, buildRetryFixPrompt, classifyPrefixStep, classifyVerdict, clipText, countScriptCommands, deriveFailureSignature, derivedImageTag, dockerImagePreparer, enumerateReplayableCases, extractFixCommand, findingReplayStep, findingTrajectoryId, generateFixCommand, goldIncorrectSteps, ingestRecordedTrajectory, isSubmitAction, parseCorpusFlag, parseIncorrectStepsSubject, parseObservationOutput, parseRecordedReturncode, readFindingsFile, readLabelEntries, renderBatchReport, renderVerifiedFindingsSection, replayVerify, replayVerifyFinding, resolveCaseResources, resolveFindingInvocation, resolveFindingReplayability, runFixLoop, runReplayBatch, seededSample, summarizePrefixReplay, verifyFindings, wrapActionForExec };
+
+//# sourceMappingURL=index.js.map