@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/trace-repair/index.js

@@ -1,15 +1,162 @@
-import { n as CaptureIntegrityError, s as ValidationError } from "../errors-Dngq5h35.js";
-import { i as compareCodeUnits } from "../canonical-BsZVgBhW.js";
-import { r as pairedBootstrap } from "../paired-tests-jbwPdSz5.js";
-import { n as contentHash } from "../verdict-cache-BQEsVy9n.js";
-import { t as certificationEvidenceDigest } from "../verdict-DhPoXApk.js";
+import { c as errorMessage, n as CaptureIntegrityError, s as ValidationError } from "../errors-BcOs5MKW.js";
+import { i as compareCodeUnits } from "../canonical-Dq2hOQ8L.js";
+import { i as pairedBootstrap, t as mean } from "../mean-BbA_JCzW.js";
+import { n as contentHash } from "../verdict-cache-CL_7tePD.js";
+import { n as isRecord } from "../json-BhdsJaOQ.js";
+import { t as certificationEvidenceDigest } from "../verdict-BGQmxQ8A.js";
 import { t as packageVersion } from "../package-version-D7lQHt_-.js";
-import { t as assertEqualDeclarativeTerms } from "../equal-terms-Blx9Zk5I.js";
-import { d as runPrimeExchange, n as buildPrimePrompt, t as analystUsageReceiptFromPrimeUsage } from "../prime-protocol-DcAK9pC8.js";
-import { c as deriveFailureSignature, d as isRecordedTimeout, h as parseRecordedReturncode, i as TIMEOUT_OBSERVATION_MARKER, n as FORMAT_ERROR_OBSERVATION_PREFIX, r as SUBMIT_ACTION_SIGNATURE, t as wrapActionForExec } from "../exec-ChJ6d5if.js";
+import { t as assertEqualDeclarativeTerms } from "../equal-terms-DbPGcVtI.js";
+import { c as runPrimeExchange, n as buildPrimePrompt, t as analystUsageReceiptFromPrimeUsage } from "../prime-protocol-BFgGrEMP.js";
+import { i as TIMEOUT_OBSERVATION_MARKER, l as isRecordedTimeout, n as FORMAT_ERROR_OBSERVATION_PREFIX, p as parseRecordedReturncode, r as SUBMIT_ACTION_SIGNATURE, s as deriveFailureSignature, t as wrapActionForExec } from "../exec-CpbtOXVt.js";
 import { createHash } from "node:crypto";
 import { constants } from "node:os";
 import { spawn } from "node:child_process";
+//#region src/trace-repair/admission-records.ts
+/**
+* The vocabulary of the TB-Repair admission pre-pass: what a corpus row is,
+* which failure population it belongs to, why it can leave the funnel, and the
+* denominator chain those exclusions add up to.
+*
+* Pure data and pure functions. The gate that spends containers on these types
+* lives in `admission.ts`, and the artifact that publishes them lives in
+* `admission-report.ts`.
+*/
+/** A campaign scored rows the pre-pass did not admit, or dropped rows it did. */
+var AdmissionDenominatorError = class extends CaptureIntegrityError {};
+/** A row handed to the pre-pass carried a field only an analyst could produce. */
+var AdmissionIndependenceError = class extends CaptureIntegrityError {};
+const ADMISSION_ROW_KEYS = [
+	"rowId",
+	"taskName",
+	"recordedModel",
+	"recordedCommands",
+	"finalReturncode"
+];
+/**
+* Reject rows that carry anything beyond the recording.
+*
+* The check is a closed key list rather than a list of known analyst field
+* names, because the failure to catch is "some new analyst output leaked into
+* the gate", and only a closed shape catches the fields nobody thought of.
+*/
+function assertAnalystIndependent(rows) {
+	const allowed = new Set(ADMISSION_ROW_KEYS);
+	for (const row of rows) {
+		const extra = Object.keys(row).filter((key) => !allowed.has(key));
+		if (extra.length > 0) throw new AdmissionIndependenceError(`admission row ${String(row.rowId)} carries analyst-side fields: ${extra.sort().join(", ")}`);
+	}
+}
+const ADMISSION_STRATA = [
+	"clean-exit",
+	"command-error",
+	"signal-kill"
+];
+/** `null` when the recording holds no parseable final return code. */
+function stratumOf(finalReturncode) {
+	if (finalReturncode === null || !Number.isInteger(finalReturncode)) return null;
+	if (finalReturncode === 0) return "clean-exit";
+	return finalReturncode < 0 ? "signal-kill" : "command-error";
+}
+const ADMISSION_EXCLUSION_ORDER = [
+	"no-recorded-commands",
+	"unparseable-final-returncode",
+	"stratum-not-admitted",
+	"task-oracle-uncertified",
+	"task-oracle-nondeterministic",
+	"prefix-replay-error",
+	"prefix-replay-empty",
+	"prefix-replay-truncated",
+	"prefix-divergence-above-threshold",
+	"end-state-oracle-error",
+	"end-state-tests-pass",
+	"no-fix-control-error",
+	"no-fix-control-rescued",
+	"no-op-control-error",
+	"no-op-control-rescued"
+];
+/** Reasons decided from the recording alone, before a row can be stratified. */
+const PRE_STRATUM_REASONS = ["no-recorded-commands", "unparseable-final-returncode"];
+function isPreStratumReason(reason) {
+	return PRE_STRATUM_REASONS.includes(reason);
+}
+/** One line of prose per reason, for the rendered chain. */
+const ADMISSION_EXCLUSION_MEANING = Object.freeze({
+	"no-recorded-commands": "the recording holds no command to substitute",
+	"unparseable-final-returncode": "the last observation carries no return code",
+	"stratum-not-admitted": "the row belongs to a population this campaign excluded",
+	"task-oracle-uncertified": "the task grader has no determinism certification on file",
+	"task-oracle-nondeterministic": "the task grader returns different verdicts on byte-identical state",
+	"prefix-replay-error": "the replay boundary failed, so divergence is unmeasured",
+	"prefix-replay-empty": "the replay executed no recorded step",
+	"prefix-replay-truncated": "the replay stopped short of the recorded end state",
+	"prefix-divergence-above-threshold": "replaying the prefix did not reproduce the recording",
+	"end-state-oracle-error": "the task grader failed, so the end state is unjudged",
+	"end-state-tests-pass": "the task tests pass on the recorded end state, so nothing failed",
+	"no-fix-control-error": "a no-fix rollout failed to run, so the control is unmeasured",
+	"no-fix-control-rescued": "the continuation policy passes the task with no intervention",
+	"no-op-control-error": "a no-op rollout failed to run, so the control is unmeasured",
+	"no-op-control-rescued": "an inert action plus continuation passes the task"
+});
+/**
+* Build the funnel every campaign report publishes.
+*
+* Each stage names the reason, the rows that reached it, the rows it removed,
+* and the rows that survived, so `input = admitted + sum(excluded)` can be read
+* off the table instead of trusted.
+*/
+function buildDenominatorChain(verdicts, admitStrata) {
+	const reasonTotals = emptyReasonTotals();
+	for (const verdict of verdicts) if (verdict.excludedBy !== null) reasonTotals[verdict.excludedBy] += 1;
+	const stratumReasons = ADMISSION_EXCLUSION_ORDER.filter((reason) => !isPreStratumReason(reason));
+	const artifact = {
+		version: 1,
+		overall: chainOf("all", verdicts, ADMISSION_EXCLUSION_ORDER),
+		byStratum: ADMISSION_STRATA.filter((stratum) => verdicts.some((verdict) => verdict.stratum === stratum)).map((stratum) => chainOf(stratum, verdicts.filter((verdict) => verdict.stratum === stratum), stratumReasons)),
+		reasonTotals,
+		unstratified: verdicts.filter((verdict) => verdict.stratum === null).length,
+		admitStrata: [...admitStrata]
+	};
+	assertChainReconciles(artifact);
+	return artifact;
+}
+function chainOf(scope, verdicts, reasons) {
+	let remaining = verdicts.length;
+	const stages = [];
+	for (const reason of reasons) {
+		const excluded = verdicts.filter((verdict) => verdict.excludedBy === reason).length;
+		const entering = remaining;
+		remaining -= excluded;
+		stages.push({
+			reason,
+			entering,
+			excluded,
+			remaining
+		});
+	}
+	return {
+		scope,
+		input: verdicts.length,
+		stages,
+		admitted: verdicts.filter((verdict) => verdict.admitted).length
+	};
+}
+function emptyReasonTotals() {
+	const totals = {};
+	for (const reason of ADMISSION_EXCLUSION_ORDER) totals[reason] = 0;
+	return totals;
+}
+/** A chain that does not add up is a broken denominator, so this throws. */
+function assertChainReconciles(artifact) {
+	for (const chain of [artifact.overall, ...artifact.byStratum]) {
+		const excluded = chain.stages.reduce((total, stage) => total + stage.excluded, 0);
+		if (chain.input !== chain.admitted + excluded) throw new AdmissionDenominatorError(`denominator chain (${chain.scope}) does not reconcile: input ${chain.input} != admitted ${chain.admitted} + excluded ${excluded}`);
+		const last = chain.stages[chain.stages.length - 1];
+		if (last && last.remaining !== chain.admitted) throw new AdmissionDenominatorError(`denominator chain (${chain.scope}) ends at ${last.remaining} rows but reports ${chain.admitted} admitted`);
+	}
+	const stratumInputs = artifact.byStratum.reduce((total, chain) => total + chain.input, 0);
+	if (stratumInputs + artifact.unstratified !== artifact.overall.input) throw new AdmissionDenominatorError(`stratum inputs ${stratumInputs} plus ${artifact.unstratified} unstratified do not cover ${artifact.overall.input} input rows`);
+}
+//#endregion
 //#region src/trace-repair/mini-swe-scaffold.ts
 /**
 * The mini-swe-agent scaffold as the Terminal-Bench-2 trajectory corpus
@@ -154,7 +301,7 @@ function parseAction(assistantMessage) {
 function renderObservation(output) {
 	const head = output.exceptionInfo ? `<exception>${output.exceptionInfo}</exception>\n` : "";
 	const returncode = `<returncode>${output.returncode}</returncode>\n`;
-	if (output.output.length < 1e4) return `${head}${returncode}<output>\n${output.output}</output>`;
+	if (output.output.length < OUTPUT_ELISION_THRESHOLD) return `${head}${returncode}<output>\n${output.output}</output>`;
 	const elided = output.output.length - OUTPUT_ELISION_THRESHOLD;
 	return `${head}${returncode}<warning>\nThe output of your last command was too long.
 Please try a different command that produces less output.
@@ -196,582 +343,69 @@ function submissionOf(output) {
 	return lines.slice(1).join("");
 }
 //#endregion
-//#region src/trace-repair/action-budget.ts
+//#region src/trace-repair/continuation-policy.ts
+/** A rollout ran outside the pinned policy, so its evidence cannot be used. */
+var ContinuationPolicyViolationError = class extends CaptureIntegrityError {};
+/** Two arms did not run the same policy, so their difference is not the intervention. */
+var ContinuationSymmetryError = class extends CaptureIntegrityError {};
 /**
-* The action budget an intervention must fit inside.
-*
-* The analyst answers with one action, applied at step k, drawn from the same
-* action space the scaffold had: one shell command or one edit, at most 4 KB.
-* An answer that buys a bigger action than the scaffold could take is not a
-* counterfactual about the recorded run, so the budget is enforced before any
-* container is opened and a violation never reaches the reproduction gate.
+* Everything the policy fixes except the two a campaign must choose.
 *
-* "One action" is decided by counting top-level statements, not lines. A
-* command list joined by `&&`, `||` or a pipe is one statement, because that
-* is one thing the shell runs and one thing the scaffold could have typed.
-* Two statements separated by a newline or `;` are two actions and are
-* rejected. Heredoc bodies, comments and compound blocks (`if`, `for`,
-* `while`, `until`, `case`, `{ … }`) are inside a statement, never separators.
+* `commandTimeoutSeconds` is 30 because the recorded runs used the scaffold's
+* own 30-second environment timeout; a longer limit would let the continuation
+* finish commands the recorded agent could not.
 */
-/** The scaffold's own per-action budget, pre-registered for the campaign. */
-const SCAFFOLD_INTERVENTION_BUDGET = Object.freeze({
-	maxBytes: 4096,
-	maxStatements: 1,
-	maxHeredocs: 1
-});
+const CONTINUATION_POLICY_DEFAULTS = {
+	id: "tb-repair-continuation-v1",
+	stepBudget: 20,
+	temperature: 0,
+	maxTokens: 4096,
+	commandTimeoutSeconds: 30,
+	maxConsecutiveFormatErrors: 3,
+	networkMode: "none",
+	scaffold: "mini-swe-agent"
+};
+function definePinnedContinuationPolicy(input) {
+	const policy = {
+		...CONTINUATION_POLICY_DEFAULTS,
+		...input
+	};
+	if (!policy.model.trim()) throw new ValidationError("continuation policy requires a model id");
+	if (!Number.isInteger(policy.seed)) throw new ValidationError(`continuation policy seed must be an integer, got ${policy.seed}`);
+	requirePositiveInteger$1(policy.stepBudget, "stepBudget");
+	requirePositiveInteger$1(policy.maxTokens, "maxTokens");
+	requirePositiveInteger$1(policy.commandTimeoutSeconds, "commandTimeoutSeconds");
+	requirePositiveInteger$1(policy.maxConsecutiveFormatErrors, "maxConsecutiveFormatErrors");
+	if (!Number.isFinite(policy.temperature) || policy.temperature < 0) throw new ValidationError(`continuation policy temperature must be a non-negative number, got ${policy.temperature}`);
+	return Object.freeze(policy);
+}
+function requirePositiveInteger$1(value, field) {
+	if (!Number.isInteger(value) || value <= 0) throw new ValidationError(`continuation policy ${field} must be a positive integer, got ${value}`);
+}
 /**
-* Actions whose only effect is to consume a turn. They are rejected before a
-* container opens: an intervention that changes nothing is measurably
-* identical to the no-op control, and paying rollouts to rediscover that
-* wastes the corpus.
+* Hash over the policy and the scaffold text it renders. A changed template
+* changes the digest, so rollouts recorded before and after an edit cannot be
+* pooled by accident.
 */
-const NO_OP_ACTIONS = Object.freeze([
-	":",
-	"true",
-	"/bin/true",
-	"exit",
-	"exit 0"
-]);
-const BLOCK_OPENERS = /* @__PURE__ */ new Set([
-	"if",
-	"for",
-	"while",
-	"until",
-	"case",
-	"select",
-	"do",
-	"then"
-]);
-const BLOCK_CLOSERS = /* @__PURE__ */ new Set([
-	"fi",
-	"done",
-	"esac"
-]);
+function continuationPolicyDigest(policy) {
+	return contentHash({
+		policy: { ...policy },
+		systemMessage: MINI_SWE_SYSTEM_MESSAGE,
+		instanceMessage: renderInstanceMessage({
+			task: "<task>",
+			systemInformation: "<system>"
+		}),
+		formatErrorObservation: renderFormatErrorObservation(0),
+		timeoutObservation: renderTimeoutObservation("<command>", "<output>"),
+		observation: renderObservation({
+			returncode: 0,
+			output: ""
+		})
+	});
+}
 /**
-* Split a shell script into top-level statements and count its heredocs.
-*
-* The scan tracks quoting, escapes, command substitution, brace and paren
-* grouping, comments, compound-block keywords, and heredoc bodies. Anything
-* it cannot resolve stays inside the current statement, so an unparseable
-* action reads as one oversized statement and is rejected on bytes rather
-* than silently accepted as one clean action.
-*/
-function scanShellAction(script) {
-	const state = {
-		statements: [],
-		current: "",
-		heredocs: 0
-	};
-	let index = 0;
-	let parenDepth = 0;
-	let braceDepth = 0;
-	let blockDepth = 0;
-	let inSingle = false;
-	let inDouble = false;
-	let inBacktick = false;
-	let pendingHeredocs = [];
-	let word = "";
-	let atStatementStart = true;
-	const flushWord = () => {
-		if (word.length === 0) return;
-		if (BLOCK_OPENERS.has(word)) blockDepth += 1;
-		else if (BLOCK_CLOSERS.has(word)) blockDepth = Math.max(0, blockDepth - 1);
-		word = "";
-	};
-	const endStatement = () => {
-		flushWord();
-		const text = state.current.trim();
-		if (text.length > 0 && !isCommentOnly(text)) state.statements.push(text);
-		state.current = "";
-		atStatementStart = true;
-	};
-	while (index < script.length) {
-		const char = script[index];
-		if (inSingle) {
-			state.current += char;
-			if (char === "'") inSingle = false;
-			index += 1;
-			continue;
-		}
-		if (char === "\\" && index + 1 < script.length) {
-			const next = script[index + 1];
-			if (next === "\n" && !inDouble) {
-				state.current += char + next;
-				index += 2;
-				continue;
-			}
-			state.current += char + next;
-			index += 2;
-			continue;
-		}
-		if (inDouble) {
-			state.current += char;
-			if (char === "\"") inDouble = false;
-			index += 1;
-			continue;
-		}
-		if (char === "'") {
-			flushWord();
-			inSingle = true;
-			state.current += char;
-			index += 1;
-			atStatementStart = false;
-			continue;
-		}
-		if (char === "\"") {
-			flushWord();
-			inDouble = true;
-			state.current += char;
-			index += 1;
-			atStatementStart = false;
-			continue;
-		}
-		if (char === "`") {
-			inBacktick = !inBacktick;
-			state.current += char;
-			index += 1;
-			atStatementStart = false;
-			continue;
-		}
-		if (char === "#" && (atStatementStart || /\s/.test(script[index - 1] ?? " "))) {
-			const end = script.indexOf("\n", index);
-			const stop = end === -1 ? script.length : end;
-			state.current += script.slice(index, stop);
-			index = stop;
-			continue;
-		}
-		if (char === "<" && script[index + 1] === "<" && script[index + 2] !== "<" && script[index - 1] !== "<") {
-			const mark = readHeredocMark(script, index);
-			if (mark) {
-				pendingHeredocs.push(mark.mark);
-				state.heredocs += 1;
-				state.current += script.slice(index, mark.nextIndex);
-				index = mark.nextIndex;
-				atStatementStart = false;
-				continue;
-			}
-		}
-		if (char === "(") {
-			flushWord();
-			parenDepth += 1;
-			state.current += char;
-			index += 1;
-			atStatementStart = true;
-			continue;
-		}
-		if (char === ")") {
-			flushWord();
-			parenDepth = Math.max(0, parenDepth - 1);
-			state.current += char;
-			index += 1;
-			atStatementStart = false;
-			continue;
-		}
-		if (char === "{") {
-			flushWord();
-			braceDepth += 1;
-			state.current += char;
-			index += 1;
-			atStatementStart = true;
-			continue;
-		}
-		if (char === "}") {
-			flushWord();
-			braceDepth = Math.max(0, braceDepth - 1);
-			state.current += char;
-			index += 1;
-			atStatementStart = false;
-			continue;
-		}
-		if (char === "\n") {
-			flushWord();
-			if (pendingHeredocs.length > 0) {
-				const consumed = consumeHeredocBodies(script, index + 1, pendingHeredocs);
-				state.current += script.slice(index, consumed);
-				pendingHeredocs = [];
-				index = consumed;
-				continue;
-			}
-			if (parenDepth > 0 || braceDepth > 0 || blockDepth > 0 || inBacktick || endsWithContinuation(state.current)) {
-				state.current += char;
-				index += 1;
-				atStatementStart = true;
-				continue;
-			}
-			endStatement();
-			index += 1;
-			continue;
-		}
-		if (char === ";") {
-			flushWord();
-			if (parenDepth > 0 || braceDepth > 0 || blockDepth > 0 || inBacktick) {
-				state.current += char;
-				index += 1;
-				atStatementStart = true;
-				continue;
-			}
-			endStatement();
-			index += 1;
-			continue;
-		}
-		if (/\s/.test(char)) {
-			flushWord();
-			state.current += char;
-			index += 1;
-			continue;
-		}
-		if (char === "&" || char === "|") {
-			flushWord();
-			state.current += char;
-			index += 1;
-			atStatementStart = true;
-			continue;
-		}
-		word += char;
-		state.current += char;
-		atStatementStart = false;
-		index += 1;
-	}
-	endStatement();
-	return {
-		statements: state.statements,
-		heredocs: state.heredocs
-	};
-}
-function isCommentOnly(text) {
-	return text.split("\n").every((line) => line.trim().length === 0 || line.trim().startsWith("#"));
-}
-function endsWithContinuation(current) {
-	const trimmed = current.trimEnd();
-	return /(&&|\|\||\||&|\\)$/.test(trimmed);
-}
-function readHeredocMark(script, index) {
-	let cursor = index + 2;
-	let stripTabs = false;
-	if (script[cursor] === "-") {
-		stripTabs = true;
-		cursor += 1;
-	}
-	while (script[cursor] === " " || script[cursor] === "	") cursor += 1;
-	const quote = script[cursor];
-	if (quote === "'" || quote === "\"") {
-		const close = script.indexOf(quote, cursor + 1);
-		if (close === -1) return null;
-		return {
-			mark: {
-				delimiter: script.slice(cursor + 1, close),
-				stripTabs,
-				quoted: true
-			},
-			nextIndex: close + 1
-		};
-	}
-	const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(script.slice(cursor));
-	if (!match) return null;
-	return {
-		mark: {
-			delimiter: match[0],
-			stripTabs,
-			quoted: false
-		},
-		nextIndex: cursor + match[0].length
-	};
-}
-/** Consume every pending heredoc body; returns the offset just past the last
-*  terminator, or the end of the script when a terminator never arrives. */
-function consumeHeredocBodies(script, from, marks) {
-	let cursor = from;
-	for (const mark of marks) {
-		let closed = false;
-		while (cursor < script.length) {
-			const lineEnd = script.indexOf("\n", cursor);
-			const stop = lineEnd === -1 ? script.length : lineEnd;
-			const line = script.slice(cursor, stop);
-			const candidate = mark.stripTabs ? line.replace(/^\t+/, "") : line;
-			cursor = lineEnd === -1 ? script.length : lineEnd + 1;
-			if (candidate === mark.delimiter) {
-				closed = true;
-				break;
-			}
-		}
-		if (!closed) return script.length;
-	}
-	return cursor;
-}
-/** Payload shape of an action: `edit` when it authors file content through a
-*  heredoc, `shell` otherwise. */
-function classifyActionPayload(action) {
-	return scanShellAction(action).heredocs > 0 ? "edit" : "shell";
-}
-/**
-* Measure an action against the budget.
-*
-* The budget bounds what the scaffold can execute: one top-level statement,
-* one authored file, a byte cap, and neither a no-op nor a submit. Every
-* rejection here is one of those.
-*
-* `declaredKind` is what the analyst called its own action. It is recorded
-* beside the measured payload and never rejected on, because the scaffold runs
-* the action identically either way — so rejecting the label scores an arm on
-* how it described a repair rather than on the repair. A reader who wants the
-* mismatch counts `declared` against `payload`.
-*/
-function checkInterventionBudget(action, declaredKind, budget = SCAFFOLD_INTERVENTION_BUDGET) {
-	assertBudget(budget);
-	const scan = scanShellAction(action);
-	const payload = scan.heredocs > 0 ? "edit" : "shell";
-	const measurement = {
-		bytes: Buffer.byteLength(action, "utf8"),
-		statements: scan.statements.length,
-		heredocs: scan.heredocs,
-		payload,
-		declared: declaredKind
-	};
-	const reject = (violation, detail) => ({
-		admissible: false,
-		violation,
-		detail,
-		measurement
-	});
-	if (action.trim().length === 0) return reject("empty", "the intervention is empty");
-	if (measurement.bytes > budget.maxBytes) return reject("over-byte-cap", `${measurement.bytes} bytes exceeds the ${budget.maxBytes}-byte action budget`);
-	if (measurement.statements > budget.maxStatements) return reject("multiple-statements", `${measurement.statements} top-level statements exceeds the ${budget.maxStatements} the scaffold takes per action`);
-	if (measurement.heredocs > budget.maxHeredocs) return reject("multiple-heredocs", `${measurement.heredocs} heredocs exceeds the ${budget.maxHeredocs} one edit may author`);
-	if (action.includes(SUBMIT_SENTINEL)) return reject("submit-instead-of-repair", "the action submits the run instead of repairing it");
-	if (NO_OP_ACTIONS.includes(action.trim())) return reject("no-op-action", `"${action.trim()}" changes nothing`);
-	return {
-		admissible: true,
-		measurement
-	};
-}
-function assertBudget(budget) {
-	for (const field of [
-		"maxBytes",
-		"maxStatements",
-		"maxHeredocs"
-	]) {
-		const value = budget[field];
-		if (!Number.isInteger(value) || value <= 0) throw new ValidationError(`intervention budget ${field} must be a positive integer, got ${value}`);
-	}
-}
-/**
-* Whitespace-insensitive comparison used to reject an intervention that is
-* the recorded action again. Trailing whitespace and blank lines are the only
-* differences a re-proposal can carry without changing what runs.
-*/
-function normalizeActionForComparison(action) {
-	return action.split("\n").map((line) => line.trimEnd()).filter((line, index, lines) => line.length > 0 || index > 0 && index < lines.length - 1).join("\n").trim();
-}
-//#endregion
-//#region src/trace-repair/admission-records.ts
-/**
-* The vocabulary of the TB-Repair admission pre-pass: what a corpus row is,
-* which failure population it belongs to, why it can leave the funnel, and the
-* denominator chain those exclusions add up to.
-*
-* Pure data and pure functions. The gate that spends containers on these types
-* lives in `admission.ts`, and the artifact that publishes them lives in
-* `admission-report.ts`.
-*/
-/** A campaign scored rows the pre-pass did not admit, or dropped rows it did. */
-var AdmissionDenominatorError = class extends CaptureIntegrityError {};
-/** A row handed to the pre-pass carried a field only an analyst could produce. */
-var AdmissionIndependenceError = class extends CaptureIntegrityError {};
-const ADMISSION_ROW_KEYS = [
-	"rowId",
-	"taskName",
-	"recordedModel",
-	"recordedCommands",
-	"finalReturncode"
-];
-/**
-* Reject rows that carry anything beyond the recording.
-*
-* The check is a closed key list rather than a list of known analyst field
-* names, because the failure to catch is "some new analyst output leaked into
-* the gate", and only a closed shape catches the fields nobody thought of.
-*/
-function assertAnalystIndependent(rows) {
-	const allowed = new Set(ADMISSION_ROW_KEYS);
-	for (const row of rows) {
-		const extra = Object.keys(row).filter((key) => !allowed.has(key));
-		if (extra.length > 0) throw new AdmissionIndependenceError(`admission row ${String(row.rowId)} carries analyst-side fields: ${extra.sort().join(", ")}`);
-	}
-}
-const ADMISSION_STRATA = [
-	"clean-exit",
-	"command-error",
-	"signal-kill"
-];
-/** `null` when the recording holds no parseable final return code. */
-function stratumOf(finalReturncode) {
-	if (finalReturncode === null || !Number.isInteger(finalReturncode)) return null;
-	if (finalReturncode === 0) return "clean-exit";
-	return finalReturncode < 0 ? "signal-kill" : "command-error";
-}
-const ADMISSION_EXCLUSION_ORDER = [
-	"no-recorded-commands",
-	"unparseable-final-returncode",
-	"stratum-not-admitted",
-	"task-oracle-uncertified",
-	"task-oracle-nondeterministic",
-	"prefix-replay-error",
-	"prefix-replay-empty",
-	"prefix-replay-truncated",
-	"prefix-divergence-above-threshold",
-	"end-state-oracle-error",
-	"end-state-tests-pass",
-	"no-fix-control-error",
-	"no-fix-control-rescued",
-	"no-op-control-error",
-	"no-op-control-rescued"
-];
-/** Reasons decided from the recording alone, before a row can be stratified. */
-const PRE_STRATUM_REASONS = ["no-recorded-commands", "unparseable-final-returncode"];
-function isPreStratumReason(reason) {
-	return PRE_STRATUM_REASONS.includes(reason);
-}
-/** One line of prose per reason, for the rendered chain. */
-const ADMISSION_EXCLUSION_MEANING = Object.freeze({
-	"no-recorded-commands": "the recording holds no command to substitute",
-	"unparseable-final-returncode": "the last observation carries no return code",
-	"stratum-not-admitted": "the row belongs to a population this campaign excluded",
-	"task-oracle-uncertified": "the task grader has no determinism certification on file",
-	"task-oracle-nondeterministic": "the task grader returns different verdicts on byte-identical state",
-	"prefix-replay-error": "the replay boundary failed, so divergence is unmeasured",
-	"prefix-replay-empty": "the replay executed no recorded step",
-	"prefix-replay-truncated": "the replay stopped short of the recorded end state",
-	"prefix-divergence-above-threshold": "replaying the prefix did not reproduce the recording",
-	"end-state-oracle-error": "the task grader failed, so the end state is unjudged",
-	"end-state-tests-pass": "the task tests pass on the recorded end state, so nothing failed",
-	"no-fix-control-error": "a no-fix rollout failed to run, so the control is unmeasured",
-	"no-fix-control-rescued": "the continuation policy passes the task with no intervention",
-	"no-op-control-error": "a no-op rollout failed to run, so the control is unmeasured",
-	"no-op-control-rescued": "an inert action plus continuation passes the task"
-});
-/**
-* Build the funnel every campaign report publishes.
-*
-* Each stage names the reason, the rows that reached it, the rows it removed,
-* and the rows that survived, so `input = admitted + sum(excluded)` can be read
-* off the table instead of trusted.
-*/
-function buildDenominatorChain(verdicts, admitStrata) {
-	const reasonTotals = emptyReasonTotals();
-	for (const verdict of verdicts) if (verdict.excludedBy !== null) reasonTotals[verdict.excludedBy] += 1;
-	const stratumReasons = ADMISSION_EXCLUSION_ORDER.filter((reason) => !isPreStratumReason(reason));
-	const artifact = {
-		version: 1,
-		overall: chainOf("all", verdicts, ADMISSION_EXCLUSION_ORDER),
-		byStratum: ADMISSION_STRATA.filter((stratum) => verdicts.some((verdict) => verdict.stratum === stratum)).map((stratum) => chainOf(stratum, verdicts.filter((verdict) => verdict.stratum === stratum), stratumReasons)),
-		reasonTotals,
-		unstratified: verdicts.filter((verdict) => verdict.stratum === null).length,
-		admitStrata: [...admitStrata]
-	};
-	assertChainReconciles(artifact);
-	return artifact;
-}
-function chainOf(scope, verdicts, reasons) {
-	let remaining = verdicts.length;
-	const stages = [];
-	for (const reason of reasons) {
-		const excluded = verdicts.filter((verdict) => verdict.excludedBy === reason).length;
-		const entering = remaining;
-		remaining -= excluded;
-		stages.push({
-			reason,
-			entering,
-			excluded,
-			remaining
-		});
-	}
-	return {
-		scope,
-		input: verdicts.length,
-		stages,
-		admitted: verdicts.filter((verdict) => verdict.admitted).length
-	};
-}
-function emptyReasonTotals() {
-	const totals = {};
-	for (const reason of ADMISSION_EXCLUSION_ORDER) totals[reason] = 0;
-	return totals;
-}
-/** A chain that does not add up is a broken denominator, so this throws. */
-function assertChainReconciles(artifact) {
-	for (const chain of [artifact.overall, ...artifact.byStratum]) {
-		const excluded = chain.stages.reduce((total, stage) => total + stage.excluded, 0);
-		if (chain.input !== chain.admitted + excluded) throw new AdmissionDenominatorError(`denominator chain (${chain.scope}) does not reconcile: input ${chain.input} != admitted ${chain.admitted} + excluded ${excluded}`);
-		const last = chain.stages[chain.stages.length - 1];
-		if (last && last.remaining !== chain.admitted) throw new AdmissionDenominatorError(`denominator chain (${chain.scope}) ends at ${last.remaining} rows but reports ${chain.admitted} admitted`);
-	}
-	const stratumInputs = artifact.byStratum.reduce((total, chain) => total + chain.input, 0);
-	if (stratumInputs + artifact.unstratified !== artifact.overall.input) throw new AdmissionDenominatorError(`stratum inputs ${stratumInputs} plus ${artifact.unstratified} unstratified do not cover ${artifact.overall.input} input rows`);
-}
-//#endregion
-//#region src/trace-repair/continuation-policy.ts
-/** A rollout ran outside the pinned policy, so its evidence cannot be used. */
-var ContinuationPolicyViolationError = class extends CaptureIntegrityError {};
-/** Two arms did not run the same policy, so their difference is not the intervention. */
-var ContinuationSymmetryError = class extends CaptureIntegrityError {};
-/**
-* Everything the policy fixes except the two a campaign must choose.
-*
-* `commandTimeoutSeconds` is 30 because the recorded runs used the scaffold's
-* own 30-second environment timeout; a longer limit would let the continuation
-* finish commands the recorded agent could not.
-*/
-const CONTINUATION_POLICY_DEFAULTS = {
-	id: "tb-repair-continuation-v1",
-	stepBudget: 20,
-	temperature: 0,
-	maxTokens: 4096,
-	commandTimeoutSeconds: 30,
-	maxConsecutiveFormatErrors: 3,
-	networkMode: "none",
-	scaffold: "mini-swe-agent"
-};
-function definePinnedContinuationPolicy(input) {
-	const policy = {
-		...CONTINUATION_POLICY_DEFAULTS,
-		...input
-	};
-	if (!policy.model.trim()) throw new ValidationError("continuation policy requires a model id");
-	if (!Number.isInteger(policy.seed)) throw new ValidationError(`continuation policy seed must be an integer, got ${policy.seed}`);
-	requirePositiveInteger$1(policy.stepBudget, "stepBudget");
-	requirePositiveInteger$1(policy.maxTokens, "maxTokens");
-	requirePositiveInteger$1(policy.commandTimeoutSeconds, "commandTimeoutSeconds");
-	requirePositiveInteger$1(policy.maxConsecutiveFormatErrors, "maxConsecutiveFormatErrors");
-	if (!Number.isFinite(policy.temperature) || policy.temperature < 0) throw new ValidationError(`continuation policy temperature must be a non-negative number, got ${policy.temperature}`);
-	return Object.freeze(policy);
-}
-function requirePositiveInteger$1(value, field) {
-	if (!Number.isInteger(value) || value <= 0) throw new ValidationError(`continuation policy ${field} must be a positive integer, got ${value}`);
-}
-/**
-* Hash over the policy and the scaffold text it renders. A changed template
-* changes the digest, so rollouts recorded before and after an edit cannot be
-* pooled by accident.
-*/
-function continuationPolicyDigest(policy) {
-	return contentHash({
-		policy: { ...policy },
-		systemMessage: MINI_SWE_SYSTEM_MESSAGE,
-		instanceMessage: renderInstanceMessage({
-			task: "<task>",
-			systemInformation: "<system>"
-		}),
-		formatErrorObservation: renderFormatErrorObservation(0),
-		timeoutObservation: renderTimeoutObservation("<command>", "<output>"),
-		observation: renderObservation({
-			returncode: 0,
-			output: ""
-		})
-	});
-}
-/**
-* Per-rollout seed. It reads the policy seed, the row, and the rollout index —
-* deliberately not the arm, so paired rollouts across arms draw identically.
+* Per-rollout seed. It reads the policy seed, the row, and the rollout index —
+* deliberately not the arm, so paired rollouts across arms draw identically.
 */
 function continuationSeed(policySeed, rowId, rolloutIndex) {
 	const input = `${policySeed}:${rowId}:${rolloutIndex}`;
@@ -983,9 +617,6 @@ async function runOneRollout(input) {
 		await environment.dispose();
 	}
 }
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 /**
 * Sum only what the provider reported. A call with no usage raises
 * `callsWithUsage` short of `calls` and clears `captured`, so a partially
@@ -1451,333 +1082,688 @@ function summarizeControlCost(verdicts) {
 		usd
 	};
 }
-function groupAdmittedByStratum(verdicts) {
-	const grouped = {
-		"clean-exit": [],
-		"command-error": [],
-		"signal-kill": []
-	};
-	for (const verdict of verdicts) {
-		if (!verdict.admitted || verdict.stratum === null) continue;
-		grouped[verdict.stratum].push(verdict.rowId);
-	}
-	return Object.freeze({
-		"clean-exit": Object.freeze(grouped["clean-exit"]),
-		"command-error": Object.freeze(grouped["command-error"]),
-		"signal-kill": Object.freeze(grouped["signal-kill"])
-	});
+function groupAdmittedByStratum(verdicts) {
+	const grouped = {
+		"clean-exit": [],
+		"command-error": [],
+		"signal-kill": []
+	};
+	for (const verdict of verdicts) {
+		if (!verdict.admitted || verdict.stratum === null) continue;
+		grouped[verdict.stratum].push(verdict.rowId);
+	}
+	return Object.freeze({
+		"clean-exit": Object.freeze(grouped["clean-exit"]),
+		"command-error": Object.freeze(grouped["command-error"]),
+		"signal-kill": Object.freeze(grouped["signal-kill"])
+	});
+}
+/** Bounded worker pool that keeps results in input order. */
+async function mapOrdered(items, concurrency, fn) {
+	const results = new Array(items.length);
+	let next = 0;
+	const workerCount = Math.max(1, Math.min(concurrency, items.length));
+	const workers = Array.from({ length: workerCount }, async () => {
+		for (;;) {
+			const index = next;
+			next += 1;
+			if (index >= items.length) return;
+			const item = items[index];
+			if (item === void 0) return;
+			results[index] = await fn(item);
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+/**
+* Prove a campaign measured the denominator admission published.
+*
+* Three ways a denominator moves after the fact, each rejected here: scoring a
+* row that was never admitted, scoring a row that was never sampled, and
+* dropping a sampled row instead of scoring it. The third is the one an analyst
+* can cause on its own — declining a row it cannot solve — so a sampled row
+* with no outcome is an error, not a smaller `n`.
+*/
+function assertDenominatorIntact(input) {
+	const { report, strata, sampled, scored } = input;
+	for (const stratum of strata) if (!ADMISSION_STRATA.includes(stratum)) throw new ValidationError(`unknown stratum in denominator check: ${stratum}`);
+	assertNoDuplicates(sampled, "sampled");
+	assertNoDuplicates(scored, "scored");
+	const eligible = new Set(strata.flatMap((stratum) => [...report.strata[stratum]]));
+	const notAdmitted = sampled.filter((rowId) => !eligible.has(rowId));
+	if (notAdmitted.length > 0) throw new AdmissionDenominatorError(`${notAdmitted.length} sampled row(s) are not admitted in strata ${strata.join(", ")}: ${preview(notAdmitted)}`);
+	const sampledSet = new Set(sampled);
+	const unsampled = scored.filter((rowId) => !sampledSet.has(rowId));
+	if (unsampled.length > 0) throw new AdmissionDenominatorError(`${unsampled.length} scored row(s) were never sampled: ${preview(unsampled)}`);
+	const scoredSet = new Set(scored);
+	const dropped = sampled.filter((rowId) => !scoredSet.has(rowId));
+	if (dropped.length > 0) throw new AdmissionDenominatorError(`denominator shrank by ${dropped.length} row(s): sampled but never scored: ${preview(dropped)}`);
+}
+/** A row counted twice raises `n` without measuring anything twice. */
+function assertNoDuplicates(rowIds, field) {
+	const seen = /* @__PURE__ */ new Set();
+	const duplicates = rowIds.filter((rowId) => {
+		if (seen.has(rowId)) return true;
+		seen.add(rowId);
+		return false;
+	});
+	if (duplicates.length > 0) throw new AdmissionDenominatorError(`${field} lists ${duplicates.length} duplicate row id(s): ${preview([...new Set(duplicates)])}`);
+}
+function preview(rowIds) {
+	const shown = rowIds.slice(0, 5).join(", ");
+	return rowIds.length > 5 ? `${shown}, +${rowIds.length - 5} more` : shown;
+}
+//#endregion
+//#region src/trace-repair/admission-contract.ts
+/**
+* Admission: the executed checks a row must pass before an analyst is allowed
+* to see it, and the brand that proves it did.
+*
+* Every check is analyst-independent. None of them reads a finding, a label,
+* or a k, and all of them are anchored at the recorded end state — the point
+* the agent actually stopped at — so the same evidence admits a row no matter
+* which step an analyst later blames:
+*
+*   oracle-determinism the task's own suite returns one verdict on identical
+*                      bytes, so its answer is about the state
+*   prefix-fidelity    the recorded trajectory replays with at most 10 % of
+*                      its steps diverging from their recorded returncode
+*   end-state-fails    the held-out suite fails on the recorded end state
+*   no-fix-control     3 of 3 continuations from the end state fail
+*   no-op-control      3 of 3 continuations from the end state, after an
+*                      action that changes nothing, fail
+*
+* The two controls are what make `Delta-repair` a difference rather than a
+* rate, and what stops a row where the agent was one free step from success
+* from counting as a repair the analyst caused. They only do that under a
+* control that can act: `control-policy.ts` holds the declaration, and the
+* criteria name which reading of a control pass applies.
+*
+* The determinism check sits in front of all of it. Every downstream check
+* reads the same suite, so a suite whose verdict is not a function of the state
+* makes each of them a coin flip rather than a measurement.
+*
+* This module owns the CONTRACT, not the execution. `runAdmission` in
+* `./admission` executes the checks against real containers and hands the
+* measured evidence to `admitRow`, which decides and brands. Splitting it that
+* way keeps the decision auditable from the recorded numbers alone: a reviewer
+* can re-derive every admission from the evidence file without re-running a
+* container.
+*/
+const TB_REPAIR_ADMISSION_CRITERIA = Object.freeze({
+	maxPrefixDivergenceRatio: .1,
+	controlRollouts: 3,
+	controlScreening: "enforced"
+});
+/**
+* Decide admission from executed evidence.
+*
+* Pure: it opens no container and calls no model. Every threshold it applies
+* is in `criteria`, and every number it reads is in `evidence`, so an
+* admission decision is reproducible from the recorded evidence alone.
+*
+* It throws, rather than rejecting, when the criteria and the declared control
+* contradict. A contradiction there is a property of the configuration and not
+* of the row, so it must stop the run instead of producing one verdict per row
+* that reads as if a check had been applied.
+*/
+function admitRow(evidence, criteria = TB_REPAIR_ADMISSION_CRITERIA) {
+	assertCriteria(criteria);
+	assertControlCalibrated(evidence.controlPolicy, criteria.controlScreening);
+	if (evidence.oracleDeterminism.taskName !== evidence.taskName) throw new ValidationError(`row ${evidence.rowId} is from task ${evidence.taskName} but carries the oracle certification for ${evidence.oracleDeterminism.taskName}`);
+	const screening = {
+		controlPolicy: evidence.controlPolicy,
+		controlScreening: criteria.controlScreening,
+		controlPolicyDigest: evidence.controlPolicy.digest,
+		taskName: evidence.oracleDeterminism.taskName,
+		oracleStable: evidence.oracleDeterminism.stable,
+		oracleFlipRate: evidence.oracleDeterminism.flipRate
+	};
+	const reject = (rejection, detail) => ({
+		admitted: false,
+		rowId: evidence.rowId,
+		screening,
+		rejection,
+		detail
+	});
+	const oracle = evidence.oracleDeterminism;
+	if (!oracle.stable) return reject("task-oracle-nondeterministic", `task ${oracle.taskName} graded byte-identical state inconsistently: flip rate ${(oracle.flipRate * 100).toFixed(1)} % over ${oracle.replicates} replicates (${oracle.detail}). Every check below reads that suite, so none of them measures state.`);
+	if (evidence.steps.length === 0) return reject("empty-trajectory", "the row records no steps");
+	const { stepsReplayed, divergences } = evidence.prefixFidelity;
+	if (stepsReplayed <= 0) return reject("empty-trajectory", "no recorded step was replayed");
+	const prefixDivergenceRatio = divergences / stepsReplayed;
+	if (prefixDivergenceRatio > criteria.maxPrefixDivergenceRatio) return reject("prefix-divergence-too-high", `${divergences}/${stepsReplayed} replayed steps diverged (${(prefixDivergenceRatio * 100).toFixed(1)} %), above the ${(criteria.maxPrefixDivergenceRatio * 100).toFixed(1)} % ceiling`);
+	if (evidence.endStatePassed) return reject("end-state-already-passes", "the held-out suite passes on the recorded end state, so the row records no failure to repair");
+	for (const [name, arm, rescued] of [[
+		"no-fix control",
+		evidence.noFixControl,
+		"no-fix-control-passed"
+	], [
+		"no-op control",
+		evidence.noOpControl,
+		"no-op-control-passed"
+	]]) {
+		if (arm.rollouts !== criteria.controlRollouts) return reject("control-rollouts-short", `${name} ran ${arm.rollouts} rollouts, the criteria pre-register ${criteria.controlRollouts}`);
+		if (arm.policyDigest !== evidence.controlPolicy.digest) return reject("control-policy-mismatch", `${name} reported policy ${arm.policyDigest} but the criteria screen under ${evidence.controlPolicy.id} (${evidence.controlPolicy.digest}); the arm did not run the declared control`);
+		if (arm.passes !== 0) return criteria.controlScreening === "enforced" ? reject(rescued, `${name} passed ${arm.passes}/${arm.rollouts}; the row is repairable by continuing alone`) : reject("control-passed-on-identical-state", `${name} passed ${arm.passes}/${arm.rollouts} under ${evidence.controlPolicy.id}, which executes no command, so it graded the same bytes the end-state check graded as failing. The task's certification reports flip rate ${(oracle.flipRate * 100).toFixed(1)} %; this row is a further flip, not a rescue.`);
+	}
+	return {
+		admitted: true,
+		screening,
+		row: {
+			rowId: evidence.rowId,
+			taskName: evidence.taskName,
+			image: evidence.image,
+			cwd: evidence.cwd,
+			taskStatement: evidence.taskStatement,
+			steps: evidence.steps,
+			criteria,
+			prefixDivergenceRatio,
+			suiteDigest: evidence.suiteDigest,
+			controlPolicy: evidence.controlPolicy,
+			controlScreening: criteria.controlScreening,
+			policyDigest: evidence.controlPolicy.digest,
+			controlRate: evidence.noFixControl.passes / evidence.noFixControl.rollouts,
+			controlRollouts: evidence.noFixControl.rollouts
+		}
+	};
+}
+function assertCriteria(criteria) {
+	const { maxPrefixDivergenceRatio, controlRollouts } = criteria;
+	if (!(maxPrefixDivergenceRatio >= 0 && maxPrefixDivergenceRatio <= 1)) throw new ValidationError(`admission maxPrefixDivergenceRatio must be within [0,1], got ${maxPrefixDivergenceRatio}`);
+	if (!Number.isInteger(controlRollouts) || controlRollouts <= 0) throw new ValidationError(`admission controlRollouts must be a positive integer, got ${controlRollouts}`);
+}
+//#endregion
+//#region src/trace-repair/admission-report.ts
+/** Plain JSON. `JSON.stringify` of this object is the machine-readable artifact. */
+function admissionArtifact(report) {
+	assertChainReconciles(report.chain);
+	return {
+		version: 1,
+		kind: "tb-repair-admission",
+		generatedAt: report.generatedAt,
+		digest: report.digest,
+		config: report.config,
+		provenance: report.provenance,
+		chain: report.chain,
+		admitted: {
+			"clean-exit": report.strata["clean-exit"],
+			"command-error": report.strata["command-error"],
+			"signal-kill": report.strata["signal-kill"]
+		},
+		controlCost: {
+			kind: report.controlCost.kind,
+			usd: report.controlCost.usd
+		},
+		rows: report.rows
+	};
+}
+/** Markdown for the campaign report. Every number here is also in the artifact. */
+function renderAdmissionReport(artifact, options = {}) {
+	const lines = [];
+	lines.push("# TB-Repair admission", "");
+	lines.push(`${artifact.chain.overall.admitted} of ${artifact.chain.overall.input} rows admitted. Digest \`${artifact.digest}\`.`, "");
+	lines.push(...provenanceSection(artifact));
+	lines.push(...chainSection(artifact.chain.overall, "Denominator chain"));
+	for (const chain of artifact.chain.byStratum) lines.push(...chainSection(chain, `Denominator chain — ${chain.scope}`));
+	lines.push(...stratumSection(artifact));
+	lines.push(...reasonSection(artifact.chain.reasonTotals));
+	const rowLimit = options.rowLimit ?? 0;
+	if (rowLimit > 0) lines.push(...rowSection(artifact.rows, rowLimit));
+	return `${lines.join("\n").trimEnd()}\n`;
 }
-/** Bounded worker pool that keeps results in input order. */
-async function mapOrdered(items, concurrency, fn) {
-	const results = new Array(items.length);
-	let next = 0;
-	const workerCount = Math.max(1, Math.min(concurrency, items.length));
-	const workers = Array.from({ length: workerCount }, async () => {
-		for (;;) {
-			const index = next;
-			next += 1;
-			if (index >= items.length) return;
-			const item = items[index];
-			if (item === void 0) return;
-			results[index] = await fn(item);
-		}
+function provenanceSection(artifact) {
+	const { provenance, config, controlCost } = artifact;
+	const cost = controlCost.usd === null ? "uncaptured" : `$${controlCost.usd.toFixed(4)}`;
+	return [
+		"## Provenance",
+		"",
+		"| field | value |",
+		"| --- | --- |",
+		`| generated | ${artifact.generatedAt} |`,
+		`| prefix replayer | \`${provenance.replayerId}\` |`,
+		`| end-state oracle | \`${provenance.oracleId}\` |`,
+		`| control runner | \`${provenance.controlRunnerId}\` |`,
+		`| continuation policy | \`${provenance.policyId}\` |`,
+		`| policy model | \`${provenance.policyModel}\` |`,
+		`| policy seed | ${provenance.policySeed} |`,
+		`| policy digest | \`${provenance.policyDigest}\` |`,
+		`| policy step budget | ${provenance.policyStepBudget} model call(s) per control rollout |`,
+		`| control screening | \`${provenance.controlScreening}\` |`,
+		`| certified task oracles | ${formatCertifiedTasks(provenance.certifiedTasks)} |`,
+		`| max prefix divergence | ${formatShare(config.maxPrefixDivergence)} |`,
+		`| control rollouts per arm | ${config.controlRollouts} |`,
+		`| inert action | \`${config.inertAction}\` |`,
+		`| strata admitted | ${config.admitStrata.join(", ")} |`,
+		`| control model cost | ${cost} (${controlCost.kind}) |`,
+		""
+	];
+}
+function formatCertifiedTasks(certified) {
+	const entries = Object.entries(certified).sort(([a], [b]) => a.localeCompare(b));
+	if (entries.length === 0) return "none";
+	return entries.map(([task, flipRate]) => `${task} (flip ${formatShare(flipRate)})`).join(", ");
+}
+function chainSection(chain, heading) {
+	const lines = [
+		`## ${heading}`,
+		"",
+		"| stage | exclusion reason | entering | excluded | remaining |",
+		"| --- | --- | --- | --- | --- |"
+	];
+	chain.stages.forEach((stage, index) => {
+		lines.push(`| ${index + 1} | \`${stage.reason}\` | ${stage.entering} | ${stage.excluded} | ${stage.remaining} |`);
 	});
-	await Promise.all(workers);
-	return results;
+	const excluded = chain.input - chain.admitted;
+	lines.push("", `Input ${chain.input} = admitted ${chain.admitted} + excluded ${excluded}. Admission rate ${formatShare(rate(chain.admitted, chain.input))}.`, "");
+	return lines;
 }
-/** Admitted row ids in one stratum. No call returns them pooled. */
-function admittedRowIds(report, stratum) {
-	return report.strata[stratum];
+function stratumSection(artifact) {
+	const lines = [
+		"## Strata",
+		"",
+		"| stratum | admitted rows | in this campaign |",
+		"| --- | --- | --- |"
+	];
+	for (const stratum of ADMISSION_STRATA) {
+		const admitted = artifact.admitted[stratum].length;
+		const eligible = artifact.chain.admitStrata.includes(stratum) ? "yes" : "no";
+		lines.push(`| ${stratum} | ${admitted} | ${eligible} |`);
+	}
+	lines.push("", "Sample within a stratum. A command-level repair cannot address a signal kill, so pooling that population with the others averages an addressable class with an unaddressable one.", "");
+	return lines;
 }
-function admittedCount(report) {
-	return ADMISSION_STRATA.reduce((total, stratum) => total + report.strata[stratum].length, 0);
+function reasonSection(totals) {
+	const lines = [
+		"## Exclusions",
+		"",
+		"| reason | rows | what it means |",
+		"| --- | --- | --- |"
+	];
+	for (const reason of ADMISSION_EXCLUSION_ORDER) lines.push(`| \`${reason}\` | ${totals[reason]} | ${ADMISSION_EXCLUSION_MEANING[reason]} |`);
+	lines.push("");
+	return lines;
 }
-/**
-* Prove a campaign measured the denominator admission published.
-*
-* Three ways a denominator moves after the fact, each rejected here: scoring a
-* row that was never admitted, scoring a row that was never sampled, and
-* dropping a sampled row instead of scoring it. The third is the one an analyst
-* can cause on its own — declining a row it cannot solve — so a sampled row
-* with no outcome is an error, not a smaller `n`.
-*/
-function assertDenominatorIntact(input) {
-	const { report, strata, sampled, scored } = input;
-	for (const stratum of strata) if (!ADMISSION_STRATA.includes(stratum)) throw new ValidationError(`unknown stratum in denominator check: ${stratum}`);
-	assertNoDuplicates(sampled, "sampled");
-	assertNoDuplicates(scored, "scored");
-	const eligible = new Set(strata.flatMap((stratum) => [...report.strata[stratum]]));
-	const notAdmitted = sampled.filter((rowId) => !eligible.has(rowId));
-	if (notAdmitted.length > 0) throw new AdmissionDenominatorError(`${notAdmitted.length} sampled row(s) are not admitted in strata ${strata.join(", ")}: ${preview(notAdmitted)}`);
-	const sampledSet = new Set(sampled);
-	const unsampled = scored.filter((rowId) => !sampledSet.has(rowId));
-	if (unsampled.length > 0) throw new AdmissionDenominatorError(`${unsampled.length} scored row(s) were never sampled: ${preview(unsampled)}`);
-	const scoredSet = new Set(scored);
-	const dropped = sampled.filter((rowId) => !scoredSet.has(rowId));
-	if (dropped.length > 0) throw new AdmissionDenominatorError(`denominator shrank by ${dropped.length} row(s): sampled but never scored: ${preview(dropped)}`);
+function rowSection(rows, limit) {
+	const lines = [
+		"## Rows",
+		"",
+		"| row | task | stratum | final rc | admitted | excluded by |",
+		"| --- | --- | --- | --- | --- | --- |"
+	];
+	for (const row of rows.slice(0, limit)) lines.push(`| \`${row.rowId}\` | ${row.taskName} | ${row.stratum ?? "—"} | ${row.finalReturncode ?? "—"} | ${row.admitted ? "yes" : "no"} | ${row.excludedBy === null ? "—" : `\`${row.excludedBy}\``} |`);
+	if (rows.length > limit) lines.push("", `${rows.length - limit} further rows in the artifact.`);
+	lines.push("");
+	return lines;
 }
-/** A row counted twice raises `n` without measuring anything twice. */
-function assertNoDuplicates(rowIds, field) {
-	const seen = /* @__PURE__ */ new Set();
-	const duplicates = rowIds.filter((rowId) => {
-		if (seen.has(rowId)) return true;
-		seen.add(rowId);
-		return false;
-	});
-	if (duplicates.length > 0) throw new AdmissionDenominatorError(`${field} lists ${duplicates.length} duplicate row id(s): ${preview([...new Set(duplicates)])}`);
+function rate(part, total) {
+	return total === 0 ? 0 : part / total;
 }
-function preview(rowIds) {
-	const shown = rowIds.slice(0, 5).join(", ");
-	return rowIds.length > 5 ? `${shown}, +${rowIds.length - 5} more` : shown;
+function formatShare(share) {
+	return `${(share * 100).toFixed(2)}%`;
 }
 //#endregion
-//#region src/trace-repair/admission-contract.ts
+//#region src/trace-repair/action-budget.ts
 /**
-* Admission: the executed checks a row must pass before an analyst is allowed
-* to see it, and the brand that proves it did.
-*
-* Every check is analyst-independent. None of them reads a finding, a label,
-* or a k, and all of them are anchored at the recorded end state — the point
-* the agent actually stopped at — so the same evidence admits a row no matter
-* which step an analyst later blames:
-*
-*   oracle-determinism the task's own suite returns one verdict on identical
-*                      bytes, so its answer is about the state
-*   prefix-fidelity    the recorded trajectory replays with at most 10 % of
-*                      its steps diverging from their recorded returncode
-*   end-state-fails    the held-out suite fails on the recorded end state
-*   no-fix-control     3 of 3 continuations from the end state fail
-*   no-op-control      3 of 3 continuations from the end state, after an
-*                      action that changes nothing, fail
-*
-* The two controls are what make `Delta-repair` a difference rather than a
-* rate, and what stops a row where the agent was one free step from success
-* from counting as a repair the analyst caused. They only do that under a
-* control that can act: `control-policy.ts` holds the declaration, and the
-* criteria name which reading of a control pass applies.
+* The action budget an intervention must fit inside.
 *
-* The determinism check sits in front of all of it. Every downstream check
-* reads the same suite, so a suite whose verdict is not a function of the state
-* makes each of them a coin flip rather than a measurement.
+* The analyst answers with one action, applied at step k, drawn from the same
+* action space the scaffold had: one shell command or one edit, at most 4 KB.
+* An answer that buys a bigger action than the scaffold could take is not a
+* counterfactual about the recorded run, so the budget is enforced before any
+* container is opened and a violation never reaches the reproduction gate.
 *
-* This module owns the CONTRACT, not the execution. `runAdmission` in
-* `./admission` executes the checks against real containers and hands the
-* measured evidence to `admitRow`, which decides and brands. Splitting it that
-* way keeps the decision auditable from the recorded numbers alone: a reviewer
-* can re-derive every admission from the evidence file without re-running a
-* container.
+* "One action" is decided by counting top-level statements, not lines. A
+* command list joined by `&&`, `||` or a pipe is one statement, because that
+* is one thing the shell runs and one thing the scaffold could have typed.
+* Two statements separated by a newline or `;` are two actions and are
+* rejected. Heredoc bodies, comments and compound blocks (`if`, `for`,
+* `while`, `until`, `case`, `{ … }`) are inside a statement, never separators.
 */
-const TB_REPAIR_ADMISSION_CRITERIA = Object.freeze({
-	maxPrefixDivergenceRatio: .1,
-	controlRollouts: 3,
-	controlScreening: "enforced"
+/** The scaffold's own per-action budget, pre-registered for the campaign. */
+const SCAFFOLD_INTERVENTION_BUDGET = Object.freeze({
+	maxBytes: 4096,
+	maxStatements: 1,
+	maxHeredocs: 1
 });
 /**
-* Decide admission from executed evidence.
-*
-* Pure: it opens no container and calls no model. Every threshold it applies
-* is in `criteria`, and every number it reads is in `evidence`, so an
-* admission decision is reproducible from the recorded evidence alone.
+* Actions whose only effect is to consume a turn. They are rejected before a
+* container opens: an intervention that changes nothing is measurably
+* identical to the no-op control, and paying rollouts to rediscover that
+* wastes the corpus.
+*/
+const NO_OP_ACTIONS = Object.freeze([
+	":",
+	"true",
+	"/bin/true",
+	"exit",
+	"exit 0"
+]);
+const BLOCK_OPENERS = /* @__PURE__ */ new Set([
+	"if",
+	"for",
+	"while",
+	"until",
+	"case",
+	"select",
+	"do",
+	"then"
+]);
+const BLOCK_CLOSERS = /* @__PURE__ */ new Set([
+	"fi",
+	"done",
+	"esac"
+]);
+/**
+* Split a shell script into top-level statements and count its heredocs.
 *
-* It throws, rather than rejecting, when the criteria and the declared control
-* contradict. A contradiction there is a property of the configuration and not
-* of the row, so it must stop the run instead of producing one verdict per row
-* that reads as if a check had been applied.
+* The scan tracks quoting, escapes, command substitution, brace and paren
+* grouping, comments, compound-block keywords, and heredoc bodies. Anything
+* it cannot resolve stays inside the current statement, so an unparseable
+* action reads as one oversized statement and is rejected on bytes rather
+* than silently accepted as one clean action.
 */
-function admitRow(evidence, criteria = TB_REPAIR_ADMISSION_CRITERIA) {
-	assertCriteria(criteria);
-	assertControlCalibrated(evidence.controlPolicy, criteria.controlScreening);
-	if (evidence.oracleDeterminism.taskName !== evidence.taskName) throw new ValidationError(`row ${evidence.rowId} is from task ${evidence.taskName} but carries the oracle certification for ${evidence.oracleDeterminism.taskName}`);
-	const screening = {
-		controlPolicy: evidence.controlPolicy,
-		controlScreening: criteria.controlScreening,
-		controlPolicyDigest: evidence.controlPolicy.digest,
-		taskName: evidence.oracleDeterminism.taskName,
-		oracleStable: evidence.oracleDeterminism.stable,
-		oracleFlipRate: evidence.oracleDeterminism.flipRate
+function scanShellAction(script) {
+	const state = {
+		statements: [],
+		current: "",
+		heredocs: 0
 	};
-	const reject = (rejection, detail) => ({
-		admitted: false,
-		rowId: evidence.rowId,
-		screening,
-		rejection,
-		detail
-	});
-	const oracle = evidence.oracleDeterminism;
-	if (!oracle.stable) return reject("task-oracle-nondeterministic", `task ${oracle.taskName} graded byte-identical state inconsistently: flip rate ${(oracle.flipRate * 100).toFixed(1)} % over ${oracle.replicates} replicates (${oracle.detail}). Every check below reads that suite, so none of them measures state.`);
-	if (evidence.steps.length === 0) return reject("empty-trajectory", "the row records no steps");
-	const { stepsReplayed, divergences } = evidence.prefixFidelity;
-	if (stepsReplayed <= 0) return reject("empty-trajectory", "no recorded step was replayed");
-	const prefixDivergenceRatio = divergences / stepsReplayed;
-	if (prefixDivergenceRatio > criteria.maxPrefixDivergenceRatio) return reject("prefix-divergence-too-high", `${divergences}/${stepsReplayed} replayed steps diverged (${(prefixDivergenceRatio * 100).toFixed(1)} %), above the ${(criteria.maxPrefixDivergenceRatio * 100).toFixed(1)} % ceiling`);
-	if (evidence.endStatePassed) return reject("end-state-already-passes", "the held-out suite passes on the recorded end state, so the row records no failure to repair");
-	for (const [name, arm, rescued] of [[
-		"no-fix control",
-		evidence.noFixControl,
-		"no-fix-control-passed"
-	], [
-		"no-op control",
-		evidence.noOpControl,
-		"no-op-control-passed"
-	]]) {
-		if (arm.rollouts !== criteria.controlRollouts) return reject("control-rollouts-short", `${name} ran ${arm.rollouts} rollouts, the criteria pre-register ${criteria.controlRollouts}`);
-		if (arm.policyDigest !== evidence.controlPolicy.digest) return reject("control-policy-mismatch", `${name} reported policy ${arm.policyDigest} but the criteria screen under ${evidence.controlPolicy.id} (${evidence.controlPolicy.digest}); the arm did not run the declared control`);
-		if (arm.passes !== 0) return criteria.controlScreening === "enforced" ? reject(rescued, `${name} passed ${arm.passes}/${arm.rollouts}; the row is repairable by continuing alone`) : reject("control-passed-on-identical-state", `${name} passed ${arm.passes}/${arm.rollouts} under ${evidence.controlPolicy.id}, which executes no command, so it graded the same bytes the end-state check graded as failing. The task's certification reports flip rate ${(oracle.flipRate * 100).toFixed(1)} %; this row is a further flip, not a rescue.`);
+	let index = 0;
+	let parenDepth = 0;
+	let braceDepth = 0;
+	let blockDepth = 0;
+	let inSingle = false;
+	let inDouble = false;
+	let inBacktick = false;
+	let pendingHeredocs = [];
+	let word = "";
+	let atStatementStart = true;
+	const flushWord = () => {
+		if (word.length === 0) return;
+		if (BLOCK_OPENERS.has(word)) blockDepth += 1;
+		else if (BLOCK_CLOSERS.has(word)) blockDepth = Math.max(0, blockDepth - 1);
+		word = "";
+	};
+	const endStatement = () => {
+		flushWord();
+		const text = state.current.trim();
+		if (text.length > 0 && !isCommentOnly(text)) state.statements.push(text);
+		state.current = "";
+		atStatementStart = true;
+	};
+	while (index < script.length) {
+		const char = script[index];
+		if (inSingle) {
+			state.current += char;
+			if (char === "'") inSingle = false;
+			index += 1;
+			continue;
+		}
+		if (char === "\\" && index + 1 < script.length) {
+			const next = script[index + 1];
+			if (next === "\n" && !inDouble) {
+				state.current += char + next;
+				index += 2;
+				continue;
+			}
+			state.current += char + next;
+			index += 2;
+			continue;
+		}
+		if (inDouble) {
+			state.current += char;
+			if (char === "\"") inDouble = false;
+			index += 1;
+			continue;
+		}
+		if (char === "'") {
+			flushWord();
+			inSingle = true;
+			state.current += char;
+			index += 1;
+			atStatementStart = false;
+			continue;
+		}
+		if (char === "\"") {
+			flushWord();
+			inDouble = true;
+			state.current += char;
+			index += 1;
+			atStatementStart = false;
+			continue;
+		}
+		if (char === "`") {
+			inBacktick = !inBacktick;
+			state.current += char;
+			index += 1;
+			atStatementStart = false;
+			continue;
+		}
+		if (char === "#" && (atStatementStart || /\s/.test(script[index - 1] ?? " "))) {
+			const end = script.indexOf("\n", index);
+			const stop = end === -1 ? script.length : end;
+			state.current += script.slice(index, stop);
+			index = stop;
+			continue;
+		}
+		if (char === "<" && script[index + 1] === "<" && script[index + 2] !== "<" && script[index - 1] !== "<") {
+			const mark = readHeredocMark(script, index);
+			if (mark) {
+				pendingHeredocs.push(mark.mark);
+				state.heredocs += 1;
+				state.current += script.slice(index, mark.nextIndex);
+				index = mark.nextIndex;
+				atStatementStart = false;
+				continue;
+			}
+		}
+		if (char === "(") {
+			flushWord();
+			parenDepth += 1;
+			state.current += char;
+			index += 1;
+			atStatementStart = true;
+			continue;
+		}
+		if (char === ")") {
+			flushWord();
+			parenDepth = Math.max(0, parenDepth - 1);
+			state.current += char;
+			index += 1;
+			atStatementStart = false;
+			continue;
+		}
+		if (char === "{") {
+			flushWord();
+			braceDepth += 1;
+			state.current += char;
+			index += 1;
+			atStatementStart = true;
+			continue;
+		}
+		if (char === "}") {
+			flushWord();
+			braceDepth = Math.max(0, braceDepth - 1);
+			state.current += char;
+			index += 1;
+			atStatementStart = false;
+			continue;
+		}
+		if (char === "\n") {
+			flushWord();
+			if (pendingHeredocs.length > 0) {
+				const consumed = consumeHeredocBodies(script, index + 1, pendingHeredocs);
+				state.current += script.slice(index, consumed);
+				pendingHeredocs = [];
+				index = consumed;
+				continue;
+			}
+			if (parenDepth > 0 || braceDepth > 0 || blockDepth > 0 || inBacktick || endsWithContinuation(state.current)) {
+				state.current += char;
+				index += 1;
+				atStatementStart = true;
+				continue;
+			}
+			endStatement();
+			index += 1;
+			continue;
+		}
+		if (char === ";") {
+			flushWord();
+			if (parenDepth > 0 || braceDepth > 0 || blockDepth > 0 || inBacktick) {
+				state.current += char;
+				index += 1;
+				atStatementStart = true;
+				continue;
+			}
+			endStatement();
+			index += 1;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			flushWord();
+			state.current += char;
+			index += 1;
+			continue;
+		}
+		if (char === "&" || char === "|") {
+			flushWord();
+			state.current += char;
+			index += 1;
+			atStatementStart = true;
+			continue;
+		}
+		word += char;
+		state.current += char;
+		atStatementStart = false;
+		index += 1;
 	}
+	endStatement();
 	return {
-		admitted: true,
-		screening,
-		row: {
-			rowId: evidence.rowId,
-			taskName: evidence.taskName,
-			image: evidence.image,
-			cwd: evidence.cwd,
-			taskStatement: evidence.taskStatement,
-			steps: evidence.steps,
-			criteria,
-			prefixDivergenceRatio,
-			suiteDigest: evidence.suiteDigest,
-			controlPolicy: evidence.controlPolicy,
-			controlScreening: criteria.controlScreening,
-			policyDigest: evidence.controlPolicy.digest,
-			controlRate: evidence.noFixControl.passes / evidence.noFixControl.rollouts,
-			controlRollouts: evidence.noFixControl.rollouts
-		}
+		statements: state.statements,
+		heredocs: state.heredocs
 	};
 }
-function assertCriteria(criteria) {
-	const { maxPrefixDivergenceRatio, controlRollouts } = criteria;
-	if (!(maxPrefixDivergenceRatio >= 0 && maxPrefixDivergenceRatio <= 1)) throw new ValidationError(`admission maxPrefixDivergenceRatio must be within [0,1], got ${maxPrefixDivergenceRatio}`);
-	if (!Number.isInteger(controlRollouts) || controlRollouts <= 0) throw new ValidationError(`admission controlRollouts must be a positive integer, got ${controlRollouts}`);
+function isCommentOnly(text) {
+	return text.split("\n").every((line) => line.trim().length === 0 || line.trim().startsWith("#"));
+}
+function endsWithContinuation(current) {
+	const trimmed = current.trimEnd();
+	return /(&&|\|\||\||&|\\)$/.test(trimmed);
 }
-//#endregion
-//#region src/trace-repair/admission-report.ts
-/** Plain JSON. `JSON.stringify` of this object is the machine-readable artifact. */
-function admissionArtifact(report) {
-	assertChainReconciles(report.chain);
+function readHeredocMark(script, index) {
+	let cursor = index + 2;
+	let stripTabs = false;
+	if (script[cursor] === "-") {
+		stripTabs = true;
+		cursor += 1;
+	}
+	while (script[cursor] === " " || script[cursor] === "	") cursor += 1;
+	const quote = script[cursor];
+	if (quote === "'" || quote === "\"") {
+		const close = script.indexOf(quote, cursor + 1);
+		if (close === -1) return null;
+		return {
+			mark: {
+				delimiter: script.slice(cursor + 1, close),
+				stripTabs,
+				quoted: true
+			},
+			nextIndex: close + 1
+		};
+	}
+	const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(script.slice(cursor));
+	if (!match) return null;
 	return {
-		version: 1,
-		kind: "tb-repair-admission",
-		generatedAt: report.generatedAt,
-		digest: report.digest,
-		config: report.config,
-		provenance: report.provenance,
-		chain: report.chain,
-		admitted: {
-			"clean-exit": report.strata["clean-exit"],
-			"command-error": report.strata["command-error"],
-			"signal-kill": report.strata["signal-kill"]
-		},
-		controlCost: {
-			kind: report.controlCost.kind,
-			usd: report.controlCost.usd
+		mark: {
+			delimiter: match[0],
+			stripTabs,
+			quoted: false
 		},
-		rows: report.rows
+		nextIndex: cursor + match[0].length
 	};
 }
-/** Markdown for the campaign report. Every number here is also in the artifact. */
-function renderAdmissionReport(artifact, options = {}) {
-	const lines = [];
-	lines.push("# TB-Repair admission", "");
-	lines.push(`${artifact.chain.overall.admitted} of ${artifact.chain.overall.input} rows admitted. Digest \`${artifact.digest}\`.`, "");
-	lines.push(...provenanceSection(artifact));
-	lines.push(...chainSection(artifact.chain.overall, "Denominator chain"));
-	for (const chain of artifact.chain.byStratum) lines.push(...chainSection(chain, `Denominator chain — ${chain.scope}`));
-	lines.push(...stratumSection(artifact));
-	lines.push(...reasonSection(artifact.chain.reasonTotals));
-	const rowLimit = options.rowLimit ?? 0;
-	if (rowLimit > 0) lines.push(...rowSection(artifact.rows, rowLimit));
-	return `${lines.join("\n").trimEnd()}\n`;
-}
-function provenanceSection(artifact) {
-	const { provenance, config, controlCost } = artifact;
-	const cost = controlCost.usd === null ? "uncaptured" : `$${controlCost.usd.toFixed(4)}`;
-	return [
-		"## Provenance",
-		"",
-		"| field | value |",
-		"| --- | --- |",
-		`| generated | ${artifact.generatedAt} |`,
-		`| prefix replayer | \`${provenance.replayerId}\` |`,
-		`| end-state oracle | \`${provenance.oracleId}\` |`,
-		`| control runner | \`${provenance.controlRunnerId}\` |`,
-		`| continuation policy | \`${provenance.policyId}\` |`,
-		`| policy model | \`${provenance.policyModel}\` |`,
-		`| policy seed | ${provenance.policySeed} |`,
-		`| policy digest | \`${provenance.policyDigest}\` |`,
-		`| policy step budget | ${provenance.policyStepBudget} model call(s) per control rollout |`,
-		`| control screening | \`${provenance.controlScreening}\` |`,
-		`| certified task oracles | ${formatCertifiedTasks(provenance.certifiedTasks)} |`,
-		`| max prefix divergence | ${formatShare(config.maxPrefixDivergence)} |`,
-		`| control rollouts per arm | ${config.controlRollouts} |`,
-		`| inert action | \`${config.inertAction}\` |`,
-		`| strata admitted | ${config.admitStrata.join(", ")} |`,
-		`| control model cost | ${cost} (${controlCost.kind}) |`,
-		""
-	];
-}
-function formatCertifiedTasks(certified) {
-	const entries = Object.entries(certified).sort(([a], [b]) => a.localeCompare(b));
-	if (entries.length === 0) return "none";
-	return entries.map(([task, flipRate]) => `${task} (flip ${formatShare(flipRate)})`).join(", ");
+/** Consume every pending heredoc body; returns the offset just past the last
+*  terminator, or the end of the script when a terminator never arrives. */
+function consumeHeredocBodies(script, from, marks) {
+	let cursor = from;
+	for (const mark of marks) {
+		let closed = false;
+		while (cursor < script.length) {
+			const lineEnd = script.indexOf("\n", cursor);
+			const stop = lineEnd === -1 ? script.length : lineEnd;
+			const line = script.slice(cursor, stop);
+			const candidate = mark.stripTabs ? line.replace(/^\t+/, "") : line;
+			cursor = lineEnd === -1 ? script.length : lineEnd + 1;
+			if (candidate === mark.delimiter) {
+				closed = true;
+				break;
+			}
+		}
+		if (!closed) return script.length;
+	}
+	return cursor;
 }
-function chainSection(chain, heading) {
-	const lines = [
-		`## ${heading}`,
-		"",
-		"| stage | exclusion reason | entering | excluded | remaining |",
-		"| --- | --- | --- | --- | --- |"
-	];
-	chain.stages.forEach((stage, index) => {
-		lines.push(`| ${index + 1} | \`${stage.reason}\` | ${stage.entering} | ${stage.excluded} | ${stage.remaining} |`);
+/**
+* Measure an action against the budget.
+*
+* The budget bounds what the scaffold can execute: one top-level statement,
+* one authored file, a byte cap, and neither a no-op nor a submit. Every
+* rejection here is one of those.
+*
+* `declaredKind` is what the analyst called its own action. It is recorded
+* beside the measured payload and never rejected on, because the scaffold runs
+* the action identically either way — so rejecting the label scores an arm on
+* how it described a repair rather than on the repair. A reader who wants the
+* mismatch counts `declared` against `payload`.
+*/
+function checkInterventionBudget(action, declaredKind, budget = SCAFFOLD_INTERVENTION_BUDGET) {
+	assertBudget(budget);
+	const scan = scanShellAction(action);
+	const payload = scan.heredocs > 0 ? "edit" : "shell";
+	const measurement = {
+		bytes: Buffer.byteLength(action, "utf8"),
+		statements: scan.statements.length,
+		heredocs: scan.heredocs,
+		payload,
+		declared: declaredKind
+	};
+	const reject = (violation, detail) => ({
+		admissible: false,
+		violation,
+		detail,
+		measurement
 	});
-	const excluded = chain.input - chain.admitted;
-	lines.push("", `Input ${chain.input} = admitted ${chain.admitted} + excluded ${excluded}. Admission rate ${formatShare(rate(chain.admitted, chain.input))}.`, "");
-	return lines;
+	if (action.trim().length === 0) return reject("empty", "the intervention is empty");
+	if (measurement.bytes > budget.maxBytes) return reject("over-byte-cap", `${measurement.bytes} bytes exceeds the ${budget.maxBytes}-byte action budget`);
+	if (measurement.statements > budget.maxStatements) return reject("multiple-statements", `${measurement.statements} top-level statements exceeds the ${budget.maxStatements} the scaffold takes per action`);
+	if (measurement.heredocs > budget.maxHeredocs) return reject("multiple-heredocs", `${measurement.heredocs} heredocs exceeds the ${budget.maxHeredocs} one edit may author`);
+	if (action.includes(SUBMIT_SENTINEL)) return reject("submit-instead-of-repair", "the action submits the run instead of repairing it");
+	if (NO_OP_ACTIONS.includes(action.trim())) return reject("no-op-action", `"${action.trim()}" changes nothing`);
+	return {
+		admissible: true,
+		measurement
+	};
 }
-function stratumSection(artifact) {
-	const lines = [
-		"## Strata",
-		"",
-		"| stratum | admitted rows | in this campaign |",
-		"| --- | --- | --- |"
-	];
-	for (const stratum of ADMISSION_STRATA) {
-		const admitted = artifact.admitted[stratum].length;
-		const eligible = artifact.chain.admitStrata.includes(stratum) ? "yes" : "no";
-		lines.push(`| ${stratum} | ${admitted} | ${eligible} |`);
+function assertBudget(budget) {
+	for (const field of [
+		"maxBytes",
+		"maxStatements",
+		"maxHeredocs"
+	]) {
+		const value = budget[field];
+		if (!Number.isInteger(value) || value <= 0) throw new ValidationError(`intervention budget ${field} must be a positive integer, got ${value}`);
 	}
-	lines.push("", "Sample within a stratum. A command-level repair cannot address a signal kill, so pooling that population with the others averages an addressable class with an unaddressable one.", "");
-	return lines;
-}
-function reasonSection(totals) {
-	const lines = [
-		"## Exclusions",
-		"",
-		"| reason | rows | what it means |",
-		"| --- | --- | --- |"
-	];
-	for (const reason of ADMISSION_EXCLUSION_ORDER) lines.push(`| \`${reason}\` | ${totals[reason]} | ${ADMISSION_EXCLUSION_MEANING[reason]} |`);
-	lines.push("");
-	return lines;
-}
-function rowSection(rows, limit) {
-	const lines = [
-		"## Rows",
-		"",
-		"| row | task | stratum | final rc | admitted | excluded by |",
-		"| --- | --- | --- | --- | --- | --- |"
-	];
-	for (const row of rows.slice(0, limit)) lines.push(`| \`${row.rowId}\` | ${row.taskName} | ${row.stratum ?? "—"} | ${row.finalReturncode ?? "—"} | ${row.admitted ? "yes" : "no"} | ${row.excludedBy === null ? "—" : `\`${row.excludedBy}\``} |`);
-	if (rows.length > limit) lines.push("", `${rows.length - limit} further rows in the artifact.`);
-	lines.push("");
-	return lines;
-}
-function rate(part, total) {
-	return total === 0 ? 0 : part / total;
 }
-function formatShare(share) {
-	return `${(share * 100).toFixed(2)}%`;
+/**
+* Whitespace-insensitive comparison used to reject an intervention that is
+* the recorded action again. Trailing whitespace and blank lines are the only
+* differences a re-proposal can carry without changing what runs.
+*/
+function normalizeActionForComparison(action) {
+	return action.split("\n").map((line) => line.trimEnd()).filter((line, index, lines) => line.length > 0 || index > 0 && index < lines.length - 1).join("\n").trim();
 }
 //#endregion
 //#region src/trace-repair/blinding.ts
@@ -1814,11 +1800,7 @@ function blindTrajectory(row, options = {}) {
 		maxK: through
 	};
 }
-/**
-* Fields an analyst prompt must never carry. Exported so a consumer that
-* builds its own prompt can assert against the same list this module honours.
-*/
-const BLINDED_FIELDS = Object.freeze([
+Object.freeze([
 	"criteria",
 	"controlPolicy",
 	"controlRate",
@@ -2094,20 +2076,6 @@ function assertReplyWithinDeclaration(declaration, reply) {
 }
 //#endregion
 //#region src/trace-repair/analyst-response.ts
-/**
-* What an analyst is allowed to say about a blinded trajectory prefix.
-*
-* Exactly one of two answers:
-*
-*   a finding                {k, failureClaim, intervention}
-*   the literal string       no-decisive-failure
-*
-* Nothing else parses. A finding names one step, states what went wrong
-* there, and supplies one action to run instead. Declining is a real answer
-* with its own cell in the funnel, not a parse failure — an admitted row has
-* a failure by construction, but it need not have a single-action repair, and
-* an analyst that says so is answering the question it was asked.
-*/
 /** The literal an analyst returns when no single step carries the failure. */
 const NO_DECISIVE_FAILURE = "no-decisive-failure";
 /**
@@ -2188,17 +2156,6 @@ function parseAnalystResponse(reply) {
 		}
 	};
 }
-/** Build a finding directly, for callers that already hold typed fields. */
-function repairFinding(input) {
-	if (!Number.isInteger(input.k) || input.k < 1) throw new ValidationError(`repair finding k must be a positive integer, got ${input.k}`);
-	if (input.failureClaim.trim().length === 0) throw new ValidationError("repair finding requires a non-empty failure claim");
-	return {
-		kind: "finding",
-		k: input.k,
-		failureClaim: input.failureClaim.trim(),
-		intervention: input.intervention
-	};
-}
 function describe$2(value) {
 	if (value === null) return "null";
 	if (value === void 0) return "undefined";
@@ -2703,9 +2660,6 @@ function engineUsage(modelCalls) {
 		costUsd: null
 	};
 }
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function describe(value) {
 	if (value === null) return "null";
 	if (value === void 0) return "undefined";
@@ -2717,51 +2671,6 @@ function assertDspyRepairEngine(engine) {
 }
 //#endregion
 //#region src/trace-repair/continuation-records.ts
-/**
-* Project a full message list into corpus steps: the system and task messages
-* become their own steps, and every assistant turn carries the command it
-* requested plus the observation that answered it. A trailing assistant turn
-* with no answer keeps `obs: null`, which is how the corpus records a run that
-* ended on its last command.
-*/
-function toRecordedSteps(messages) {
-	const steps = [];
-	for (let i = 0; i < messages.length; i += 1) {
-		const message = messages[i];
-		if (!message) continue;
-		if (message.role === "assistant") {
-			const parsed = parseAction(message.content);
-			const next = messages[i + 1];
-			steps.push({
-				src: "agent",
-				msg: message.content,
-				tools: parsed.kind === "action" ? [{
-					fn: "bash_command",
-					cmd: parsed.command
-				}] : null,
-				obs: next && next.role === "user" ? next.content : null
-			});
-			continue;
-		}
-		if (message.role === "system") {
-			steps.push({
-				src: "system",
-				msg: message.content,
-				tools: null,
-				obs: null
-			});
-			continue;
-		}
-		const previous = messages[i - 1];
-		if (!previous || previous.role === "system") steps.push({
-			src: "user",
-			msg: message.content,
-			tools: null,
-			obs: null
-		});
-	}
-	return steps;
-}
 /** Corpus steps for the continuation alone, excluding the prefix it inherited. */
 function rolloutRecordedSteps(rollout) {
 	return rollout.steps.map((step) => ({
@@ -2870,11 +2779,6 @@ const DEGENERATE_STRATEGIES = [
 ];
 //#endregion
 //#region src/trace-repair/funnel.ts
-const CREDIT_TERMS = [
-	"executes",
-	"localFlip",
-	"repairRate"
-];
 const ZERO_CREDIT = Object.freeze({
 	executes: 0,
 	localFlip: 0,
@@ -3060,9 +2964,6 @@ function measuredPrefixDivergences(grade) {
 	if (grade.outcome === "not-reproduced" && grade.reproduction.basis !== "no-recorded-observation") return grade.reproduction.prefix.divergences;
 	return 0;
 }
-function mean(values) {
-	return values.reduce((sum, value) => sum + value, 0) / values.length;
-}
 /** Markdown report: provenance, the funnel, every per-row column, the
 *  distribution, and the threats. */
 function renderDeltaRepairReport(report) {
@@ -3225,29 +3126,6 @@ const KILL_GRACE_SECONDS = 5;
 const BACKSTOP_SECONDS = 10;
 /** `timeout` reports this when it stopped the command. */
 const TIMEOUT_EXIT_CODE = 124;
-/**
-* Arguments that create a container the policy accepts. `--network none` is
-* not optional: a continuation with network access could install what the
-* recorded run could not, and the arms would no longer differ only by the
-* intervention.
-*/
-function dockerRunArgs(input) {
-	return [
-		input.executable ?? DEFAULT_EXECUTABLE,
-		"run",
-		"-d",
-		"--name",
-		input.name,
-		"--network",
-		"none",
-		"-w",
-		input.cwd,
-		"--rm",
-		input.image,
-		"sleep",
-		input.containerLifetime ?? "2h"
-	];
-}
 function createDockerContinuationEnvironment(options) {
 	if (!options.containerRef.trim()) throw new ValidationError("docker continuation environment requires a container reference");
 	const executable = options.executable ?? DEFAULT_EXECUTABLE;
@@ -3886,6 +3764,6 @@ function shellQuote(value) {
 	return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 //#endregion
-export { ADMISSION_CONFIG_DEFAULTS, ADMISSION_EXCLUSION_MEANING, ADMISSION_EXCLUSION_ORDER, ADMISSION_STRATA, AdmissionDenominatorError, AdmissionIndependenceError, BLINDED_FIELDS, CONTROL_SCREENING_MODES, CREDIT_TERMS, ContinuationPolicyViolationError, ContinuationSymmetryError, DEGENERATE_STRATEGIES, DSPY_REPAIR_SIGNATURE, DSPY_REPAIR_TASK_TOKEN, MINI_SWE_SYSTEM_MESSAGE, NO_DECISIVE_FAILURE, NondeterministicOracleError, OUTPUT_ELISION_THRESHOLD, REPAIR_CONTRACT_LINES, REPAIR_QUESTION, REPAIR_REPAIR_CONTRACT_LINES, SCAFFOLD_INTERVENTION_BUDGET, SUBMIT_SENTINEL, SUITE_REWARD_UNIT, TB_REPAIR_ADMISSION_CRITERIA, TestOracleError, TestSuiteTamperedError, UncalibratedControlError, admissionArtifact, admitRow, admittedCount, admittedRowIds, askRepairArm, assertAnalystIndependent, assertArmSymmetry, assertChainReconciles, assertControlCalibrated, assertDenominatorIntact, assertDeterministicOracle, assertDspyRepairEngine, blindTrajectory, buildDenominatorChain, checkInterventionBudget, classifyActionPayload, continuationPolicyDigest, continuationSeed, controlCanRescue, countFunnel, createCompletionRepairArm, createDockerContinuationEnvironment, createDspyRepairArm, defineControlPolicy, definePinnedContinuationPolicy, deltaRepair, dockerRunArgs, dspyRepairInstructions, gradeRepairRow, injectedTestOracle, isRecordedTimeout, noOpInjectionStep, nodeProcessRunner, normalizeActionForComparison, oracleDeterminism, parseAction, parseAnalystResponse, parseTaskOracleRegistry, renderAdmissionReport, renderDeltaRepairReport, renderFormatErrorObservation, renderInstanceMessage, renderObservation, renderRepairTrajectory, renderTimeoutObservation, repairArmAsymmetries, repairArmPromptSha256, repairArmResponse, repairCredit, repairFinding, repairQuestionSha256, repairTaskDefinition, repairTaskPolicy, repairTrajectoryHeader, resolveAdmissionConfig, rolloutDigest, rolloutRecordedSteps, runAdmission, runContinuation, scanShellAction, stratumOf, submissionOf, taskOracleRegistry, testSuiteDigest, toRecordedSteps, totalCost, totalUsage };
+export { ADMISSION_CONFIG_DEFAULTS, DEGENERATE_STRATEGIES, DSPY_REPAIR_SIGNATURE, TestSuiteTamperedError, UncalibratedControlError, admissionArtifact, admitRow, askRepairArm, assertAnalystIndependent, assertArmSymmetry, assertChainReconciles, assertControlCalibrated, assertDenominatorIntact, assertDeterministicOracle, blindTrajectory, buildDenominatorChain, continuationPolicyDigest, continuationSeed, createCompletionRepairArm, createDockerContinuationEnvironment, createDspyRepairArm, defineControlPolicy, definePinnedContinuationPolicy, deltaRepair, gradeRepairRow, injectedTestOracle, nodeProcessRunner, parseAction, parseAnalystResponse, parseTaskOracleRegistry, renderAdmissionReport, renderDeltaRepairReport, repairArmAsymmetries, repairArmPromptSha256, repairArmResponse, repairQuestionSha256, rolloutDigest, rolloutRecordedSteps, runAdmission, runContinuation, totalCost, totalUsage };
 
 //# sourceMappingURL=index.js.map