@lyupro/codex-bridge 0.6.8 → 0.6.10

package/src/home/lib/meta/launch-rows.mjs

@@ -23,6 +23,27 @@ function retentionReply(runDir) {
   return `Retention: freed ${formatBytes(bytes)} from ${runs} runs older than ${days} days`;
 }
 
+function attemptReply(runDir) {
+  const retryOf = readJson(path.join(runDir, 'status.json'))?.retry_of;
+  if (typeof retryOf !== 'string' || !retryOf.trim()) return null;
+  const runsRoot = path.dirname(runDir);
+  const key = (name) => process.platform === 'win32' ? name.toLowerCase() : name;
+  const seen = new Set([key(path.basename(runDir))]);
+  let previous = retryOf;
+  let attempt = 1;
+  // Plan_75 D1, 2026-10-03 TradeForge: show retries without trusting broken provenance links.
+  for (let hops = 0; hops < 50; hops += 1) {
+    if (typeof previous !== 'string' || !previous || /[/\\]/.test(previous)
+      || previous === '.' || previous === '..' || seen.has(key(previous))) break;
+    const status = readJson(path.join(runsRoot, previous, 'status.json'));
+    if (!status) break;
+    seen.add(key(previous));
+    attempt += 1;
+    previous = status.retry_of;
+  }
+  return `Attempt: ${attempt} of this pass — retry of ${retryOf}`;
+}
+
 // Five copies of Retention missed writeFailure(), so both reply assemblers share this point.
 // The 2026-09-16 dead Codex sandbox incident is why the launcher probes the sandbox at all.
 export function launchRows(runDir) {
@@ -33,6 +54,8 @@ export function launchRows(runDir) {
     const reason = line(probe.reason, 160) || 'no reason recorded';
     rows.push(`Sandbox probe: inconclusive — ${reason} The run started without a sandbox check.`);
   }
+  const attempt = attemptReply(runDir);
+  if (attempt) rows.push(attempt);
   return rows;
 }
 

package/src/home/lib/meta/paths.mjs

@@ -3,11 +3,21 @@
  *
  * Two sides spell the same file differently — git prints repo-relative paths with forward
  * slashes, Codex writes whatever it likes — so nothing above this module compares a path
- * before it has been through here. This is also the only module that touches the
- * filesystem for reading artifacts: everything else receives text, JSON or a byte count from it.
+ * before it has been through here. Strict snapshot judgement belongs to run-snapshots.mjs.
  */
 import fs from 'node:fs';
 import { readJsonFileSync } from '../json-file.mjs';
+import { compareSnapshots, decodeSnapshot } from './snapshot-format.mjs';
+
+/**
+ * `slice` counts UTF-16 units and can leave half of an emoji or a rare CJK character at the cut;
+ * a lone surrogate in a reply is the same kind of broken text Plan_68 D6 refuses from the model.
+ */
+export const safeSlice = (value, max) => {
+  const text = String(value ?? '').toWellFormed();
+  const result = text.slice(0, max);
+  return result.isWellFormed() ? result : result.slice(0, -1);
+};
 
 /** One line, no newlines, bounded length — a five-line reply must stay five lines. */
 export const line = (value, max = 200) => {
@@ -15,7 +25,7 @@ export const line = (value, max = 200) => {
   if (text.length <= max) return text;
 
   const ellipsis = '...';
-  if (max <= ellipsis.length) return text.slice(0, Math.max(0, max));
+  if (max <= ellipsis.length) return safeSlice(text, Math.max(0, max));
 
   const contentLimit = max - ellipsis.length;
   const boundary = text.lastIndexOf(' ', contentLimit);
@@ -24,11 +34,11 @@ export const line = (value, max = 200) => {
   // where a word ended. Dropping a trailing number here as well cost `All 298 12345678 rest`
   // its 298 — a number that fitted whole — because the digit test compared the limit rather
   // than the point the text was actually cut at.
-  if (boundary > 0) return `${text.slice(0, boundary)}${ellipsis}`;
+  if (boundary > 0) return `${safeSlice(text, boundary)}${ellipsis}`;
 
   // No space to retreat to: the limit lands inside a single long word. Only here can the cut
   // land mid-number, so only here is a partial number dropped.
-  return `${text.slice(0, contentLimit).replace(/\d+$/, '')}${ellipsis}`;
+  return `${safeSlice(text, contentLimit).replace(/\d+$/, '')}${ellipsis}`;
 };
 
 export const readText = (file) => {
@@ -60,32 +70,22 @@ export const size = (file) => {
 };
 
 /**
- * Snapshot lines are `<added>\t<deleted>\t<path>` for tracked files and `U\t<bytes>\t<path>`
- * for untracked ones — see worktreeSnapshot() in runner/git-state.mjs. Path last, state first.
+ * Tolerant display reader for reply, run-state and write-meta; invalid snapshots display
+ * an empty Map. Strict judgement goes through run-snapshots.mjs.
  */
 export const snapshotMap = (text) => {
-  const map = new Map();
-  for (const row of text.split(/\r?\n/).filter(Boolean)) {
-    const parts = row.split('\t');
-    if (parts.length < 3) continue;
-    map.set(parts.slice(2).join('\t').trim(), `${parts[0]}\t${parts[1]}`);
-  }
-  return map;
+  const snapshot = decodeSnapshot(text);
+  return snapshot.ok ? snapshot.rows : new Map();
 };
 
 /**
- * Paths Codex actually touched, by content rather than by porcelain letter: a file that
- * was already ` M` stays ` M` after further edits, so status codes would report zero
- * work. Line counts (or size, for untracked files) do change.
+ * Tolerant display reader for reply, run-state and write-meta; invalid comparisons display
+ * no changes. Strict judgement goes through run-snapshots.mjs. Snapshot states measure
+ * edits even when a file's porcelain letter stays unchanged.
  */
 export const changedPaths = (before, after) => {
-  const was = snapshotMap(before);
-  const now = snapshotMap(after);
-  const paths = [];
-  for (const [file, state] of now) if (was.get(file) !== state) paths.push(file);
-  // A path that dropped out was touched too: Codex restored it to its committed state.
-  for (const file of was.keys()) if (!now.has(file)) paths.push(file);
-  return paths;
+  const comparison = compareSnapshots(before, after);
+  return comparison.ok ? comparison.changed : [];
 };
 
 /** Directories a delegated build has no business editing, whatever the task says. */

package/src/home/lib/meta/reply.mjs

@@ -2,7 +2,8 @@
  * Renders the reply lines a dispatcher is allowed to return, one format per agent.
  *
  * AGENTS adds reply strategies to the shared agent registry: for each one it describes how
- * to tell the result file is filled in and which reply strategy below renders it. FAIL and LIMIT bypass the per-agent strategy — a run that
+ * to tell the result file is filled in and which reply strategy below renders it.
+ * FAIL, LIMIT and UNAVAILABLE bypass the per-agent strategy — a run that
  * produced nothing has nothing agent-specific left to say.
  *
  * The lines built here ARE the reply. Agents forward this text verbatim instead of
@@ -24,6 +25,11 @@ const runChanges = (runDir) =>
 
 const readCommand = (runDir) => `codex-bridge read ${runDir}`;
 
+function stripVerdict(value) {
+  // Run 2026-10-01_114244_plan72-r3q-live-probe-20261001 repeated OK because the model prefixed its summary.
+  return String(value ?? '').replace(/^(?:OK|FAIL|LIMIT|UNAVAILABLE)(?: — | - |: )/, '');
+}
+
 export const AGENTS = {
   'codex-scout': {
     ...AGENT_DEFINITIONS['codex-scout'],
@@ -54,7 +60,7 @@ function scoutReply(ctx) {
   const unknowns = (r.unknowns || []).filter(Boolean);
   const coverage = scoutCoverage(ctx.runDir, r);
   return [
-    `OK — ${line(r.answer, 160)}`,
+    `OK — ${line(stripVerdict(r.answer), 160)}`,
     // Any explicit question gets a coverage line, including a valid one-question order.
     ...(coverage ? [`Coverage: ${coverage}`] : []),
     `Key finding: ${top ? `${line(top.fact, 130)} (${line(top.where, 60)})` : 'no findings listed'}`,
@@ -68,6 +74,7 @@ function buildReply(ctx) {
   const { work: touchedPaths, environment } = runChanges(ctx.runDir);
   const paths = touchedPaths.slice(0, 3).join(', ');
   const flags = readText(path.join(ctx.runDir, 'flags.txt')).split(/\r?\n/).filter(Boolean);
+  const gaps = readText(path.join(ctx.runDir, 'flags-coverage.txt')).split(/\r?\n/).filter((gap) => gap.trim());
   // A multi-line verification is several commands, and collapsing them into one 60-character
   // line cut the last one mid-word: the reply named a command nobody could run.
   const commands = String(r.verify_command ?? '')
@@ -90,7 +97,7 @@ function buildReply(ctx) {
     ? `${paths ? `${paths} · ` : ''}changes were made by an earlier run of this task`
     : paths || 'worktree untouched';
   return [
-    `OK — ${line(r.summary, 300)}`,
+    `OK — ${line(stripVerdict(r.summary), 300)}`,
     `Files: ${touchedPaths.length} changed · ${files}`,
     // Only when something outside the run wrote to the tree. Subtracting those paths from the
     // verdict without naming them would hide a real edit behind a pattern.
@@ -99,6 +106,9 @@ function buildReply(ctx) {
       : []),
     `Verification: ${verify} — ${verdict}`,
     `Flags: ${flags.length ? `${flags.length} TODO/skip — ${line(flags.slice(0, 3).join(' | '), 140)}` : 'none'}`,
+    ...(gaps.length
+      ? [`Flags coverage: incomplete — ${line(gaps[0], 120)}${gaps.length > 1 ? ` (+${gaps.length - 1} more)` : ''}`]
+      : []),
     `Report: ${ctx.file('report.md')} · Log: ${readCommand(ctx.runDir)}`,
   ];
 }
@@ -223,3 +233,27 @@ export function limitReply(ctx, meta) {
   rows.push(`Log: ${readCommand(ctx.runDir)}`);
   return rows;
 }
+
+/** Plan_60 D2: pre-start and post-start refusals share the same handoff contract. */
+export function unavailableRows(signal) {
+  return [
+    'UNAVAILABLE — Codex is not available (missing or signed out); ' +
+      'hand the task to the next executor, do not retry',
+    `Signal: ${line(signal, 170)}`,
+    'Operator check: codex --version; codex login status (sign in with codex login)',
+  ];
+}
+
+export function unavailableReply(ctx, meta) {
+  const rows = unavailableRows(meta.reason);
+  if (ctx.agent === 'codex-build') {
+    const { work: touched } = runChanges(ctx.runDir);
+    rows.push(
+      `Worktree: ${
+        touched.length ? `has unfinished changes (${touched.length}), see git-after.txt` : 'no new changes'
+      }`,
+    );
+  }
+  rows.push(`Log: ${readCommand(ctx.runDir)}`);
+  return rows;
+}

package/src/home/lib/meta/run-snapshots.mjs

@@ -0,0 +1,29 @@
+/**
+ * Read a run's before/after snapshots and compare them strictly.
+ * On 2026-09-30 git-quoted Cyrillic names made an in-scope edit look out of scope;
+ * missing or untrustworthy snapshots must refuse judgement, never imply a clean tree.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { compareSnapshots } from './snapshot-format.mjs';
+
+export function readSnapshot(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+export function runSnapshotChanges(runDir) {
+  return compareSnapshots(
+    readSnapshot(path.join(runDir, 'state-before.txt')),
+    readSnapshot(path.join(runDir, 'state-after.txt')),
+  );
+}
+
+export function snapshotRefusal(comparison) {
+  const issue = comparison.side ? `${comparison.side} ${comparison.issue}` : comparison.issue;
+  return `worktree snapshots cannot be compared (${issue}): ${comparison.detail}`;
+}

package/src/home/lib/meta/run-state.mjs

@@ -12,6 +12,7 @@ import path from 'node:path';
 import { changedPaths, line, normalizePath, readJson, readText, size } from './paths.mjs';
 import { withLaunchRows } from './launch-rows.mjs';
 import { runLiveness } from './run-liveness.mjs';
+import { removeFlagBaselineCopies } from '../runner/flag-baseline.mjs';
 
 /**
  * Run state on disk, merged over whatever is already there. A killed runner leaves no
@@ -115,6 +116,8 @@ export function markAbandoned(runsRoot, currentTree) {
     }
     try {
       writeStatus(runDir, patch);
+      // Plan_60 D3a: a dead worker cannot remove its start copies; keep the manifest for inspection.
+      if (patch.state === 'abandoned') removeFlagBaselineCopies(runDir);
       changed.push({ run: entry.name, state: patch.state });
     } catch {
       // A folder that cannot be written to is not worth failing a fresh run over.

package/src/home/lib/meta/snapshot-format.mjs

@@ -0,0 +1,96 @@
+/**
+ * Serialize, validate and compare worktree snapshots; owns the version rule.
+ *
+ * On 2026-09-30 git's quoted Cyrillic names made an in-scope edit look out of scope
+ * and hid a new Cyrillic file. JSON names preserve exact spelling; mixed versions
+ * must refuse comparison rather than repeat that incident.
+ */
+import { parseJsonText } from '../json-file.mjs';
+
+export const SNAPSHOT_V2_HEADER = '# codex-bridge-state-v2';
+
+// `unreadable`: listed but not readable (a Windows file held by another process gives EBUSY/EPERM).
+const STATE_RE = /^(?:\d+\t\d+|-\t-|U\t(?:\d+:[0-9a-fA-F]{64}|missing|unreadable))$/;
+const LEGACY_ROW_RE = /^(?:\d+\t\d+|-\t-|U\t\d+)\t\S.*$/;
+const validState = (state) => typeof state === 'string' && STATE_RE.exec(state)?.[0] === state;
+const malformed = (detail) => ({ ok: false, issue: 'malformed', detail });
+
+export function encodeSnapshot(rows) {
+  const paths = new Set();
+  const ordered = [];
+  for (const row of rows) {
+    if (!row || typeof row.path !== 'string' || !validState(row.state)) {
+      throw new TypeError('Snapshot rows require a string path and a valid v2 state.');
+    }
+    if (paths.has(row.path)) throw new TypeError(`Duplicate snapshot path: ${JSON.stringify(row.path)}`);
+    paths.add(row.path);
+    ordered.push({ path: row.path, state: row.state });
+  }
+  ordered.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return [SNAPSHOT_V2_HEADER, ...ordered.map(({ path, state }) => `${state}\t${JSON.stringify(path)}`)]
+    .join('\n') + '\n';
+}
+
+export function decodeSnapshot(text) {
+  if (text === null) return { ok: false, issue: 'missing', detail: 'Snapshot file is absent.' };
+  if (typeof text !== 'string') return malformed('Snapshot text must be a string or null.');
+  const lines = text.replace(/^\uFEFF/, '').split(/\r?\n/);
+  const version = lines[0] === SNAPSHOT_V2_HEADER ? 2 : 1;
+  if (version === 2) lines.shift();
+  // Only the final line terminator is framing; an empty interior row is damaged data.
+  if (lines.at(-1) === '') lines.pop();
+  const rows = new Map();
+  for (const [index, line] of lines.entries()) {
+    const location = `Snapshot line ${index + (version === 2 ? 2 : 1)}`;
+    let path;
+    let state;
+    if (version === 2) {
+      const fields = line.split('\t');
+      if (fields.length !== 3) return malformed(`${location} must have exactly three tab fields.`);
+      state = `${fields[0]}\t${fields[1]}`;
+      if (!validState(state)) return malformed(`${location} has an invalid v2 state.`);
+      try {
+        path = parseJsonText(location, fields[2]);
+      } catch {
+        return malformed(`${location} has an invalid JSON path.`);
+      }
+      if (typeof path !== 'string') return malformed(`${location} path must be a JSON string.`);
+    } else {
+      // The legacy launcher wrote `${snapshot}\n`, so a clean tree is the text "\n" and the old
+      // reader skipped blank rows. Refusing them failed every build that started on a clean tree.
+      if (line === '') continue;
+      if (!LEGACY_ROW_RE.test(line)) return malformed(`${location} has an invalid legacy row.`);
+      const fields = line.split('\t');
+      state = `${fields[0]}\t${fields[1]}`;
+      path = fields.slice(2).join('\t').trim();
+      if (path.startsWith('"')) {
+        return {
+          ok: false,
+          issue: 'legacy-quoted-name',
+          detail: `${location} contains a git-quoted legacy name whose original spelling is lost.`,
+        };
+      }
+    }
+    if (rows.has(path)) return malformed(`${location} repeats path ${JSON.stringify(path)}.`);
+    rows.set(path, state);
+  }
+  return { ok: true, version, rows };
+}
+
+export function compareSnapshots(beforeText, afterText) {
+  const before = decodeSnapshot(beforeText);
+  if (!before.ok) return { ...before, side: 'before' };
+  const after = decodeSnapshot(afterText);
+  if (!after.ok) return { ...after, side: 'after' };
+  if (before.version !== after.version) {
+    return {
+      ok: false,
+      issue: 'incompatible-versions',
+      detail: 'The run started under another package version; restart the run before comparing snapshots.',
+    };
+  }
+  const changed = [];
+  for (const [path, state] of after.rows) if (before.rows.get(path) !== state) changed.push(path);
+  for (const path of before.rows.keys()) if (!after.rows.has(path)) changed.push(path);
+  return { ok: true, changed };
+}

package/src/home/lib/meta/verdict.mjs

@@ -10,7 +10,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {
   SERVICE_RE,
-  changedPaths,
   declaredHits,
   displayPath,
   expandDeclared,
@@ -29,6 +28,9 @@ import { startupGap } from './startup.mjs';
 import { transportGap } from './transport.mjs';
 import { reasonFrom } from './reason.mjs';
 import { adviceGap } from './advice-status.mjs';
+import { allStartupContext, contextOnlyGap } from './context-only.mjs';
+import { compareSnapshots } from './snapshot-format.mjs';
+import { readSnapshot, runSnapshotChanges, snapshotRefusal } from './run-snapshots.mjs';
 
 // How much prose an answer must carry once coordinates and paths are subtracted. Measured
 // on the scout run of 2026-07-30 that replied with a table of `file.ts:60-79` rows: every
@@ -79,16 +81,14 @@ const WRONG_WORK = 'wrong work was done: ';
  */
 export function reportVersusWork(runDir, result, ctx) {
   const declared = (result?.changes || []).flatMap((c) => expandDeclared(c?.file));
-  const after = readText(path.join(runDir, 'state-after.txt'));
+  const comparison = runSnapshotChanges(runDir);
+  const broken = (reason) => ({ ok: false, carried: false, reason });
+  if (!comparison.ok) return broken(snapshotRefusal(comparison));
   // Only the run's own work is compared: a report that names nothing is honest when the sole
   // change in the tree was written by the tooling around the run.
-  const touched = splitRunChanges(
-    runDir,
-    changedPaths(readText(path.join(runDir, 'state-before.txt')), after),
-  ).work;
+  const touched = splitRunChanges(runDir, comparison.changed).work;
   const show = (list) => list.slice(0, 3).join(', ');
   const agreed = (carried = false) => ({ ok: true, carried, reason: null });
-  const broken = (reason) => ({ ok: false, carried: false, reason });
 
   if (!declared.length && !touched.length) return agreed();
   if (!declared.length) {
@@ -110,8 +110,11 @@ export function reportVersusWork(runDir, result, ctx) {
 
   const baseline = chainBaseline(ctx?.runsRoot, ctx?.repo, ctx?.slug, ctx?.taskHash, ctx?.orderId);
   if (baseline !== null) {
-    const accumulated = splitRunChanges(runDir, changedPaths(baseline, after)).work;
-    if (declared.some((d) => declaredHits(d, accumulated))) return agreed(true);
+    const chain = compareSnapshots(baseline, readSnapshot(path.join(runDir, 'state-after.txt')));
+    if (chain.ok) {
+      const accumulated = splitRunChanges(runDir, chain.changed).work;
+      if (declared.some((d) => declaredHits(d, accumulated))) return agreed(true);
+    }
   }
 
   return broken(
@@ -154,7 +157,7 @@ function substanceLength(text) {
 
 const questionsOf = (runDir) => {
   const parsed = readJson(path.join(runDir, 'questions.json'));
-  return Array.isArray(parsed) ? parsed.filter((q) => q && q.id) : [];
+  return Array.isArray(parsed) ? parsed : [];
 };
 
 /** Answers indexed by question id, first one wins; ids come back in whatever case Codex used. */
@@ -173,8 +176,8 @@ const answersById = (result) => {
  * single-answer check. Every branch here exists because a schema alone accepted the run that
  * answered in coordinates.
  */
-function scoutCoverageGap(runDir, result) {
-  const questions = questionsOf(runDir);
+function scoutCoverageGap(orderedQuestions, result) {
+  const questions = orderedQuestions.filter((q) => q && q.id);
   const show = (list) => list.slice(0, 8).join(', ');
 
   if (!questions.length) {
@@ -209,7 +212,7 @@ function scoutCoverageGap(runDir, result) {
 
 /** `1/1 sub-questions`, or null for legacy runs with no questions.json artifact. */
 export function scoutCoverage(runDir, result) {
-  const questions = questionsOf(runDir);
+  const questions = questionsOf(runDir).filter((q) => q && q.id);
   if (!questions.length) return null;
   const byId = answersById(result);
   const answered = questions.filter((q) => String(byId.get(q.id)?.answer || '').trim()).length;
@@ -286,9 +289,10 @@ export function resolveStatus({ resultOk, exit, agent, result, runDir, events })
     // This branch already knows why the run died: the CLI said so itself, with a status. Letting
     // the ordered reason speak here would answer a transport question with the model's older
     // complaint about the task — a LIMIT that never mentions quota is the same "verdict says the
-    // wrong thing" defect this module exists to remove.
+    // wrong thing" defect this module exists to remove. Plan_60 D2: UNAVAILABLE only on a measured
+    // signed-out sample (events.mjs); an unfamiliar failure stays FAIL with its raw CLI text.
     return {
-      status: transportError.quota ? 'LIMIT' : 'FAIL',
+      status: transportError.quota ? 'LIMIT' : transportError.unavailable ? 'UNAVAILABLE' : 'FAIL',
       reason: transportError.reason,
     };
   }
@@ -316,19 +320,25 @@ export function resolveStatus({ resultOk, exit, agent, result, runDir, events })
   // Answers that never arrived, or arrived as coordinates. Scout-only, and per-question
   // only when questions.json is absent — see scoutCoverageGap().
   if (agent === 'codex-scout') {
+    const questions = questionsOf(runDir);
     // The 2026-09-16 dead sandbox produced nonempty evidence without reading code. Require an
     // execution fact first: checking whether evidence paths existed falsely rejected 64/151 runs.
     // Only a run that left a stream can prove it: an archived run from before `--json` has none and
     // is judged by the contract of its day; a `--json` run missing its stream already failed above.
-    if (eventData.hasStream && eventData.commands_executed === 0) {
+    // Plan_60 D1 exempts only orders whose every question asks about handed startup context.
+    if (eventData.hasStream && eventData.commands_executed === 0 && !allStartupContext(questions)) {
       return {
         status: 'FAIL',
         reason: 'scout executed no command, so no answer rests on reading the code; '
           + 'check stderr.log for sandbox refusals before changing the order',
       };
     }
-    const gap = scoutCoverageGap(runDir, result);
+    const gap = scoutCoverageGap(questions, result);
     if (gap) return { status: 'FAIL', reason: gap };
+    const contextGap = contextOnlyGap({
+      questions, result, commandsExecuted: eventData.hasStream ? eventData.commands_executed : null,
+    });
+    if (contextGap) return { status: 'FAIL', reason: contextGap };
   }
   // Plan_59 D3/D4/D5/D10: a schema-valid agreement still needs evidence and decision checks.
   // Place the advisor judge before the build-only scope check, alongside the other agent contracts.
@@ -349,13 +359,9 @@ export function resolveStatus({ resultOk, exit, agent, result, runDir, events })
       // Environment writes are subtracted first: attributing them to the run failed an honest
       // pass for a file it never opened. What was subtracted is reported, not swallowed —
       // see the "Environment" line in reply.mjs and environment_changes in meta.json.
-      const { work } = splitRunChanges(
-        runDir,
-        changedPaths(
-          readText(path.join(runDir, 'state-before.txt')),
-          readText(path.join(runDir, 'state-after.txt')),
-        ),
-      );
+      const comparison = runSnapshotChanges(runDir);
+      if (!comparison.ok) return { status: 'FAIL', reason: snapshotRefusal(comparison) };
+      const { work } = splitRunChanges(runDir, comparison.changed);
       const strays = outOfScope(work, patterns);
       if (strays.length) {
         return {

package/src/home/lib/required-inputs.mjs

@@ -23,6 +23,15 @@ export const CONTINUATION_INPUT = Object.freeze({
   conditional: 'when --continue is passed',
 });
 
+export const RETRY_INPUT = Object.freeze({
+  label: 'retry',
+  source: 'the orchestrator',
+  explanation:
+    'The failed run this pass repeats, followed by why the orchestrator pays for the same pass again. A retry repeats that failed pass under its own order; it does not authorize the next pass.',
+  example: '2026-10-03_172017_cc-d66-advisor — model at capacity, same pass again',
+  conditional: 'when --continue is passed',
+});
+
 /**
  * The task statement reaches the runner as a file because every other channel puts the invocation
  * back into the multi-line form that no permission rule can cover — a heredoc on stdin, or a
@@ -53,6 +62,7 @@ export const REQUIRED_INPUTS = Object.freeze({
     },
     TASK_FILE_INPUT,
     CONTINUATION_INPUT,
+    RETRY_INPUT,
   ]),
   'codex-build': freezeEntries([
     {
@@ -69,6 +79,7 @@ export const REQUIRED_INPUTS = Object.freeze({
     },
     TASK_FILE_INPUT,
     CONTINUATION_INPUT,
+    RETRY_INPUT,
   ]),
   'codex-review': freezeEntries([
     {
@@ -79,6 +90,7 @@ export const REQUIRED_INPUTS = Object.freeze({
     },
     TASK_FILE_INPUT,
     CONTINUATION_INPUT,
+    RETRY_INPUT,
   ]),
   // Plan_59 D7: the caller must name the phase and authorize the continued decision pass.
   'codex-advisor': freezeEntries([
@@ -90,6 +102,7 @@ export const REQUIRED_INPUTS = Object.freeze({
     },
     TASK_FILE_INPUT,
     CONTINUATION_INPUT,
+    RETRY_INPUT,
     {
       label: 'phase',
       source: 'the orchestrator',
@@ -122,13 +135,15 @@ export function isPlaceholder(value) {
 export const isInputPlaceholder = (value, label) =>
   !(label === 'phase' && cleanValue(value) === 'scope') && isPlaceholder(value);
 
-export function extractValue(promptText, label) {
+// Plan_75 D5: dispatcher prompts still need one spelling of a labelled line for reading values.
+const labelledLine = (label) => {
   const labelPattern = escapeRegExp(label).replaceAll('\\ ', '\\s+');
+  return `(?:[-*]\\s*)?(?:[*_` + '`' + `]?${labelPattern}[*_` + '`' + `]?)\\s*(?::|=|—|-)`;
+};
+
+export function extractValue(promptText, label) {
   const flag = `--${label.replaceAll(/\s+/g, '-')}`;
-  const direct = new RegExp(
-    `(?:^|\\r?\\n)\\s*(?:[-*]\\s*)?(?:[*_` + '`' + `]?${labelPattern}[*_` + '`' + `]?)\\s*(?::|=|—|-)\\s*([^\\r\\n]*)`,
-    'im',
-  );
+  const direct = new RegExp(`(?:^|\\r?\\n)\\s*${labelledLine(label)}\\s*([^\\r\\n]*)`, 'im');
   const directMatch = promptText.match(direct);
   if (directMatch) return cleanValue(directMatch[1]);
 
@@ -188,10 +203,15 @@ export function diagnoseInput(promptText, label) {
   return { line, reason: `expected \`${label}: value\` with a separator immediately after the label` };
 }
 
-/** Keeps the 2026-08-05 continuation incident's run and reason in the shared input parser. */
-export function parseContinuationGrant(promptText) {
+// Plan_75 D1, TradeForge capacity incident (2026-10-03): both grants need the same run/reason grammar.
+function parseLabelledGrant(promptText, label) {
   const prompt = typeof promptText === 'string' ? promptText : '';
-  const value = extractValue(prompt, CONTINUATION_INPUT.label);
+  const value = extractValue(prompt, label);
+  return splitGrantValue(value);
+}
+
+// Plan_75 D5, 2026-10-03 20:42: header parsing must reuse the existing grant value grammar.
+export function splitGrantValue(value) {
   if (isPlaceholder(value)) return null;
 
   for (const separator of [/\s+—\s+/, /\s+-\s+/, /\s*:\s*/]) {
@@ -205,6 +225,26 @@ export function parseContinuationGrant(promptText) {
   return null;
 }
 
+/** Keeps the 2026-08-05 continuation incident's run and reason in the shared input parser. */
+export function parseContinuationGrant(promptText) {
+  return parseLabelledGrant(promptText, CONTINUATION_INPUT.label);
+}
+
+export function parseRetryGrant(promptText) {
+  return parseLabelledGrant(promptText, RETRY_INPUT.label);
+}
+
+export function parseGrant(promptText) {
+  const continuation = parseContinuationGrant(promptText);
+  const retry = parseRetryGrant(promptText);
+  if (continuation && retry) {
+    return { error: 'exactly one grant per task: remove either the continue: or the retry: line' };
+  }
+  if (continuation) return { kind: 'continue', ...continuation };
+  if (retry) return { kind: 'retry', ...retry };
+  return null;
+}
+
 /** Returns the immutable input entries for one dispatcher type. */
 export function requiredInputsFor(agentType) {
   return REQUIRED_INPUTS[agentType] || [];

package/src/home/lib/run-codex.mjs

@@ -54,6 +54,7 @@ import { setWorkerDir, getRun, emitReply } from './runner/run-context.mjs';
 import { launcher } from './runner/launcher.mjs';
 import { worker } from './runner/worker.mjs';
 import { RunnerUsageError } from './runner/args.mjs';
+import { EXIT } from './runner/exit-codes.mjs';
 
 export { parseArgs } from './runner/args.mjs';
 export { runsPrefixInside, worktreeSnapshot } from './runner/git-state.mjs';
@@ -88,18 +89,20 @@ export function installRunnerCrashBoundary() {
           `Log: codex-bridge read ${currentRun}`,
         ]);
         emitReply(reply);
-        process.exit(1);
+        process.exit(EXIT.FAIL);
       } catch {
         // Falls through to the bare reply below: the disk itself is not cooperating.
       }
     }
     emitReply(
       [
-        `FAIL — Codex runner crashed before creating the run folder: ${String(err.message).replace(/\s+/g, ' ').slice(0, 150)}`,
+        `FAIL — Codex runner crashed before creating the run folder: ${
+          String(err.message).replace(/\s+/g, ' ').slice(0, 150)
+        }`,
         'No artifacts; nothing to inspect',
       ].join('\n'),
     );
-    process.exit(1);
+    process.exit(EXIT.FAIL);
   });
 }
 

package/src/home/lib/run-config.mjs

@@ -53,7 +53,16 @@ export function readRunConfig(file = CONFIG_PATH) {
   try {
     parsed = readJsonFileSync(file);
   } catch (err) {
-    if (err.code) return { ...DEFAULTS };
+    // Only a missing file means "no config". Every error code used to mean that, so a config the
+    // run could not open (EACCES, EISDIR, EPERM) ran every role on default models with nobody told
+    // (Plan_69 stage 0) — the one reader of an operator file that treated failure as absence.
+    if (err.code === 'ENOENT') return { ...DEFAULTS };
+    if (err.code) {
+      throw new Error(
+        `${file} cannot be read (${err.code}). Fix its permissions or type, or delete it — without it, ` +
+          'the default mode applies: hooks and plugins are disabled.',
+      );
+    }
     throw new Error(
       `${file} cannot be parsed as JSON (${err.cause?.message || err.message}). Fix or delete the file — without it, ` +
         'the default mode applies: hooks and plugins are disabled.',