@tangle-network/agent-eval 0.145.9 → 0.145.11

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { o as runRolloutReleaseCli } from "./hf-dataset-XggBupCr.js";
-import { n as runAnalystBenchmarkCommand } from "./benchmark-command-k6kI1D8H.js";
+import { n as runAnalystBenchmarkCommand } from "./benchmark-command-D8K5YJNS.js";
 import { a as runRpcBatch, o as runRpcOnce, p as handleVersion, r as startServerAsync, s as buildOpenApi } from "./server-ulsOdrTI.js";
 import { writeFileSync } from "node:fs";
 //#region src/cli-config.ts

package/dist/exec-y-DCLqK7.js

@@ -0,0 +1,204 @@
+//#region src/trajectory-replay/steps.ts
+/** Recorded returncode of a step, or null when the observation carries none. */
+function parseRecordedReturncode(observation) {
+	if (!observation) return null;
+	const m = /<returncode>(-?\d+)<\/returncode>/.exec(observation);
+	return m ? Number(m[1]) : null;
+}
+/** Text between the observation's <output> tags, or the raw observation when
+*  the tags are absent. */
+function parseObservationOutput(observation) {
+	if (!observation) return "";
+	const m = /<output>\n?([\s\S]*?)\n?<\/output>/.exec(observation);
+	return m ? m[1] : observation;
+}
+/**
+* Stable failure-signature candidate: the first line of the recorded output
+* that contains the word "error". Null when no such line exists — a verdict
+* then falls back to returncode-only matching and says so.
+* Pass an explicit signature to override (compiler quote glyphs vary with
+* locale, so a hand-picked ASCII substring is often more robust).
+*/
+function deriveFailureSignature(observation) {
+	const line = parseObservationOutput(observation).split("\n").find((l) => /\berror\b/i.test(l));
+	return line ? line.trim().slice(0, 200) : null;
+}
+/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel
+*  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a
+*  failed command — there is no executable failure to reproduce, so it is
+*  never a counterfactual replay target. */
+const SUBMIT_ACTION_SIGNATURE = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
+function isSubmitAction(action) {
+	return action.includes(SUBMIT_ACTION_SIGNATURE);
+}
+/**
+* True when the action is the sentinel echo and nothing else.
+*
+* The distinction decides whether a step may be dropped. An agent is told to
+* issue the sentinel alone, and 5.7% of recorded runs end on a command that
+* writes files or edits them and then echoes it. Dropping such a step because
+* it holds the sentinel would remove the run's last state change from the
+* replay, so the recorded end state and the replayed one would differ.
+*/
+function isSubmitOnlyAction(action) {
+	return /^echo\s+(?:"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT"|'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'|COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT)$/.test(action.trim());
+}
+/**
+* A field the dump replaced with a counter instead of its text.
+*
+* The counter is hexadecimal and rises by one per dropped string in document
+* order, so a decimal-only reading (`$12`) accepts every marker that carries a
+* letter (`$3a`) as if it were real text. A command read that way replays as
+* the literal two-to-four characters `$3a`, which is not the command the run
+* executed.
+*
+* Nothing in the dump maps a marker back to its text: the same marker carries
+* different content in different rows, so there is no dictionary to read. A
+* field that matches is unrecoverable, so a caller rejects the row that holds
+* it rather than replaying the marker.
+*/
+const RECORDED_ELISION_PATTERN = /^\$[0-9a-f]+$/;
+function isElidedField(value) {
+	return typeof value === "string" && RECORDED_ELISION_PATTERN.test(value);
+}
+/** Substring the timeout notice always carries, whatever the command was. */
+const TIMEOUT_OBSERVATION_MARKER = "timed out and has been killed";
+/** Opening of the notice the scaffold writes when a turn held no single action. */
+const FORMAT_ERROR_OBSERVATION_PREFIX = "Please always provide EXACTLY ONE action in triple backticks, found ";
+function classifyObservation(observation) {
+	if (observation === null) return "absent";
+	if (isElidedField(observation)) return "elided";
+	if (parseRecordedReturncode(observation) !== null) return "command-result";
+	if (observation.startsWith("Please always provide EXACTLY ONE action in triple backticks, found ")) return "format-error";
+	if (observation.includes("timed out and has been killed")) return "timeout";
+	return "unreadable";
+}
+/** True when the recording shows the environment killed this step at its
+*  wall-clock bound. Such a step carries no returncode, so no replay can
+*  confirm or contradict it. */
+function isRecordedTimeout(observation) {
+	return classifyObservation(observation) === "timeout";
+}
+/**
+* Pair every recorded command with the observation of its own turn.
+*
+* Collecting commands and observations into two lists and zipping them is the
+* decode that looks right and is not: a turn the scaffold rejected carries an
+* observation of its own, so from the first such turn onward every observation
+* belongs to a different command than the one it is read against.
+*
+* A rejected turn executed nothing, so it is never a step — including when the
+* dump recorded a command for it. The scaffold rejects a turn holding several
+* bash blocks and runs none of them, while the dump keeps one of the blocks in
+* the command field. Replaying that field would execute a command the recorded
+* run did not, which is a worse corpus than a smaller one.
+*
+* A rejected turn is recognised by its observation, so a rejected turn whose
+* observation the dump elided is indistinguishable from an executed command
+* whose observation it elided. Both read as a step. Nothing in the dump
+* separates them, and the row-level defence is the share of unreadable exits a
+* caller admits: a row with no elided observation cannot hold this case at all.
+*
+* A trailing step that echoes the sentinel and nothing else, with no
+* observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.
+* The scaffold records an observation only when it hands one to the model, and
+* the sentinel ends the run, so the missing observation is the end of the
+* transcript rather than a gap in it. Echoing the sentinel changes no state, so
+* the recorded end state is the state the step before it left.
+*
+* A step that DID get an observation stays a step: the run continued past it.
+* So does a step that echoes the sentinel after doing real work — its state
+* change is part of the recorded end state, and with no observation its exit is
+* unknown, which `finalRecordedOutcome` reports rather than hides.
+*/
+function decodeRecordedTurns(turns) {
+	const steps = [];
+	let formatErrorTurns = 0;
+	let unreadableTurns = 0;
+	for (const turn of turns) {
+		const command = turn.tools?.[0]?.cmd ?? null;
+		const observation = turn.obs ?? null;
+		const kind = classifyObservation(observation);
+		if (kind === "format-error") {
+			formatErrorTurns += 1;
+			continue;
+		}
+		if (command === null) {
+			if (kind === "unreadable" || kind === "elided") unreadableTurns += 1;
+			continue;
+		}
+		steps.push({
+			step_id: steps.length + 1,
+			action: command,
+			observation
+		});
+	}
+	const last = steps[steps.length - 1];
+	const endedOnSubmitSentinel = last !== void 0 && last.observation === null && isSubmitOnlyAction(last.action);
+	if (endedOnSubmitSentinel) steps.pop();
+	return {
+		steps,
+		formatErrorTurns,
+		elidedCommands: steps.filter((step) => isElidedField(step.action)).length,
+		endedOnSubmitSentinel,
+		unreadableTurns
+	};
+}
+/**
+* The outcome of the last step, or `null` when the trajectory has no steps.
+*
+* Reads only the last step. `decodeRecordedTurns` has already removed the turns
+* that executed nothing, so the last step is the last command the run ran.
+*/
+function finalRecordedOutcome(steps) {
+	const last = steps[steps.length - 1];
+	if (last === void 0) return null;
+	const kind = classifyObservation(last.observation);
+	if (kind === "command-result") return {
+		kind: "returncode",
+		value: parseRecordedReturncode(last.observation)
+	};
+	if (kind === "timeout") return { kind: "killed" };
+	return {
+		kind: "unreadable",
+		reason: kind
+	};
+}
+/**
+* Steps whose recorded exit a replay cannot check.
+*
+* A killed step counts: the recording holds no exit status to compare a replay
+* against, so agreement on it cannot be measured either way.
+*/
+function unreadableExitCount(steps) {
+	return steps.filter((step) => classifyObservation(step.observation) !== "command-result").length;
+}
+/**
+* Throw unless every recorded command survived the dump.
+*
+* A replay executes `steps` verbatim, so one elision marker in an action means
+* the replay runs the literal two-to-four characters of the marker instead of
+* the command the run executed. The guard is here so a replayer needs one call
+* rather than a field check it can forget.
+*/
+function assertReplayableTrajectory(decoded) {
+	if (decoded.elidedCommands === 0) return;
+	const markers = decoded.steps.filter((step) => isElidedField(step.action)).map((step) => step.action);
+	throw new Error(`trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(", ")}); no dictionary maps a marker back to its text, so this trajectory cannot be replayed`);
+}
+//#endregion
+//#region src/trajectory-replay/exec.ts
+/**
+* mini-SWE runs every action as a fresh /bin/sh subshell from a fixed
+* workdir. Reproduce that exactly — and stay quote-proof for arbitrary
+* recorded actions — by piping the base64 of the action into `sh` after
+* cd-ing to the workdir. Exit code is sh's, i.e. the action's.
+*/
+function wrapActionForExec(action, cwd) {
+	const b64 = Buffer.from(action, "utf8").toString("base64");
+	return `cd ${`'${cwd.replaceAll("'", `'\\''`)}'`} && printf %s ${b64} | base64 -d | sh`;
+}
+//#endregion
+export { unreadableExitCount as _, TIMEOUT_OBSERVATION_MARKER as a, decodeRecordedTurns as c, isElidedField as d, isRecordedTimeout as f, parseRecordedReturncode as g, parseObservationOutput as h, SUBMIT_ACTION_SIGNATURE as i, deriveFailureSignature as l, isSubmitOnlyAction as m, FORMAT_ERROR_OBSERVATION_PREFIX as n, assertReplayableTrajectory as o, isSubmitAction as p, RECORDED_ELISION_PATTERN as r, classifyObservation as s, wrapActionForExec as t, finalRecordedOutcome as u };
+
+//# sourceMappingURL=exec-y-DCLqK7.js.map

package/dist/exec-y-DCLqK7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-y-DCLqK7.js","names":[],"sources":["../src/trajectory-replay/steps.ts","../src/trajectory-replay/exec.ts"],"sourcesContent":["/**\n * Recorded shell-trajectory steps and the observation grammar they carry.\n *\n * A recorded trajectory is the action/observation sequence an agent actually\n * ran. Scaffolds that execute one shell command per step (mini-SWE and the\n * CodeTracer-normalized corpora built from it) tag each observation with the\n * command's returncode and its combined output:\n *\n *     <returncode>2</returncode>\n *     <output>\n *     …command output…\n *     </output>\n *\n * That is one of four shapes a recorded turn carries, and the other three are\n * not command results at all:\n *\n *   - a timeout notice, when the environment killed the command at its bound;\n *   - a format-error notice, when the scaffold rejected the turn and ran\n *     nothing;\n *   - an elision marker `$<hex>`, when the published dump dropped the string.\n *\n * A turn also carries no observation when it is the run's last turn, because\n * the scaffold records an observation only when it hands one back to the model.\n *\n * The parsers here are the only place that grammar is decoded. Everything\n * downstream — replay verdicts, corpus enumeration, admission funnels, fix\n * prompts — reads the returncode, the output, and the failure signature through\n * these functions. A second decoder elsewhere is how a corpus reads as\n * unreplayable when it is not.\n */\n\n/**\n * One step of a recorded shell trajectory. Structural: any richer step record\n * (file refs, thinking text, tool type) satisfies it.\n */\nexport interface RecordedTrajectoryStep {\n  /** 1-based position in the trajectory. */\n  readonly step_id: number\n  readonly action: string\n  /** Null when the step recorded no observation (terminal submit steps). */\n  readonly observation: string | null\n}\n\n/** Recorded returncode of a step, or null when the observation carries none. */\nexport function parseRecordedReturncode(observation: string | null): number | null {\n  if (!observation) return null\n  const m = /<returncode>(-?\\d+)<\\/returncode>/.exec(observation)\n  return m ? Number(m[1]) : null\n}\n\n/** Text between the observation's <output> tags, or the raw observation when\n *  the tags are absent. */\nexport function parseObservationOutput(observation: string | null): string {\n  if (!observation) return ''\n  const m = /<output>\\n?([\\s\\S]*?)\\n?<\\/output>/.exec(observation)\n  return m ? m[1]! : observation\n}\n\n/**\n * Stable failure-signature candidate: the first line of the recorded output\n * that contains the word \"error\". Null when no such line exists — a verdict\n * then falls back to returncode-only matching and says so.\n * Pass an explicit signature to override (compiler quote glyphs vary with\n * locale, so a hand-picked ASCII substring is often more robust).\n */\nexport function deriveFailureSignature(observation: string | null): string | null {\n  const line = parseObservationOutput(observation)\n    .split('\\n')\n    .find((l) => /\\berror\\b/i.test(l))\n  return line ? line.trim().slice(0, 200) : null\n}\n\n/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel\n *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a\n *  failed command — there is no executable failure to reproduce, so it is\n *  never a counterfactual replay target. */\nexport const SUBMIT_ACTION_SIGNATURE = 'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'\n\nexport function isSubmitAction(action: string): boolean {\n  return action.includes(SUBMIT_ACTION_SIGNATURE)\n}\n\n/**\n * True when the action is the sentinel echo and nothing else.\n *\n * The distinction decides whether a step may be dropped. An agent is told to\n * issue the sentinel alone, and 5.7% of recorded runs end on a command that\n * writes files or edits them and then echoes it. Dropping such a step because\n * it holds the sentinel would remove the run's last state change from the\n * replay, so the recorded end state and the replayed one would differ.\n */\nexport function isSubmitOnlyAction(action: string): boolean {\n  return /^echo\\s+(?:\"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\"|'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'|COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT)$/.test(\n    action.trim(),\n  )\n}\n\n// ── Fields the published dump dropped ────────────────────────────────\n\n/**\n * A field the dump replaced with a counter instead of its text.\n *\n * The counter is hexadecimal and rises by one per dropped string in document\n * order, so a decimal-only reading (`$12`) accepts every marker that carries a\n * letter (`$3a`) as if it were real text. A command read that way replays as\n * the literal two-to-four characters `$3a`, which is not the command the run\n * executed.\n *\n * Nothing in the dump maps a marker back to its text: the same marker carries\n * different content in different rows, so there is no dictionary to read. A\n * field that matches is unrecoverable, so a caller rejects the row that holds\n * it rather than replaying the marker.\n */\nexport const RECORDED_ELISION_PATTERN = /^\\$[0-9a-f]+$/\n\nexport function isElidedField(value: string | null | undefined): boolean {\n  return typeof value === 'string' && RECORDED_ELISION_PATTERN.test(value)\n}\n\n// ── Observation grammar ──────────────────────────────────────────────\n\n/** Substring the timeout notice always carries, whatever the command was. */\nexport const TIMEOUT_OBSERVATION_MARKER = 'timed out and has been killed'\n\n/** Opening of the notice the scaffold writes when a turn held no single action. */\nexport const FORMAT_ERROR_OBSERVATION_PREFIX =\n  'Please always provide EXACTLY ONE action in triple backticks, found '\n\n/**\n * What a recorded observation is.\n *\n * `command-result` is the only kind that carries an exit status. `timeout` and\n * `format-error` are the scaffold speaking rather than a command: the first\n * says the environment killed the command, the second says no command ran at\n * all. `elided` and `absent` carry no information about the step, and\n * `unreadable` is a shape this grammar does not know — never assumed to be\n * anything.\n */\nexport type RecordedObservationKind =\n  | 'command-result'\n  | 'timeout'\n  | 'format-error'\n  | 'elided'\n  | 'absent'\n  | 'unreadable'\n\nexport function classifyObservation(observation: string | null): RecordedObservationKind {\n  if (observation === null) return 'absent'\n  if (isElidedField(observation)) return 'elided'\n  if (parseRecordedReturncode(observation) !== null) return 'command-result'\n  if (observation.startsWith(FORMAT_ERROR_OBSERVATION_PREFIX)) return 'format-error'\n  if (observation.includes(TIMEOUT_OBSERVATION_MARKER)) return 'timeout'\n  return 'unreadable'\n}\n\n/** True when the recording shows the environment killed this step at its\n *  wall-clock bound. Such a step carries no returncode, so no replay can\n *  confirm or contradict it. */\nexport function isRecordedTimeout(observation: string | null): boolean {\n  return classifyObservation(observation) === 'timeout'\n}\n\n// ── Turns to steps ───────────────────────────────────────────────────\n\n/**\n * One turn as the published trajectory dump holds it.\n *\n * A turn is not a step: the system prompt, the task statement and every turn\n * the scaffold rejected are turns that executed nothing.\n */\nexport interface RecordedTrajectoryTurn {\n  readonly src?: string | null\n  readonly msg?: string | null\n  readonly tools?: readonly { readonly cmd?: string | null }[] | null\n  readonly obs?: string | null\n}\n\nexport interface DecodedTrajectory {\n  /** Executed commands in recorded order, each holding its OWN observation. */\n  readonly steps: readonly RecordedTrajectoryStep[]\n  /** Turns the scaffold rejected before anything ran. */\n  readonly formatErrorTurns: number\n  /**\n   * Executed commands whose text the dump dropped.\n   *\n   * The step stays in `steps` carrying the marker, because the run did execute\n   * a command there and a shorter list would misreport the trajectory. The\n   * marker is not a command, so any count above zero means this trajectory\n   * cannot be replayed: gate on it, or call `assertReplayableTrajectory`.\n   */\n  readonly elidedCommands: number\n  /** True when the run's last turn was the submit sentinel with no observation. */\n  readonly endedOnSubmitSentinel: boolean\n  /** Turns carrying an observation this grammar cannot read. */\n  readonly unreadableTurns: number\n}\n\n/**\n * Pair every recorded command with the observation of its own turn.\n *\n * Collecting commands and observations into two lists and zipping them is the\n * decode that looks right and is not: a turn the scaffold rejected carries an\n * observation of its own, so from the first such turn onward every observation\n * belongs to a different command than the one it is read against.\n *\n * A rejected turn executed nothing, so it is never a step — including when the\n * dump recorded a command for it. The scaffold rejects a turn holding several\n * bash blocks and runs none of them, while the dump keeps one of the blocks in\n * the command field. Replaying that field would execute a command the recorded\n * run did not, which is a worse corpus than a smaller one.\n *\n * A rejected turn is recognised by its observation, so a rejected turn whose\n * observation the dump elided is indistinguishable from an executed command\n * whose observation it elided. Both read as a step. Nothing in the dump\n * separates them, and the row-level defence is the share of unreadable exits a\n * caller admits: a row with no elided observation cannot hold this case at all.\n *\n * A trailing step that echoes the sentinel and nothing else, with no\n * observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.\n * The scaffold records an observation only when it hands one to the model, and\n * the sentinel ends the run, so the missing observation is the end of the\n * transcript rather than a gap in it. Echoing the sentinel changes no state, so\n * the recorded end state is the state the step before it left.\n *\n * A step that DID get an observation stays a step: the run continued past it.\n * So does a step that echoes the sentinel after doing real work — its state\n * change is part of the recorded end state, and with no observation its exit is\n * unknown, which `finalRecordedOutcome` reports rather than hides.\n */\nexport function decodeRecordedTurns(turns: readonly RecordedTrajectoryTurn[]): DecodedTrajectory {\n  const steps: RecordedTrajectoryStep[] = []\n  let formatErrorTurns = 0\n  let unreadableTurns = 0\n  for (const turn of turns) {\n    const command = turn.tools?.[0]?.cmd ?? null\n    const observation = turn.obs ?? null\n    const kind = classifyObservation(observation)\n    if (kind === 'format-error') {\n      formatErrorTurns += 1\n      continue\n    }\n    if (command === null) {\n      if (kind === 'unreadable' || kind === 'elided') unreadableTurns += 1\n      continue\n    }\n    steps.push({ step_id: steps.length + 1, action: command, observation })\n  }\n  const last = steps[steps.length - 1]\n  const endedOnSubmitSentinel =\n    last !== undefined && last.observation === null && isSubmitOnlyAction(last.action)\n  if (endedOnSubmitSentinel) steps.pop()\n  return {\n    steps,\n    formatErrorTurns,\n    elidedCommands: steps.filter((step) => isElidedField(step.action)).length,\n    endedOnSubmitSentinel,\n    unreadableTurns,\n  }\n}\n\n// ── The state a trajectory ended in ──────────────────────────────────\n\n/**\n * How the recorded run's last executed command ended.\n *\n * `killed` is a measured outcome, not a missing one: the environment stopped\n * the command at its bound and wrote a notice instead of an exit status.\n * `unreadable` names the observation kind that blocked the read, so a funnel\n * can report which shape cost it the row.\n */\nexport type RecordedFinalOutcome =\n  | { readonly kind: 'returncode'; readonly value: number }\n  | { readonly kind: 'killed' }\n  | { readonly kind: 'unreadable'; readonly reason: RecordedObservationKind }\n\n/**\n * The outcome of the last step, or `null` when the trajectory has no steps.\n *\n * Reads only the last step. `decodeRecordedTurns` has already removed the turns\n * that executed nothing, so the last step is the last command the run ran.\n */\nexport function finalRecordedOutcome(\n  steps: readonly RecordedTrajectoryStep[],\n): RecordedFinalOutcome | null {\n  const last = steps[steps.length - 1]\n  if (last === undefined) return null\n  const kind = classifyObservation(last.observation)\n  if (kind === 'command-result') {\n    return { kind: 'returncode', value: parseRecordedReturncode(last.observation)! }\n  }\n  if (kind === 'timeout') return { kind: 'killed' }\n  return { kind: 'unreadable', reason: kind }\n}\n\n/**\n * Steps whose recorded exit a replay cannot check.\n *\n * A killed step counts: the recording holds no exit status to compare a replay\n * against, so agreement on it cannot be measured either way.\n */\nexport function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number {\n  return steps.filter((step) => classifyObservation(step.observation) !== 'command-result').length\n}\n\n/**\n * Throw unless every recorded command survived the dump.\n *\n * A replay executes `steps` verbatim, so one elision marker in an action means\n * the replay runs the literal two-to-four characters of the marker instead of\n * the command the run executed. The guard is here so a replayer needs one call\n * rather than a field check it can forget.\n */\nexport function assertReplayableTrajectory(decoded: DecodedTrajectory): void {\n  if (decoded.elidedCommands === 0) return\n  const markers = decoded.steps\n    .filter((step) => isElidedField(step.action))\n    .map((step) => step.action)\n  throw new Error(\n    `trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(', ')}); ` +\n      'no dictionary maps a marker back to its text, so this trajectory cannot be replayed',\n  )\n}\n","/**\n * The execution boundary replay runs across.\n *\n * A replay needs one thing from its environment: a session that runs a shell\n * command inside the trajectory's own image and reports the exit code and\n * output. That is the whole contract. Concrete backends — a sandbox platform\n * client, a docker exec, an SSH shell — live with the consumer that owns the\n * infrastructure, so this package depends on no sandbox client.\n */\n\nexport interface ReplayExecResult {\n  exitCode: number\n  stdout: string\n  stderr: string\n}\n\nexport interface ReplayExecSession {\n  exec(command: string, timeoutMs: number): Promise<ReplayExecResult>\n  close(): Promise<void>\n}\n\nexport interface ReplayExecBackend {\n  /** One fresh execution environment per call; the caller closes it. */\n  open(): Promise<ReplayExecSession>\n}\n\n/** Builds a backend pinned to one image. Callers that resolve images\n *  internally (batch, corpus wire, finding verification) take this instead of\n *  a backend, so every case runs against its own image. */\nexport type ReplayExecBackendFactory = (image: string) => ReplayExecBackend\n\n/**\n * mini-SWE runs every action as a fresh /bin/sh subshell from a fixed\n * workdir. Reproduce that exactly — and stay quote-proof for arbitrary\n * recorded actions — by piping the base64 of the action into `sh` after\n * cd-ing to the workdir. Exit code is sh's, i.e. the action's.\n */\nexport function wrapActionForExec(action: string, cwd: string): string {\n  const b64 = Buffer.from(action, 'utf8').toString('base64')\n  const quotedCwd = `'${cwd.replaceAll(\"'\", `'\\\\''`)}'`\n  return `cd ${quotedCwd} && printf %s ${b64} | base64 -d | sh`\n}\n"],"mappings":"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"}

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "@tangle-network/agent-eval — wire protocol",
-    "version": "0.145.9",
+    "version": "0.145.11",
     "description": "HTTP and stdio RPC interface to agent-eval. The TypeScript runtime is the source of truth; this spec is the contract that cross-language clients (Python, Rust, Go) generate from.\n\nWire-protocol version: 1.0.0. Bumps on breaking changes to request/response schemas.",
     "contact": {
       "name": "Tangle Network",

package/dist/steps-AmkT-GIM.d.ts

@@ -0,0 +1,216 @@
+//#region src/trajectory-replay/steps.d.ts
+/**
+ * Recorded shell-trajectory steps and the observation grammar they carry.
+ *
+ * A recorded trajectory is the action/observation sequence an agent actually
+ * ran. Scaffolds that execute one shell command per step (mini-SWE and the
+ * CodeTracer-normalized corpora built from it) tag each observation with the
+ * command's returncode and its combined output:
+ *
+ *     <returncode>2</returncode>
+ *     <output>
+ *     …command output…
+ *     </output>
+ *
+ * That is one of four shapes a recorded turn carries, and the other three are
+ * not command results at all:
+ *
+ *   - a timeout notice, when the environment killed the command at its bound;
+ *   - a format-error notice, when the scaffold rejected the turn and ran
+ *     nothing;
+ *   - an elision marker `$<hex>`, when the published dump dropped the string.
+ *
+ * A turn also carries no observation when it is the run's last turn, because
+ * the scaffold records an observation only when it hands one back to the model.
+ *
+ * The parsers here are the only place that grammar is decoded. Everything
+ * downstream — replay verdicts, corpus enumeration, admission funnels, fix
+ * prompts — reads the returncode, the output, and the failure signature through
+ * these functions. A second decoder elsewhere is how a corpus reads as
+ * unreplayable when it is not.
+ */
+/**
+ * One step of a recorded shell trajectory. Structural: any richer step record
+ * (file refs, thinking text, tool type) satisfies it.
+ */
+interface RecordedTrajectoryStep {
+  /** 1-based position in the trajectory. */
+  readonly step_id: number;
+  readonly action: string;
+  /** Null when the step recorded no observation (terminal submit steps). */
+  readonly observation: string | null;
+}
+/** Recorded returncode of a step, or null when the observation carries none. */
+declare function parseRecordedReturncode(observation: string | null): number | null;
+/** Text between the observation's <output> tags, or the raw observation when
+ *  the tags are absent. */
+declare function parseObservationOutput(observation: string | null): string;
+/**
+ * Stable failure-signature candidate: the first line of the recorded output
+ * that contains the word "error". Null when no such line exists — a verdict
+ * then falls back to returncode-only matching and says so.
+ * Pass an explicit signature to override (compiler quote glyphs vary with
+ * locale, so a hand-picked ASCII substring is often more robust).
+ */
+declare function deriveFailureSignature(observation: string | null): string | null;
+/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel
+ *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a
+ *  failed command — there is no executable failure to reproduce, so it is
+ *  never a counterfactual replay target. */
+declare const SUBMIT_ACTION_SIGNATURE = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
+declare function isSubmitAction(action: string): boolean;
+/**
+ * True when the action is the sentinel echo and nothing else.
+ *
+ * The distinction decides whether a step may be dropped. An agent is told to
+ * issue the sentinel alone, and 5.7% of recorded runs end on a command that
+ * writes files or edits them and then echoes it. Dropping such a step because
+ * it holds the sentinel would remove the run's last state change from the
+ * replay, so the recorded end state and the replayed one would differ.
+ */
+declare function isSubmitOnlyAction(action: string): boolean;
+/**
+ * A field the dump replaced with a counter instead of its text.
+ *
+ * The counter is hexadecimal and rises by one per dropped string in document
+ * order, so a decimal-only reading (`$12`) accepts every marker that carries a
+ * letter (`$3a`) as if it were real text. A command read that way replays as
+ * the literal two-to-four characters `$3a`, which is not the command the run
+ * executed.
+ *
+ * Nothing in the dump maps a marker back to its text: the same marker carries
+ * different content in different rows, so there is no dictionary to read. A
+ * field that matches is unrecoverable, so a caller rejects the row that holds
+ * it rather than replaying the marker.
+ */
+declare const RECORDED_ELISION_PATTERN: RegExp;
+declare function isElidedField(value: string | null | undefined): boolean;
+/** Substring the timeout notice always carries, whatever the command was. */
+declare const TIMEOUT_OBSERVATION_MARKER = "timed out and has been killed";
+/** Opening of the notice the scaffold writes when a turn held no single action. */
+declare const FORMAT_ERROR_OBSERVATION_PREFIX = "Please always provide EXACTLY ONE action in triple backticks, found ";
+/**
+ * What a recorded observation is.
+ *
+ * `command-result` is the only kind that carries an exit status. `timeout` and
+ * `format-error` are the scaffold speaking rather than a command: the first
+ * says the environment killed the command, the second says no command ran at
+ * all. `elided` and `absent` carry no information about the step, and
+ * `unreadable` is a shape this grammar does not know — never assumed to be
+ * anything.
+ */
+type RecordedObservationKind = 'command-result' | 'timeout' | 'format-error' | 'elided' | 'absent' | 'unreadable';
+declare function classifyObservation(observation: string | null): RecordedObservationKind;
+/** True when the recording shows the environment killed this step at its
+ *  wall-clock bound. Such a step carries no returncode, so no replay can
+ *  confirm or contradict it. */
+declare function isRecordedTimeout(observation: string | null): boolean;
+/**
+ * One turn as the published trajectory dump holds it.
+ *
+ * A turn is not a step: the system prompt, the task statement and every turn
+ * the scaffold rejected are turns that executed nothing.
+ */
+interface RecordedTrajectoryTurn {
+  readonly src?: string | null;
+  readonly msg?: string | null;
+  readonly tools?: readonly {
+    readonly cmd?: string | null;
+  }[] | null;
+  readonly obs?: string | null;
+}
+interface DecodedTrajectory {
+  /** Executed commands in recorded order, each holding its OWN observation. */
+  readonly steps: readonly RecordedTrajectoryStep[];
+  /** Turns the scaffold rejected before anything ran. */
+  readonly formatErrorTurns: number;
+  /**
+   * Executed commands whose text the dump dropped.
+   *
+   * The step stays in `steps` carrying the marker, because the run did execute
+   * a command there and a shorter list would misreport the trajectory. The
+   * marker is not a command, so any count above zero means this trajectory
+   * cannot be replayed: gate on it, or call `assertReplayableTrajectory`.
+   */
+  readonly elidedCommands: number;
+  /** True when the run's last turn was the submit sentinel with no observation. */
+  readonly endedOnSubmitSentinel: boolean;
+  /** Turns carrying an observation this grammar cannot read. */
+  readonly unreadableTurns: number;
+}
+/**
+ * Pair every recorded command with the observation of its own turn.
+ *
+ * Collecting commands and observations into two lists and zipping them is the
+ * decode that looks right and is not: a turn the scaffold rejected carries an
+ * observation of its own, so from the first such turn onward every observation
+ * belongs to a different command than the one it is read against.
+ *
+ * A rejected turn executed nothing, so it is never a step — including when the
+ * dump recorded a command for it. The scaffold rejects a turn holding several
+ * bash blocks and runs none of them, while the dump keeps one of the blocks in
+ * the command field. Replaying that field would execute a command the recorded
+ * run did not, which is a worse corpus than a smaller one.
+ *
+ * A rejected turn is recognised by its observation, so a rejected turn whose
+ * observation the dump elided is indistinguishable from an executed command
+ * whose observation it elided. Both read as a step. Nothing in the dump
+ * separates them, and the row-level defence is the share of unreadable exits a
+ * caller admits: a row with no elided observation cannot hold this case at all.
+ *
+ * A trailing step that echoes the sentinel and nothing else, with no
+ * observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.
+ * The scaffold records an observation only when it hands one to the model, and
+ * the sentinel ends the run, so the missing observation is the end of the
+ * transcript rather than a gap in it. Echoing the sentinel changes no state, so
+ * the recorded end state is the state the step before it left.
+ *
+ * A step that DID get an observation stays a step: the run continued past it.
+ * So does a step that echoes the sentinel after doing real work — its state
+ * change is part of the recorded end state, and with no observation its exit is
+ * unknown, which `finalRecordedOutcome` reports rather than hides.
+ */
+declare function decodeRecordedTurns(turns: readonly RecordedTrajectoryTurn[]): DecodedTrajectory;
+/**
+ * How the recorded run's last executed command ended.
+ *
+ * `killed` is a measured outcome, not a missing one: the environment stopped
+ * the command at its bound and wrote a notice instead of an exit status.
+ * `unreadable` names the observation kind that blocked the read, so a funnel
+ * can report which shape cost it the row.
+ */
+type RecordedFinalOutcome = {
+  readonly kind: 'returncode';
+  readonly value: number;
+} | {
+  readonly kind: 'killed';
+} | {
+  readonly kind: 'unreadable';
+  readonly reason: RecordedObservationKind;
+};
+/**
+ * The outcome of the last step, or `null` when the trajectory has no steps.
+ *
+ * Reads only the last step. `decodeRecordedTurns` has already removed the turns
+ * that executed nothing, so the last step is the last command the run ran.
+ */
+declare function finalRecordedOutcome(steps: readonly RecordedTrajectoryStep[]): RecordedFinalOutcome | null;
+/**
+ * Steps whose recorded exit a replay cannot check.
+ *
+ * A killed step counts: the recording holds no exit status to compare a replay
+ * against, so agreement on it cannot be measured either way.
+ */
+declare function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number;
+/**
+ * Throw unless every recorded command survived the dump.
+ *
+ * A replay executes `steps` verbatim, so one elision marker in an action means
+ * the replay runs the literal two-to-four characters of the marker instead of
+ * the command the run executed. The guard is here so a replayer needs one call
+ * rather than a field check it can forget.
+ */
+declare function assertReplayableTrajectory(decoded: DecodedTrajectory): void;
+//#endregion
+export { isSubmitAction as _, RecordedObservationKind as a, parseRecordedReturncode as b, SUBMIT_ACTION_SIGNATURE as c, classifyObservation as d, decodeRecordedTurns as f, isRecordedTimeout as g, isElidedField as h, RecordedFinalOutcome as i, TIMEOUT_OBSERVATION_MARKER as l, finalRecordedOutcome as m, FORMAT_ERROR_OBSERVATION_PREFIX as n, RecordedTrajectoryStep as o, deriveFailureSignature as p, RECORDED_ELISION_PATTERN as r, RecordedTrajectoryTurn as s, DecodedTrajectory as t, assertReplayableTrajectory as u, isSubmitOnlyAction as v, unreadableExitCount as x, parseObservationOutput as y };
+//# sourceMappingURL=steps-AmkT-GIM.d.ts.map

package/dist/steps-AmkT-GIM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steps-AmkT-GIM.d.ts","names":[],"sources":["../src/trajectory-replay/steps.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;WAEN;WACA;;WAEA;;;iBAIK,wBAAwB;;;iBAQxB,uBAAuB;;;;;;;;iBAavB,uBAAuB;;;;;cAW1B;iBAEG,eAAe;;;;;;;;;;iBAaf,mBAAmB;;;;;;;;;;;;;;;cAsBtB,0BAAwB;iBAErB,cAAc;;cAOjB;;cAGA;;;;;;;;;;;KAaD;iBAQI,oBAAoB,6BAA6B;;;;iBAYjD,kBAAkB;;;;;;;UAYjB;WACN;WACA;WACA;aAA4B;;WAC5B;;UAGM;;WAEN,gBAAgB;;WAEhB;;;;;;;;;WASA;;WAEA;;WAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCK,oBAAoB,gBAAgB,2BAA2B;;;;;;;;;KAyCnE;WACG;WAA6B;;WAC7B;;WACA;WAA6B,QAAQ;;;;;;;;iBAQpC,qBACd,gBAAgB,2BACf;;;;;;;iBAiBa,oBAAoB,gBAAgB;;;;;;;;;iBAYpC,2BAA2B,SAAS"}

package/dist/trace-repair/index.d.ts

@@ -4,19 +4,8 @@ import { b as CustomTokenPricing, c as CostLedgerHandle, p as CostProvenance } f
 import { u as RunTokenUsage } from "../run-record-DVV82Gwh.js";
 import { a as TraceAnalystLimits, n as TraceAnalysisEngine } from "../engine-DJqRKbhs.js";
 import { t as PrimeBridgeTransport } from "../prime-bridge-transport-6feEglLf.js";
-import { t as RecordedTrajectoryStep } from "../steps-BArUxhna.js";
+import { g as isRecordedTimeout, o as RecordedTrajectoryStep } from "../steps-AmkT-GIM.js";
 //#region src/trace-repair/mini-swe-scaffold.d.ts
-/**
- * The mini-swe-agent scaffold as the Terminal-Bench-2 trajectory corpus
- * recorded it: one bash block per turn, one observation per command, and a
- * sentinel command that ends the run.
- *
- * Every template here is byte-verified against
- * `yoonholee/terminalbench-trajectories` (agent = `mini-swe-agent`, 6663 rows,
- * one distinct system prompt across all of them). A continuation that renders
- * different bytes puts the model in a different distribution than the prefix
- * it inherits, so these strings are pinned, not configurable.
- */
 /** Whole-line marker that ends a run. The first output line must equal it and the command must exit 0. */
 declare const SUBMIT_SENTINEL = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
 /** Outputs at or above this length are elided head+tail instead of shown whole. */
@@ -62,15 +51,6 @@ interface CommandOutput {
 declare function renderObservation(output: CommandOutput): string;
 /** The observation after the environment killed a command for exceeding its timeout. */
 declare function renderTimeoutObservation(command: string, partialOutput: string): string;
-/**
- * True when the recording shows the environment killed this step at its
- * wall-clock bound.
- *
- * Such a step carries no returncode, so no replay can confirm or contradict
- * it. Callers use this to bound the replay of that step cheaply rather than to
- * decide agreement.
- */
-declare function isRecordedTimeout(observation: string | null): boolean;
 /** The observation after a turn that did not contain exactly one bash block. */
 declare function renderFormatErrorObservation(actionCount: number): string;
 /**

package/dist/trace-repair/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/trace-repair/mini-swe-scaffold.ts","../../src/trace-repair/action-budget.ts","../../src/trace-repair/continuation-records.ts","../../src/trace-repair/control-policy.ts","../../src/trace-repair/admission-records.ts","../../src/trace-repair/continuation-policy.ts","../../src/trace-repair/oracle-determinism.ts","../../src/trace-repair/admission.ts","../../src/trace-repair/admission-contract.ts","../../src/trace-repair/admission-report.ts","../../src/trace-repair/analyst-response.ts","../../src/trace-repair/blinding.ts","../../src/trace-repair/analyst-arm.ts","../../src/trace-repair/arm-completion.ts","../../src/trace-repair/arm-dspy.ts","../../src/trace-repair/degenerate-strategies.ts","../../src/trace-repair/ports.ts","../../src/trace-repair/funnel.ts","../../src/trace-repair/grade.ts","../../src/trace-repair/delta-repair.ts","../../src/trace-repair/docker-environment.ts","../../src/trace-repair/repair-prompt.ts","../../src/trace-repair/test-oracle.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAaa;;cAGA;;cAGA;cAEA;UAiBI;;EAEf;;;;;EAKA;;;iBAIc,sBAAsB,OAAO;KAiFjC;EACN;EAAgB;;EAChB;EAAsB;;;;;;;iBASZ,YAAY,2BAA2B;UAMtC;EACf;EACA;;EAEA;;;;;;;iBAQc,kBAAkB,QAAQ;;iBAsB1B,yBAAyB,iBAAiB;;;;;;;;;iBAmB1C,kBAAkB;;iBAKlB,6BAA6B;;;;;;iBAyB7B,aAAa,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;KC3MzB;UAEK;;WAEN;;WAEA;;WAEA;;;cAIE,8BAA8B;;;;;;;cAY9B;;;;;;;;;;iBAgCG,gBAAgB;EAAmB;EAAsB;;;;iBA8QzD,sBAAsB,iBAAiB;;;KAM3C;UAQK;EACf;EACA;EACA;;EAEA,SAAS;;EAET,UAAU;;KAGA;WACG;WAA2B,aAAa;;WAExC;WACA,WAAW;WACX;WACA,aAAa;;;;;;;;;;;;;;;iBAqBZ,wBACd,gBACA,cAAc,mBACd,SAAQ,qBACP;;;;;;iBA8Da,6BAA6B;;;;KCtcjC;;UAGK;EACf;EACA;;;KAIU;UAOK;EACf;EACA;;EAEA;EACA;EACA;;UAGe;;EAEf;EACA;EACA;;EAEA,OAAO;;EAEP;EACA;EACA;;UAGe;;EAEf;EACA;;EAEA;;;;;;EAMA;;EAEA,WAAW;EACX,OAAO;;EAEP;;UAGe;;;;;EAKf;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf;EACA;;UAGe;EACf;EACA,KAAK;;EAEL;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA,aAAa;EACb,OAAO;EACP,YAAY;;EAEZ;EACA,OAAO;EACP,gBAAgB;EAChB;EACA;EACA;;EAEA;;;UAIe;EACf;EACA;;;UAIe;EACf;EACA;EACA,OAAO;EACP;;;;;;;;;iBAUc,gBAAgB,mBAAmB,wBAAwB;;iBA+B3D,qBAAqB,SAAS,sBAAsB;;;;;;;;;iBAiBpD,cAAc,SAAS;;;;cCvK1B,iCAAiC;;;;;;;;;;;KAYlC;cAEC,kCAAkC;UAE9B;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;;UAWM;WACN;WACA;;WAEA;;UAGM,sBAAsB,oBAAoB;;;WAGhD;;;;;;WAMA;;;;;;;iBAQK,iBAAiB;iBAIjB,oBAAoB,OAAO,qBAAqB;;;;;;;;;iBAiDhD,wBACd,QAAQ,mBACR,WAAW;;;;cC9HA,kCAAkC;;cAGlC,mCAAmC;;;;;;;;UAW/B;;EAEf;;EAEA;;EAEA;;;;;EAKA;;;;;;EAMA;;cAGW;;;;;;;;iBAeG,yBAAyB,eAAe;;;;;;;;;;;;KAyB5C;cAEC,2BAA2B;;iBAOxB,UAAU,iCAAiC;;;;;;;;KAe/C;cAiBC,oCAAoC;iBAwBjC,mBAAmB,QAAQ;;cAK9B,6BAA6B,SAAS,OAAO;KAsB9C;;UAGK;;EAEf;EACA;;KAGU;EACN;EAAkB,SAAS;;EAE3B;EACA;EACA;EACA;;EAEA;EAAsB;EAAiB;EAAkB;;EACzD;EAA0B;EAAiB;;EAE3C;EACA,KAAK;EACL;EACA;EACA,YAAY;;;UAID;EACf,KAAK;EACL;EACA;EACA;EACA,YAAY;EACZ;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;;EAEA,SAAS;;;;;EAKT;EACA,kBAAkB;;;EAGlB;EACA;;EAEA,YAAY;;EAEZ;;EAEA,QAAQ;EACR,UAAU;;UAKK;EACf,QAAQ;EACR;EACA;EACA;;UAGe;;EAEf,eAAe;EACf;EACA,QAAQ;EACR;;UAGe;EACf;EACA,SAAS;EACT,WAAW;EACX,cAAc,OAAO;;EAErB;;EAEA,sBAAsB;;;;;;;;;iBAUR,sBACd,mBAAmB,uBACnB,sBAAsB,qBACrB;;iBAsDa,sBAAsB,UAAU;;;;cC7SnC,yCAAyC;;cAGzC,kCAAkC;UAE9B;;WAEN;;WAEA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;;WAEA;WACA;;;;;;;;;cAUE;WACP;WACQ;WACC;WACF;WACY;WACK;WACf;WACH;;UAGK,sCACP,QAAQ,KAAK;;EAErB;;EAEA;;iBAGc,+BACd,OAAO,gCACN;;;;;;iBA+Ba,yBAAyB,QAAQ;;;;;iBAejC,iBAAiB,oBAAoB,eAAe;UAUnD;EACf;EACA,UAAU;EACV;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA,OAAO;;EAEP;EACA;;KAGU,qBACV,SAAS,6BACN,QAAQ;UAEI;EACf;EACA;;EAEA;;EAEA;;UAGe;;EAEf;EACA,YAAY,QAAQ;EACpB,KAAK,iBAAiB;IAAW;MAA2B,QAAQ;EACpE,WAAW;;UAGI;EACf;EACA,KAAK;EACL;;UAGe;EACf;;;;;;EAMA,OAAO,SAAS,iCAAiC,QAAQ;;UAG1C;EACf,QAAQ;EACR,KAAK;;EAEL;;;;;;EAMA,iBAAiB;;EAEjB;EACA,OAAO;EACP,cAAc;;EAEd;;;;;;;;;iBAUoB,gBACpB,SAAS,yBACR,QAAQ;;;;;;iBAiOK,WAAW,gBAAgB,2BAA2B;;;;;iBA8CtD,UAAU,gBAAgB,2BAA2B;;;;;;iBAerD,kBAAkB,mBAAmB;;;;cCnexC,oCAAoC;;;KAIrC;;KAGA;;cAGC;UAEI;;WAEN;WACA;;UAGM;;WAEN;;;;;;WAMA;WACA;WACA;;;WAGA,qBAAqB;;UAGf;WACN,OAAO;WACP,MAAM;;;;;WAKN,qBAAqB;;UAGf;WACN;;;;WAIA;;;;;;;WAOA;WACA,iBAAiB;WACjB;;;UAIM;;WAEN;WACA;WACA;WACA;;UAGM;WACN,OAAO;WACP;;WAEA;WACA;;WAEA;;WAEA;WACA,kBAAkB;;;WAGlB;;WAEA;;WAEA;;UAGM;WACN;WACA;WACA;;WAEA;WACA;;WAEA;WACA,kBAAkB;WAClB;;WAEA;;;cAIE;;;;;;;;iBASG,kBAAkB,UAAU,4BAA4B;;;;;;;;KA+H5D,qBAAqB,oBAAoB;;;;;;;;;UAUpC;WACN;WACA,uBAAuB;;iBAGlB,wBAAwB,oBAAoB;iBAc5C,mBACd,mBAAmB,6BAClB;;iBAca,0BAA0B,SAAS;;;;;;;KC3PvC,iBAAiB;EACvB;EAAiB,OAAO;;EACxB;EAAkB;;UAEP;;EAEf;EACA;EACA;;UAGe;;EAEf;;EAEA,4BAA4B;;UAGb;;EAEf;;EAEA,OAAO,KAAK,eAAe,QAAQ,iBAAiB;;UAGrC;EACf;;EAEA;;UAGe;EACf;;EAEA,MAAM,KAAK,eAAe,QAAQ,iBAAiB;;UAGpC;EACf,KAAK;EACL,KAAK;;EAEL;;EAEA,WAAW;;UAGI;;EAEf,OAAO;;EAEP,SAAS;;UAGM;EACf;;;;;EAKA,IAAI,SAAS,0BAA0B,QAAQ,iBAAiB;;UAKjD;;EAEf;;EAEA;;;;;;EAMA,uBAAuB;;EAEvB;;;;;EAKA,mBAAmB;;EAEnB;;UAGe;WACN;WACA;WACA,sBAAsB;WACtB;WACA,kBAAkB;WAClB;;cAGE,2BAA2B;iBASxB,uBAAuB,QAAO,uBAA4B;;;;;;;iBA6C1D,kBACd,oBACA,eACA,sBACA;UAce;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;EAGA;EACA,kBAAkB;;;EAGlB,gBAAgB,SAAS;;UAGV;EACf,QAAQ;EACR,YAAY;;EAEZ,eAAe;;EAEf,QAAQ,SAAS,OAAO;EACxB,OAAO;;EAEP,aAAa;;EAEb;EACA;;UAGe;EACf,eAAe;;EAEf,QAAQ;EACR,UAAU;EACV,QAAQ;EACR,UAAU;;;;;;;EAOV,aAAa;EACb,SAAS;;EAET;;;;;;;;;iBAUoB,aAAa,SAAS,sBAAsB,QAAQ;;iBAoV1D,eACd,QAAQ,iBACR,SAAS;iBAKK,cAAc,QAAQ;UAIrB;EACf,QAAQ;;EAER,iBAAiB;;EAEjB;;EAEA;;;;;;;;;;;iBAYc,wBAAwB,OAAO;;;;UC3mB9B;;;;WAIN;;WAEA;;WAEA,kBAAkB;;cAGhB,8BAA8B;UAM1B;;WAEN;;WAEA;;UAGM;WACN;;WAEA;;;WAGA;;UAGM;WACN;;;WAGA;;WAEA;;WAEA;;WAEA;WACA,gBAAgB;;;;;;WAMhB,mBAAmB;;WAEnB,eAAe;WACf,gBAAgB;;WAEhB;;WAEA;WACA,cAAc;WACd,aAAa;;;KAIZ;cAWE;;;;;;;;;;UAWG;YACL;WACD;WACA;WACA;WACA;WACA;WACA,gBAAgB;WAChB,UAAU;WACV;WACA;;;WAGA,eAAe;WACf,kBAAkB;;;WAGlB;;;WAGA;WACA;;;;UAKM;WACN,eAAe;WACf,kBAAkB;WAClB;WACA;WACA;WACA;;KAGC;WAEG;WACA,WAAW;WACX,KAAK;;WAGL;WACA;WACA,WAAW;WACX,WAAW;WACX;;;;;;;;;;;;;;iBAeC,SACd,UAAU,mBACV,WAAU,oBACT;;;UC7Kc;EACf;EACA;EACA;;EAEA;EACA,QAAQ;EACR,YAAY;EACZ,OAAO;;EAEP,UAAU,OAAO;EACjB;IAAe;IAAc;;;EAE7B,eAAe;;;iBAID,kBAAkB,QAAQ,kBAAkB;UAoB3C;;EAEf;;;iBAIc,sBACd,UAAU,mBACV,UAAS;;;;cChDE;UAEI;;WAEN,MAAM;;WAEN;;UAGM;WACN;;;WAGA;;;WAGA;WACA,cAAc;;UAGR;WACN;;KAGC,kBAAkB,gBAAgB;;KAGlC;KAQA;WACG;WAA0B,OAAO;;WACjC;WAA2B,SAAS;WAA+B;;;;;;;;;iBASlE,qBAAqB,gBAAgB;;iBAoFrC,cAAc;EAC5B;EACA;EACA,cAAc;IACZ;;;UCpIa;WACN;WACA;WACA;;UAGM;WACN;;WAEA;WACA,gBAAgB;;;WAGhB;;WAEA;;UAGM;;;WAGN;;iBAGK,gBACd,KAAK,aACL,UAAS,yBACR;;;;;cAyBU;;;;;;;;;;;KCtBD;;;;;;;;;;;;;;;;;;KAmBA;WACG;WAAuB;;WAEvB;;WAEA;;WAEA;;WAEA;;UAGE;WACN;;;WAGA;WACA,eAAe;;WAEf,QAAQ;;WAER;WACA,sBAAsB;;;;;WAKtB;;;;;UAMM;WACN,QAAQ;WACR,SAAS;;;;UAKH;WACN;WACA;WACA;WACA;;UAGM;WACN;;WAEA;;;UAIM;WACN;WACA;;;;;;;;;;KAWC;WAEG;WACA;WACA;WACA,cAAc;WACd;WACA;WACA,uBAAuB;WACvB,QAAQ;WACR,OAAO;;WAGP;WACA;WACA;WACA,uBAAuB;WACvB,QAAQ;WACR,OAAO;;WAGP;WACA;WACA;WACA,uBAAuB;WACvB,QAAQ;WACR,OAAO;;UAGL;WACN,aAAa;EACtB,IAAI,SAAS,mBAAmB,QAAQ;;;;;;;;;;KAW9B;WACG;WAA2B,aAAa;;WAExC;WACA,WAAW;WACX;WACA,aAAa;;UAGX;WACN;WACA;;WAEA;WACA,OAAO;;WAEP,QAAQ;WACR;;UAGM;WACN,KAAK;WACL,KAAK;;WAEL;WACA,SAAS;;WAET;;;;;;;;iBASW,aAAa,SAAS,sBAAsB,QAAQ;;;;;;;;iBAuC1D,kBAAkB,QAAQ,kBAAkB;;UAc3C;WACN;;WAEA,2BAA2B;;WAE3B,6BAA6B;WAC7B,eAAe;;;;WAIf;;UAGM;WACN;;;WAGA,4BAA4B;WAC5B,sBAAsB;;;WAGtB;WACA,QAAQ;WACR;;;WAGA;;;;;;;;;;;;;;;iBAgBK,qBACd,eAAe,aACf;WAAoB,SAAS;IAC5B;;;UCpQc;WACN;;WAEA;;WAEA;WACA;;WAEA,WAAW;;WAEX;;WAEA,SAAS;WACT,SAAS;;WAET,sBAAsB;WACtB,eAAe;;iBAGV,0BAA0B,SAAS,6BAA6B;;;;;;;;;;cChBnE;;cAGA;;cAGA;;;;;;;;;iBAUG,uBACd,SAAQ;UAqBO;;WAEN,QAAQ;WACR,QAAQ;WACR,YAAY;WACZ;WACA;WACA,WAAW;WACX,SAAS;WACT;WACA,OAAO,iBAAiB,SAAS;;iBAG5B,oBAAoB,SAAS,uBAAuB;UA8H1D;WACC;WACA;WACA,MAAM;WACN;;UAGD;WACC;WACA;WACA,eAAe;WACf,kBAAkB;;;WAGlB;;;;WAIA;;KAGN;WACU;WAAmB,OAAO;;WAC1B;WAAoB;;UAElB;;;;;WAKN;;;;;;;;;;;;iBAaK,kBACd,SAAS,yBACT,SAAS,2BACR;;iBA6Ia,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;KCrZnC;UAEK;WACN;;WAEA;;WAEA;WACA,YAAY;;WAEZ;;cAGE;WAEL;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;KAIJ,+BAA+B;iBAE3B,mBAAmB,IAAI,uBAAuB;;;;;;;;KCnFlD;UAQK;EACf;EACA;EACA;;EAEA;;UAGe;;WAEN;EACT,KAAK,iBAAiB,oBAAoB,QAAQ;EAClD,SAAS;;UAGM;EACf;;;EAGA;EACA,KAAK;;EAEL;;UAGe;;EAEf,KAAK,SAAS,uBAAuB,QAAQ;;UAG9B;EACf;EACA,KAAK;EACL;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;;;;;;;;;;UAWe;EACf,MAAM,SAAS,eAAe,SAAS,oBAAoB,QAAQ;;UAGpD;EACf;EACA,KAAK;EACL;;EAEA,SAAS;;EAET,gBAAgB;;;EAGhB;;;;;;;EAOA,UAAU;EACV;;UAGe;EACf;EACA;EACA;EACA;;UAGe;;EAEf;;;EAGA;;EAEA;;EAEA;EACA;;;KAIU,4BACV,SAAS,8BACN,QAAQ;;;;KCtGD;WACG;WAA0B,QAAQ;WAA+B;;WAEjE;WACA,QAAQ;WACR;WACA,aAAa;;WAGb;WACA;WACA;;UAGE;;WAEN;;WAEA;WACA;;;;;;;;;KAUC;;;WAIG;WACA;;WAGA;WACA;WACA;WACA;WACA;WACA;WACA,QAAQ;;UAGN;WACN;WACA;WACA;WACA;WACA;WACA,QAAQ;;UAGF;WACN;WACA;WACA;;WAEA;;;;;;;;;;KAWC;WAEG;WACA;WACA;WACA,cAAc;WACd,OAAO;;WAGP;WACA;WACA;WACA;;UAGE;;WAEN;;WAEA;;WAEA;;;WAGA;WACA,0BAA0B;;;;;;;;KASzB;WACG;WAA8B,WAAW;;WACzC;;WAEA;WACA;WACA,cAAc;;WAGd;WACA;WACA,cAAc;WACd,WAAW;;WAGX;WACA;WACA,cAAc;WACd,WAAW;WACX,WAAW;WACX,QAAQ;;;;;;;;;;UAWN;WACN;WACA;;WAEA;;cAaE;;iBASG,aAAa,OAAO,cAAc;;;iBAWlC,UAAU,OAAO;;;iBAMjB,UAAU,OAAO;;iBAKjB,UAAU,OAAO;UAIhB;WACN;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;;WAEA;;iBAGK,YAAY,iBAAiB,gBAAgB;;;;cC3KhD,+BAA+B;UAE3B;WACN,KAAK;WACL,UAAU;WACV,UAAU;WACV,QAAQ;WACR,cAAc;;;WAGd;WACA,SAAS;;WAET;;;;;;;;WAQA;WACA,cAAc;;;;;;;;;;UAWR,wBAAwB;WAC9B;WACA,OAAO;WACP,QAAQ;;;WAGR;WACA;WACA;;;WAGA,kBAAkB;WAClB;WACA;;WAEA;WACA;;iBAMW,eAAe,SAAS,qBAAqB,QAAQ;;;UCvF1D;;WAEN;WACA;WACA;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;WACA;;;WAGA;;KAGC;UAUK;WACN,IAAI;WACJ;;WAEA;;UAGM;WACN;WACA,QAAQ;;WAER;WACA;WACA,aAAa;;;;WAIb,cAAc;WACd;WACA,qBAAqB;WACrB,kBAAkB;;iBAGb,YACd,qBAAqB,mBACrB,UAAS,qBACR;;;iBAwKa,wBAAwB,QAAQ;;;UCtO/B;EACf;;EAEA;;UAGe;;EAEf;EACA;;EAEA;;;KAIU,iBAAiB,SAAS,mBAAmB,QAAQ;;;;;;cAOpD,mBAAmB;UAuDf;;EAEf;;EAEA;;EAEA,MAAM;;EAEN;;EAEA;EACA,YAAY;;EAEZ;;;;;;;;iBAqBc,cAAc;EAC5B;EACA;EACA;EACA;EACA;;iBAmBc,oCACd,SAAS,uCACR;;;cCxIU;;;;;iBAOG,iBACd,SAAQ;;cAkBG;;;cAgBA;;iBASG,uBAAuB,QAAQ;iBAc/B,uBAAuB,QAAQ;;;iBAM/B,qBACd,QAAQ,yBACR,SAAQ;;;;;;;;;iBAkBM,qBACd,SAAQ;;;;;;;;;iBAsBM,sBACd,QAAQ,oBACR;;;;cC7GW,+BAA+B;;cAG/B,wBAAwB;UAEpB;;WAEN;WACA;;WAEA;;UAGM;;WAEN,gBAAgB;;WAEhB;;;WAGA;WACA;WACA;;;;;;iBAUK,gBAAgB,gBAAgB;iBAWhC,mBAAmB,SAAS,4BAA4B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/trace-repair/mini-swe-scaffold.ts","../../src/trace-repair/action-budget.ts","../../src/trace-repair/continuation-records.ts","../../src/trace-repair/control-policy.ts","../../src/trace-repair/admission-records.ts","../../src/trace-repair/continuation-policy.ts","../../src/trace-repair/oracle-determinism.ts","../../src/trace-repair/admission.ts","../../src/trace-repair/admission-contract.ts","../../src/trace-repair/admission-report.ts","../../src/trace-repair/analyst-response.ts","../../src/trace-repair/blinding.ts","../../src/trace-repair/analyst-arm.ts","../../src/trace-repair/arm-completion.ts","../../src/trace-repair/arm-dspy.ts","../../src/trace-repair/degenerate-strategies.ts","../../src/trace-repair/ports.ts","../../src/trace-repair/funnel.ts","../../src/trace-repair/grade.ts","../../src/trace-repair/delta-repair.ts","../../src/trace-repair/docker-environment.ts","../../src/trace-repair/repair-prompt.ts","../../src/trace-repair/test-oracle.ts"],"mappings":";;;;;;;;;cAyBa;;cAGA;;cAGA;cAEA;UAiBI;;EAEf;;;;;EAKA;;;iBAIc,sBAAsB,OAAO;KAiFjC;EACN;EAAgB;;EAChB;EAAsB;;;;;;;iBASZ,YAAY,2BAA2B;UAMtC;EACf;EACA;;EAEA;;;;;;;iBAQc,kBAAkB,QAAQ;;iBAsB1B,yBAAyB,iBAAiB;;iBAS1C,6BAA6B;;;;;;iBAyB7B,aAAa,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;KCxMzB;UAEK;;WAEN;;WAEA;;WAEA;;;cAIE,8BAA8B;;;;;;;cAY9B;;;;;;;;;;iBAgCG,gBAAgB;EAAmB;EAAsB;;;;iBA8QzD,sBAAsB,iBAAiB;;;KAM3C;UAQK;EACf;EACA;EACA;;EAEA,SAAS;;EAET,UAAU;;KAGA;WACG;WAA2B,aAAa;;WAExC;WACA,WAAW;WACX;WACA,aAAa;;;;;;;;;;;;;;;iBAqBZ,wBACd,gBACA,cAAc,mBACd,SAAQ,qBACP;;;;;;iBA8Da,6BAA6B;;;;KCtcjC;;UAGK;EACf;EACA;;;KAIU;UAOK;EACf;EACA;;EAEA;EACA;EACA;;UAGe;;EAEf;EACA;EACA;;EAEA,OAAO;;EAEP;EACA;EACA;;UAGe;;EAEf;EACA;;EAEA;;;;;;EAMA;;EAEA,WAAW;EACX,OAAO;;EAEP;;UAGe;;;;;EAKf;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf;EACA;;UAGe;EACf;EACA,KAAK;;EAEL;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA,aAAa;EACb,OAAO;EACP,YAAY;;EAEZ;EACA,OAAO;EACP,gBAAgB;EAChB;EACA;EACA;;EAEA;;;UAIe;EACf;EACA;;;UAIe;EACf;EACA;EACA,OAAO;EACP;;;;;;;;;iBAUc,gBAAgB,mBAAmB,wBAAwB;;iBA+B3D,qBAAqB,SAAS,sBAAsB;;;;;;;;;iBAiBpD,cAAc,SAAS;;;;cCvK1B,iCAAiC;;;;;;;;;;;KAYlC;cAEC,kCAAkC;UAE9B;;WAEN;;WAEA;;WAEA;;WAEA;;WAEA;;;;;;;;;;UAWM;WACN;WACA;;WAEA;;UAGM,sBAAsB,oBAAoB;;;WAGhD;;;;;;WAMA;;;;;;;iBAQK,iBAAiB;iBAIjB,oBAAoB,OAAO,qBAAqB;;;;;;;;;iBAiDhD,wBACd,QAAQ,mBACR,WAAW;;;;cC9HA,kCAAkC;;cAGlC,mCAAmC;;;;;;;;UAW/B;;EAEf;;EAEA;;EAEA;;;;;EAKA;;;;;;EAMA;;cAGW;;;;;;;;iBAeG,yBAAyB,eAAe;;;;;;;;;;;;KAyB5C;cAEC,2BAA2B;;iBAOxB,UAAU,iCAAiC;;;;;;;;KAe/C;cAiBC,oCAAoC;iBAwBjC,mBAAmB,QAAQ;;cAK9B,6BAA6B,SAAS,OAAO;KAsB9C;;UAGK;;EAEf;EACA;;KAGU;EACN;EAAkB,SAAS;;EAE3B;EACA;EACA;EACA;;EAEA;EAAsB;EAAiB;EAAkB;;EACzD;EAA0B;EAAiB;;EAE3C;EACA,KAAK;EACL;EACA;EACA,YAAY;;;UAID;EACf,KAAK;EACL;EACA;EACA;EACA,YAAY;EACZ;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;;EAEA,SAAS;;;;;EAKT;EACA,kBAAkB;;;EAGlB;EACA;;EAEA,YAAY;;EAEZ;;EAEA,QAAQ;EACR,UAAU;;UAKK;EACf,QAAQ;EACR;EACA;EACA;;UAGe;;EAEf,eAAe;EACf;EACA,QAAQ;EACR;;UAGe;EACf;EACA,SAAS;EACT,WAAW;EACX,cAAc,OAAO;;EAErB;;EAEA,sBAAsB;;;;;;;;;iBAUR,sBACd,mBAAmB,uBACnB,sBAAsB,qBACrB;;iBAsDa,sBAAsB,UAAU;;;;cC7SnC,yCAAyC;;cAGzC,kCAAkC;UAE9B;;WAEN;;WAEA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;;WAEA;WACA;;;;;;;;;cAUE;WACP;WACQ;WACC;WACF;WACY;WACK;WACf;WACH;;UAGK,sCACP,QAAQ,KAAK;;EAErB;;EAEA;;iBAGc,+BACd,OAAO,gCACN;;;;;;iBA+Ba,yBAAyB,QAAQ;;;;;iBAejC,iBAAiB,oBAAoB,eAAe;UAUnD;EACf;EACA,UAAU;EACV;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA,OAAO;;EAEP;EACA;;KAGU,qBACV,SAAS,6BACN,QAAQ;UAEI;EACf;EACA;;EAEA;;EAEA;;UAGe;;EAEf;EACA,YAAY,QAAQ;EACpB,KAAK,iBAAiB;IAAW;MAA2B,QAAQ;EACpE,WAAW;;UAGI;EACf;EACA,KAAK;EACL;;UAGe;EACf;;;;;;EAMA,OAAO,SAAS,iCAAiC,QAAQ;;UAG1C;EACf,QAAQ;EACR,KAAK;;EAEL;;;;;;EAMA,iBAAiB;;EAEjB;EACA,OAAO;EACP,cAAc;;EAEd;;;;;;;;;iBAUoB,gBACpB,SAAS,yBACR,QAAQ;;;;;;iBAiOK,WAAW,gBAAgB,2BAA2B;;;;;iBA8CtD,UAAU,gBAAgB,2BAA2B;;;;;;iBAerD,kBAAkB,mBAAmB;;;;cCnexC,oCAAoC;;;KAIrC;;KAGA;;cAGC;UAEI;;WAEN;WACA;;UAGM;;WAEN;;;;;;WAMA;WACA;WACA;;;WAGA,qBAAqB;;UAGf;WACN,OAAO;WACP,MAAM;;;;;WAKN,qBAAqB;;UAGf;WACN;;;;WAIA;;;;;;;WAOA;WACA,iBAAiB;WACjB;;;UAIM;;WAEN;WACA;WACA;WACA;;UAGM;WACN,OAAO;WACP;;WAEA;WACA;;WAEA;;WAEA;WACA,kBAAkB;;;WAGlB;;WAEA;;WAEA;;UAGM;WACN;WACA;WACA;;WAEA;WACA;;WAEA;WACA,kBAAkB;WAClB;;WAEA;;;cAIE;;;;;;;;iBASG,kBAAkB,UAAU,4BAA4B;;;;;;;;KA+H5D,qBAAqB,oBAAoB;;;;;;;;;UAUpC;WACN;WACA,uBAAuB;;iBAGlB,wBAAwB,oBAAoB;iBAc5C,mBACd,mBAAmB,6BAClB;;iBAca,0BAA0B,SAAS;;;;;;;KC3PvC,iBAAiB;EACvB;EAAiB,OAAO;;EACxB;EAAkB;;UAEP;;EAEf;EACA;EACA;;UAGe;;EAEf;;EAEA,4BAA4B;;UAGb;;EAEf;;EAEA,OAAO,KAAK,eAAe,QAAQ,iBAAiB;;UAGrC;EACf;;EAEA;;UAGe;EACf;;EAEA,MAAM,KAAK,eAAe,QAAQ,iBAAiB;;UAGpC;EACf,KAAK;EACL,KAAK;;EAEL;;EAEA,WAAW;;UAGI;;EAEf,OAAO;;EAEP,SAAS;;UAGM;EACf;;;;;EAKA,IAAI,SAAS,0BAA0B,QAAQ,iBAAiB;;UAKjD;;EAEf;;EAEA;;;;;;EAMA,uBAAuB;;EAEvB;;;;;EAKA,mBAAmB;;EAEnB;;UAGe;WACN;WACA;WACA,sBAAsB;WACtB;WACA,kBAAkB;WAClB;;cAGE,2BAA2B;iBASxB,uBAAuB,QAAO,uBAA4B;;;;;;;iBA6C1D,kBACd,oBACA,eACA,sBACA;UAce;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;EAGA;EACA,kBAAkB;;;EAGlB,gBAAgB,SAAS;;UAGV;EACf,QAAQ;EACR,YAAY;;EAEZ,eAAe;;EAEf,QAAQ,SAAS,OAAO;EACxB,OAAO;;EAEP,aAAa;;EAEb;EACA;;UAGe;EACf,eAAe;;EAEf,QAAQ;EACR,UAAU;EACV,QAAQ;EACR,UAAU;;;;;;;EAOV,aAAa;EACb,SAAS;;EAET;;;;;;;;;iBAUoB,aAAa,SAAS,sBAAsB,QAAQ;;iBAoV1D,eACd,QAAQ,iBACR,SAAS;iBAKK,cAAc,QAAQ;UAIrB;EACf,QAAQ;;EAER,iBAAiB;;EAEjB;;EAEA;;;;;;;;;;;iBAYc,wBAAwB,OAAO;;;;UC3mB9B;;;;WAIN;;WAEA;;WAEA,kBAAkB;;cAGhB,8BAA8B;UAM1B;;WAEN;;WAEA;;UAGM;WACN;;WAEA;;;WAGA;;UAGM;WACN;;;WAGA;;WAEA;;WAEA;;WAEA;WACA,gBAAgB;;;;;;WAMhB,mBAAmB;;WAEnB,eAAe;WACf,gBAAgB;;WAEhB;;WAEA;WACA,cAAc;WACd,aAAa;;;KAIZ;cAWE;;;;;;;;;;UAWG;YACL;WACD;WACA;WACA;WACA;WACA;WACA,gBAAgB;WAChB,UAAU;WACV;WACA;;;WAGA,eAAe;WACf,kBAAkB;;;WAGlB;;;WAGA;WACA;;;;UAKM;WACN,eAAe;WACf,kBAAkB;WAClB;WACA;WACA;WACA;;KAGC;WAEG;WACA,WAAW;WACX,KAAK;;WAGL;WACA;WACA,WAAW;WACX,WAAW;WACX;;;;;;;;;;;;;;iBAeC,SACd,UAAU,mBACV,WAAU,oBACT;;;UC7Kc;EACf;EACA;EACA;;EAEA;EACA,QAAQ;EACR,YAAY;EACZ,OAAO;;EAEP,UAAU,OAAO;EACjB;IAAe;IAAc;;;EAE7B,eAAe;;;iBAID,kBAAkB,QAAQ,kBAAkB;UAoB3C;;EAEf;;;iBAIc,sBACd,UAAU,mBACV,UAAS;;;;cChDE;UAEI;;WAEN,MAAM;;WAEN;;UAGM;WACN;;;WAGA;;;WAGA;WACA,cAAc;;UAGR;WACN;;KAGC,kBAAkB,gBAAgB;;KAGlC;KAQA;WACG;WAA0B,OAAO;;WACjC;WAA2B,SAAS;WAA+B;;;;;;;;;iBASlE,qBAAqB,gBAAgB;;iBAoFrC,cAAc;EAC5B;EACA;EACA,cAAc;IACZ;;;UCpIa;WACN;WACA;WACA;;UAGM;WACN;;WAEA;WACA,gBAAgB;;;WAGhB;;WAEA;;UAGM;;;WAGN;;iBAGK,gBACd,KAAK,aACL,UAAS,yBACR;;;;;cAyBU;;;;;;;;;;;KCtBD;;;;;;;;;;;;;;;;;;KAmBA;WACG;WAAuB;;WAEvB;;WAEA;;WAEA;;WAEA;;UAGE;WACN;;;WAGA;WACA,eAAe;;WAEf,QAAQ;;WAER;WACA,sBAAsB;;;;;WAKtB;;;;;UAMM;WACN,QAAQ;WACR,SAAS;;;;UAKH;WACN;WACA;WACA;WACA;;UAGM;WACN;;WAEA;;;UAIM;WACN;WACA;;;;;;;;;;KAWC;WAEG;WACA;WACA;WACA,cAAc;WACd;WACA;WACA,uBAAuB;WACvB,QAAQ;WACR,OAAO;;WAGP;WACA;WACA;WACA,uBAAuB;WACvB,QAAQ;WACR,OAAO;;WAGP;WACA;WACA;WACA,uBAAuB;WACvB,QAAQ;WACR,OAAO;;UAGL;WACN,aAAa;EACtB,IAAI,SAAS,mBAAmB,QAAQ;;;;;;;;;;KAW9B;WACG;WAA2B,aAAa;;WAExC;WACA,WAAW;WACX;WACA,aAAa;;UAGX;WACN;WACA;;WAEA;WACA,OAAO;;WAEP,QAAQ;WACR;;UAGM;WACN,KAAK;WACL,KAAK;;WAEL;WACA,SAAS;;WAET;;;;;;;;iBASW,aAAa,SAAS,sBAAsB,QAAQ;;;;;;;;iBAuC1D,kBAAkB,QAAQ,kBAAkB;;UAc3C;WACN;;WAEA,2BAA2B;;WAE3B,6BAA6B;WAC7B,eAAe;;;;WAIf;;UAGM;WACN;;;WAGA,4BAA4B;WAC5B,sBAAsB;;;WAGtB;WACA,QAAQ;WACR;;;WAGA;;;;;;;;;;;;;;;iBAgBK,qBACd,eAAe,aACf;WAAoB,SAAS;IAC5B;;;UCpQc;WACN;;WAEA;;WAEA;WACA;;WAEA,WAAW;;WAEX;;WAEA,SAAS;WACT,SAAS;;WAET,sBAAsB;WACtB,eAAe;;iBAGV,0BAA0B,SAAS,6BAA6B;;;;;;;;;;cChBnE;;cAGA;;cAGA;;;;;;;;;iBAUG,uBACd,SAAQ;UAqBO;;WAEN,QAAQ;WACR,QAAQ;WACR,YAAY;WACZ;WACA;WACA,WAAW;WACX,SAAS;WACT;WACA,OAAO,iBAAiB,SAAS;;iBAG5B,oBAAoB,SAAS,uBAAuB;UA8H1D;WACC;WACA;WACA,MAAM;WACN;;UAGD;WACC;WACA;WACA,eAAe;WACf,kBAAkB;;;WAGlB;;;;WAIA;;KAGN;WACU;WAAmB,OAAO;;WAC1B;WAAoB;;UAElB;;;;;WAKN;;;;;;;;;;;;iBAaK,kBACd,SAAS,yBACT,SAAS,2BACR;;iBA6Ia,uBAAuB,QAAQ;;;;;;;;;;;;;;;;;KCrZnC;UAEK;WACN;;WAEA;;WAEA;WACA,YAAY;;WAEZ;;cAGE;WAEL;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;WAGR;WAEF;WAEA;WACU;WACA;;KAIJ,+BAA+B;iBAE3B,mBAAmB,IAAI,uBAAuB;;;;;;;;KCnFlD;UAQK;EACf;EACA;EACA;;EAEA;;UAGe;;WAEN;EACT,KAAK,iBAAiB,oBAAoB,QAAQ;EAClD,SAAS;;UAGM;EACf;;;EAGA;EACA,KAAK;;EAEL;;UAGe;;EAEf,KAAK,SAAS,uBAAuB,QAAQ;;UAG9B;EACf;EACA,KAAK;EACL;;UAGe;;EAEf;EACA;EACA;;EAEA;EACA;;;;;;;;;;UAWe;EACf,MAAM,SAAS,eAAe,SAAS,oBAAoB,QAAQ;;UAGpD;EACf;EACA,KAAK;EACL;;EAEA,SAAS;;EAET,gBAAgB;;;EAGhB;;;;;;;EAOA,UAAU;EACV;;UAGe;EACf;EACA;EACA;EACA;;UAGe;;EAEf;;;EAGA;;EAEA;;EAEA;EACA;;;KAIU,4BACV,SAAS,8BACN,QAAQ;;;;KCtGD;WACG;WAA0B,QAAQ;WAA+B;;WAEjE;WACA,QAAQ;WACR;WACA,aAAa;;WAGb;WACA;WACA;;UAGE;;WAEN;;WAEA;WACA;;;;;;;;;KAUC;;;WAIG;WACA;;WAGA;WACA;WACA;WACA;WACA;WACA;WACA,QAAQ;;UAGN;WACN;WACA;WACA;WACA;WACA;WACA,QAAQ;;UAGF;WACN;WACA;WACA;;WAEA;;;;;;;;;;KAWC;WAEG;WACA;WACA;WACA,cAAc;WACd,OAAO;;WAGP;WACA;WACA;WACA;;UAGE;;WAEN;;WAEA;;WAEA;;;WAGA;WACA,0BAA0B;;;;;;;;KASzB;WACG;WAA8B,WAAW;;WACzC;;WAEA;WACA;WACA,cAAc;;WAGd;WACA;WACA,cAAc;WACd,WAAW;;WAGX;WACA;WACA,cAAc;WACd,WAAW;WACX,WAAW;WACX,QAAQ;;;;;;;;;;UAWN;WACN;WACA;;WAEA;;cAaE;;iBASG,aAAa,OAAO,cAAc;;;iBAWlC,UAAU,OAAO;;;iBAMjB,UAAU,OAAO;;iBAKjB,UAAU,OAAO;UAIhB;WACN;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;;WAEA;;iBAGK,YAAY,iBAAiB,gBAAgB;;;;cC3KhD,+BAA+B;UAE3B;WACN,KAAK;WACL,UAAU;WACV,UAAU;WACV,QAAQ;WACR,cAAc;;;WAGd;WACA,SAAS;;WAET;;;;;;;;WAQA;WACA,cAAc;;;;;;;;;;UAWR,wBAAwB;WAC9B;WACA,OAAO;WACP,QAAQ;;;WAGR;WACA;WACA;;;WAGA,kBAAkB;WAClB;WACA;;WAEA;WACA;;iBAMW,eAAe,SAAS,qBAAqB,QAAQ;;;UCvF1D;;WAEN;WACA;WACA;;UAGM;WACN;WACA;WACA;WACA;WACA;WACA;WACA;;;WAGA;;KAGC;UAUK;WACN,IAAI;WACJ;;WAEA;;UAGM;WACN;WACA,QAAQ;;WAER;WACA;WACA,aAAa;;;;WAIb,cAAc;WACd;WACA,qBAAqB;WACrB,kBAAkB;;iBAGb,YACd,qBAAqB,mBACrB,UAAS,qBACR;;;iBAwKa,wBAAwB,QAAQ;;;UCtO/B;EACf;;EAEA;;UAGe;;EAEf;EACA;;EAEA;;;KAIU,iBAAiB,SAAS,mBAAmB,QAAQ;;;;;;cAOpD,mBAAmB;UAuDf;;EAEf;;EAEA;;EAEA,MAAM;;EAEN;;EAEA;EACA,YAAY;;EAEZ;;;;;;;;iBAqBc,cAAc;EAC5B;EACA;EACA;EACA;EACA;;iBAmBc,oCACd,SAAS,uCACR;;;cCxIU;;;;;iBAOG,iBACd,SAAQ;;cAkBG;;;cAgBA;;iBASG,uBAAuB,QAAQ;iBAc/B,uBAAuB,QAAQ;;;iBAM/B,qBACd,QAAQ,yBACR,SAAQ;;;;;;;;;iBAkBM,qBACd,SAAQ;;;;;;;;;iBAsBM,sBACd,QAAQ,oBACR;;;;cC7GW,+BAA+B;;cAG/B,wBAAwB;UAEpB;;WAEN;WACA;;WAEA;;UAGM;;WAEN,gBAAgB;;WAEhB;;;WAGA;WACA;WACA;;;;;;iBAUK,gBAAgB,gBAAgB;iBAWhC,mBAAmB,SAAS,4BAA4B"}

package/dist/trace-repair/index.js

@@ -4,7 +4,7 @@ import { n as contentHash } from "../verdict-cache-mZf5FEiY.js";
 import { t as certificationEvidenceDigest } from "../verdict-BndeTAh_.js";
 import { t as packageVersion } from "../package-version-D7lQHt_-.js";
 import { d as runPrimeExchange, n as buildPrimePrompt, p as assertEqualDeclarativeTerms, t as analystUsageReceiptFromPrimeUsage } from "../prime-protocol-6tZTVsWm.js";
-import { o as parseRecordedReturncode, r as deriveFailureSignature, t as wrapActionForExec } from "../exec-BLtYZdWo.js";
+import { a as TIMEOUT_OBSERVATION_MARKER, f as isRecordedTimeout, g as parseRecordedReturncode, i as SUBMIT_ACTION_SIGNATURE, l as deriveFailureSignature, n as FORMAT_ERROR_OBSERVATION_PREFIX, t as wrapActionForExec } from "../exec-y-DCLqK7.js";
 import { createHash } from "node:crypto";
 import { constants } from "node:os";
 import { spawn } from "node:child_process";
@@ -19,9 +19,13 @@ import { spawn } from "node:child_process";
 * one distinct system prompt across all of them). A continuation that renders
 * different bytes puts the model in a different distribution than the prefix
 * it inherits, so these strings are pinned, not configurable.
+*
+* The markers a reader matches on live in `trajectory-replay/steps`, which owns
+* the recorded grammar. This module writes with them so a rendered observation
+* and a recorded one classify the same way.
 */
 /** Whole-line marker that ends a run. The first output line must equal it and the command must exit 0. */
-const SUBMIT_SENTINEL = "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT";
+const SUBMIT_SENTINEL = SUBMIT_ACTION_SIGNATURE;
 /** Outputs at or above this length are elided head+tail instead of shown whole. */
 const OUTPUT_ELISION_THRESHOLD = 1e4;
 /** Characters kept from each end of an elided output. */
@@ -159,24 +163,11 @@ If you really need to see something from the full command's output, you can redi
 }
 /** The observation after the environment killed a command for exceeding its timeout. */
 function renderTimeoutObservation(command, partialOutput) {
-	return `The last command <command>${command}</command> timed out and has been killed.\nThe output of the command was:\n <output>\n${partialOutput}\n</output>\nPlease try another command and make sure to avoid those requiring interactive input.`;
-}
-/** Substring `renderTimeoutObservation` always writes, whatever the command was. */
-const TIMEOUT_OBSERVATION_MARKER = "timed out and has been killed";
-/**
-* True when the recording shows the environment killed this step at its
-* wall-clock bound.
-*
-* Such a step carries no returncode, so no replay can confirm or contradict
-* it. Callers use this to bound the replay of that step cheaply rather than to
-* decide agreement.
-*/
-function isRecordedTimeout(observation) {
-	return observation?.includes(TIMEOUT_OBSERVATION_MARKER) === true;
+	return `The last command <command>${command}</command> ${TIMEOUT_OBSERVATION_MARKER}.\nThe output of the command was:\n <output>\n${partialOutput}\n</output>\nPlease try another command and make sure to avoid those requiring interactive input.`;
 }
 /** The observation after a turn that did not contain exactly one bash block. */
 function renderFormatErrorObservation(actionCount) {
-	return `Please always provide EXACTLY ONE action in triple backticks, found ${actionCount} actions.\nIf you want to end the task, please issue the following command: \`echo ${SUBMIT_SENTINEL}\`\nwithout any other command.
+	return `${FORMAT_ERROR_OBSERVATION_PREFIX}${actionCount} actions.\nIf you want to end the task, please issue the following command: \`echo ${SUBMIT_SENTINEL}\`\nwithout any other command.
 Else, please format your response exactly as follows:
 
 <response_example>
@@ -199,7 +190,7 @@ function submissionOf(output) {
 	if (output.returncode !== 0) return null;
 	const lines = output.output.replace(/^\s+/, "").split(/(?<=\n)/);
 	const first = lines[0];
-	if (first === void 0 || first.trim() !== "COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT") return null;
+	if (first === void 0 || first.trim() !== SUBMIT_SENTINEL) return null;
 	return lines.slice(1).join("");
 }
 //#endregion
@@ -544,7 +535,7 @@ function checkInterventionBudget(action, declaredKind, budget = SCAFFOLD_INTERVE
 	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("COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT")) return reject("submit-instead-of-repair", "the action submits the run instead of repairing it");
+	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,