@lyupro/codex-bridge 0.6.9 → 0.6.10

package/src/agents/codex-scout.md

@@ -38,13 +38,17 @@ files, do not run grep, do not retell the report, and do not reason about the ta
   hides. If the orchestrator did not give a required input, do not guess — start the runner without
   its flag and return the runner's refusal verbatim.
 - The sub-questions are NOT yours to pass. They live in the task file the orchestrator wrote, under
-  a `Questions` heading, one Markdown list item each. You never read that file, never edit it and
-  never put a question on the command line: a question is free prose, and free prose in an argument
+  a `Questions` heading, one Markdown list item each. A question may carry the orderer's
+  `[context-only]` marker; the dispatcher never adds, removes or repairs it. You never read that
+  file, never edit it and never put a question on the command line: a question is free prose, and
+  free prose in an argument
   makes the host stop applying the operator's permission rule, which is how a delegation dies on a
   refusal. If the file holds no question, start the runner anyway and return its refusal verbatim.
-- `continue` — when the task text contains a line beginning with the `continue:` label, pass the
-  bare `--continue` flag even when its run name or reason looks malformed. Do not inspect, repair,
-  or swallow this grant; pass it through and let the runner issue the refusal. A continuation is
+- `continue` — when the orchestrator's call carries a line beginning with `continue:` or `retry:`,
+  pass the bare `--continue` flag even when its run name or reason looks malformed. A `retry:`
+  grant lets the orchestrator repeat a failed pass (FAIL, LIMIT, UNAVAILABLE) of the same order
+  once; it is not the next pass. Do not inspect, repair, or swallow this grant; pass it through
+  and let the runner issue the refusal. A continuation is
   assigned by the orchestrator, never chosen by you. After the verdict, return the exact attaching
   output and stop; do not issue or invent another continuation. If no such grant line is present,
   the flag must not be present.
@@ -85,8 +89,9 @@ Add `--effort "<value>"` only when the orchestrator named a depth, and only with
 decides, which is the intended default — a placeholder copied from this template is refused before
 Codex starts.
 
-If the task text contains a line beginning with the `continue:` label, add the bare `--continue`
-flag even when its run name or reason looks malformed. Do not inspect, repair, or swallow the line;
+If the orchestrator's call carries a line beginning with `continue:` or `retry:`, add the bare
+`--continue` flag even when its run name or reason looks malformed. Do not inspect, repair, or
+swallow the line;
 the runner parses it and issues the refusal. If no such grant line is present, the flag must not be
 present in the command.
 No value
@@ -170,6 +175,7 @@ confidence), `unknowns[]`, and `report_markdown`. An uncovered subquestion or an
 evidence is FAIL;
 the runner prints the line `Coverage: N/M subquestions`. The runner expands the last field into
 `report.md`.
+A `[context-only]` subquestion is answered with `startup:<source>` evidence.
 An empty `answer` is FAIL with a path to the log, not a reason to choose different flags.
 
 ## The script determines status, not you
@@ -180,9 +186,13 @@ An empty `answer` is FAIL with a path to the log, not a reason to choose differe
 - `LIMIT` — the result is empty and the log signals a limit. The ChatGPT quota is exhausted, and the
   task was not
   completed; this is not a task failure and not a reason to restart.
+- `UNAVAILABLE` — Codex is missing or signed out (checked before start, or recognised from the CLI's own
+  sign-in refusal after start). The task was not attempted or could not run; this is not a task failure and
+  not a reason to restart — return the block as is, the orchestrator hands the task to the next executor.
 
-The script return code mirrors the status: `0` / `1` / `3`. A nonzero code is not a reason to retry,
+The script return code mirrors the status: `0` / `1` / `3` / `5`. A nonzero code is not a reason to retry,
 not a reason to change the command, and not a reason to investigate on your own.
+Code `5` means `UNAVAILABLE`.
 
 The run folder contains `status.json` (`running` / `finished` / `failed` / `abandoned`) and the
 runner pid.
@@ -194,10 +204,10 @@ which is the runner telling you the answer is on disk already.
 
 ## Codex is unavailable
 
-The runner checks `codex --version` before starting. If the binary is missing or authentication
-failed,
-it prints a ready-made FAIL with a verification command for the operator. Your job is to return that
-output.
+The runner looks `codex` up on PATH and asks `codex login status` before starting. A missing binary
+or the measured "Not logged in" answer prints a ready-made `UNAVAILABLE` block (first line
+`UNAVAILABLE — `, exit 5, no run folder). An unclear probe prints an ordinary refusal starting
+`Codex CLI unavailable:` (exit 1). Return that output verbatim.
 Performing the task manually instead of Codex is prohibited for any reason it fails.
 
 ## What a violation looks like

package/src/home/hooks/order-gate.mjs

@@ -20,15 +20,16 @@ import {
   diagnoseInput,
   extractValue,
   missingInputs,
-  parseContinuationGrant,
+  parseGrant,
   shellUnsafeInputs,
 } from '../lib/required-inputs.mjs';
 import { SUBAGENT_TOOLS } from '../lib/hook-definitions.mjs';
 import { taskFingerprint } from '../lib/meta/chain.mjs';
-import { conflictingOrderOwner } from '../lib/runner/order-owner.mjs';
+import { conflictingOrderOwner, orderOwnerConflictText } from '../lib/runner/order-owner.mjs';
 import { resolveProjectRunsDir } from '../lib/runner/project-dir.mjs';
 import { runsRoot } from '../lib/runner/runs-root.mjs';
 import { parseTaskDocument } from '../lib/runner/task-file.mjs';
+import { parseTaskHeader, taskHeaderRefusal } from '../lib/task-header.mjs';
 
 const GUARDED = new Set(Object.keys(AGENTS));
 /**
@@ -115,11 +116,29 @@ const readStatus = (file) => {
 
 const orderId = extractValue(toolInput.prompt, 'order id');
 const taskFile = extractValue(toolInput.prompt, 'task file');
-if (!orderId || !taskFile || parseContinuationGrant(toolInput.prompt)) pass();
+// Plan_75 D1, TradeForge capacity incident: retries keep their order; the runner owns conflicting-grant refusal.
+const grant = parseGrant(toolInput.prompt);
+if (!orderId || !taskFile || grant?.kind || grant?.error) pass();
+
+let rawTask;
+try {
+  rawTask = fs.readFileSync(taskFile, 'utf8');
+} catch {
+  pass();
+}
+// Plan_75 D5, 2026-10-03 20:42: malformed metadata must not disappear into the disk-state guard.
+const parsed = parseTaskHeader(rawTask);
+const headerRefusal = taskHeaderRefusal(parsed);
+if (headerRefusal) deny(headerRefusal);
+let taskHash;
+try {
+  taskHash = taskFingerprint(parseTaskDocument(parsed.body).task);
+} catch {
+  // A malformed Questions or Verify section is the runner's refusal to issue, with its own text.
+  pass();
+}
 
 try {
-  const taskDocument = parseTaskDocument(fs.readFileSync(taskFile, 'utf8'));
-  const taskHash = taskFingerprint(taskDocument.task);
   const projectRunsDir = resolveProjectRunsDir(runsRoot(), input.cwd, { create: false }).dir;
   // Per folder, not per directory: a run folder created a moment before its status.json, or any
   // leftover beside the runs, would otherwise throw out of the whole check and silently disarm the
@@ -131,12 +150,7 @@ try {
   const owner = conflictingOrderOwner(runs, orderId, taskHash);
   if (owner) {
     const ownerDir = path.join(projectRunsDir, owner.run);
-    deny(
-      `Order gate denied the Agent call because order id ${JSON.stringify(orderId)} already belongs ` +
-        `to run folder ${ownerDir} (slug ${owner.status.slug}, started_at ${owner.status.started_at}) ` +
-        'with a different task. Use a new order id, or provide an explicit continuation grant if ' +
-        'this is another pass of that order.',
-    );
+    deny(orderOwnerConflictText(owner, ownerDir, orderId));
   }
 } catch {
   // The 2026-08-15 collision guard is diagnostic: uncertain disk state must not block real work.

package/src/home/hooks/reply-parser.mjs

@@ -1,5 +1,5 @@
 /** Parses dispatcher replies into guard facts. */
-const STATUSES = ['OK', 'FAIL', 'LIMIT'];
+const STATUSES = ['OK', 'FAIL', 'LIMIT', 'UNAVAILABLE'];
 
 /**
  * Either line names the run folder. `RUN=` is printed by the call that starts a run, `ATTACH=`

package/src/home/lib/command-path.mjs

@@ -0,0 +1,32 @@
+/**
+ * Finds a command on PATH the way the host shell would, without starting it.
+ * The runner and CLI share this home module because the home never imports cli/ (Plan_60 D2).
+ */
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+export function envValue(env, name) {
+  const key = Object.keys(env).find((entry) => entry.toLowerCase() === name);
+  return key ? env[key] : '';
+}
+
+function pathValue(env) {
+  return envValue(env, 'path');
+}
+
+export function resolveCommandOnPath(name, env = process.env) {
+  const extensions = process.platform === 'win32'
+    ? (env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';')
+    : [''];
+  for (const directory of pathValue(env).split(path.delimiter).filter(Boolean)) {
+    for (const extension of extensions) {
+      const candidate = path.join(path.resolve(directory), `${name}${extension}`);
+      try {
+        if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}

package/src/home/lib/dispatcher-command.mjs

@@ -4,7 +4,7 @@ import {
   extractValue,
   isAbsoluteTaskFilePath,
   isInputPlaceholder,
-  parseContinuationGrant,
+  parseGrant,
   REQUIRED_INPUTS,
 } from './required-inputs.mjs';
 import { firstShellUnsafeSequence } from './shell-unsafe.mjs';
@@ -69,7 +69,9 @@ export function canonicalRunCommand(agentType, promptText) {
   tokens.push('--order-id', quote(inputs.get('order id')));
   tokens.push('--task-file', quote(inputs.get('task file')));
   if (inputs.get('effort')) tokens.push('--effort', quote(inputs.get('effort')));
-  if (parseContinuationGrant(promptText)) tokens.push('--continue');
+  // Plan_75 D1, TradeForge capacity incident: forward either grant; the runner owns conflicting-grant refusal.
+  const grant = parseGrant(promptText);
+  if (grant?.kind || grant?.error) tokens.push('--continue');
   return { command: tokens.join(' ') };
 }
 

package/src/home/lib/kernel-lock.mjs

@@ -0,0 +1,171 @@
+/**
+ * Locks the kernel releases on its holder's death, shared by the lifecycle lock and the order claim.
+ * Plan_60 D4: on 2026-09-24 two launchers with one order id started 2.8 seconds apart and both ran
+ * and billed; the runner needs the lifecycle lock's primitive and may not import `cli/`.
+ * Where the kernel can release a lock on the holder's death, the lock is a kernel object: a named
+ * pipe on Windows, an abstract socket on Linux — both reproduced on real machines (hard kill, name
+ * free at once, nothing on disk), which matters on a machine that lost power six times in two weeks.
+ * The name comes from the directory's dev+ino, not its path: aliases must reach the same claim.
+ * A second listen inside the holder must fail, or the platform did not give exclusivity and the
+ * call refuses rather than switch protocols (Plan_65 D5/D8). What the holder answers a waiter is
+ * diagnosis only — it never grants anything.
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+
+const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+export function kernelLockStrategy(platform = process.platform) {
+  if (platform === 'win32') return 'named-pipe';
+  return platform === 'linux' ? 'abstract-socket' : null;
+}
+
+export function kernelLockAddress(purpose, digest, platform = process.platform) {
+  if (typeof purpose !== 'string' || !/^[a-z][a-z-]*$/.test(purpose)) {
+    throw new TypeError('purpose must match ^[a-z][a-z-]*$');
+  }
+  if (platform === 'win32') return `\\\\.\\pipe\\codex-bridge-${purpose}-${digest}`;
+  return platform === 'linux' ? `\0codex-bridge-${purpose}-${digest}` : null;
+}
+
+export function directoryDigest(directory, { suffix } = {}) {
+  try {
+    const stat = fs.statSync(directory, { bigint: true });
+    if (!stat.isDirectory()) throw new Error(`${directory} is not a directory`);
+    const identity = `${stat.dev}:${stat.ino}`;
+    const extra = typeof suffix === 'string' && suffix.length > 0 ? `:${suffix}` : '';
+    return createHash('sha256').update(identity + extra).digest('hex');
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function listen(server, address) {
+  return new Promise((resolve, reject) => {
+    const listening = () => { server.removeListener('error', failed); resolve(); };
+    const failed = (error) => { server.removeListener('listening', listening); reject(error); };
+    server.once('listening', listening);
+    server.once('error', failed);
+    try {
+      server.listen(address);
+    } catch (error) {
+      server.removeListener('listening', listening);
+      server.removeListener('error', failed);
+      reject(error);
+    }
+  });
+}
+
+function closeServer(server) {
+  if (!server) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    try {
+      server.close((error) => {
+        if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') reject(error);
+        else resolve();
+      });
+    } catch (error) {
+      if (error.code === 'ERR_SERVER_NOT_RUNNING') resolve();
+      else reject(error);
+    }
+  });
+}
+
+async function closeQuietly(server) {
+  try { await closeServer(server); } catch { /* Preserve the original failure. */ }
+}
+
+async function selfCheck(server, address, createServer, label) {
+  let probe;
+  let detail;
+  try {
+    probe = createServer();
+    await listen(probe, address);
+    detail = 'a second listener succeeded';
+  } catch (error) {
+    if (!error || error.code !== 'EADDRINUSE') detail = (error && (error.code || error.message)) || String(error);
+  }
+  if (detail === undefined) {
+    await closeQuietly(probe);
+    return;
+  }
+  await Promise.all([closeQuietly(probe), closeQuietly(server)]);
+  throw new Error(`${label} self-check failed: ${detail}`);
+}
+
+export async function tryHoldSocket(address, createServer = net.createServer, label = 'kernel lock') {
+  const server = createServer((socket) => socket.destroy());
+  try {
+    await listen(server, address);
+    await selfCheck(server, address, createServer, label);
+    let releasePromise;
+    return () => (releasePromise ??= closeServer(server));
+  } catch (error) {
+    await closeQuietly(server);
+    if (error?.code === 'EADDRINUSE') return 'in-use';
+    throw error;
+  }
+}
+
+function readSocketHolder(address, timeoutMs, parseAnswer) {
+  return new Promise((resolve) => {
+    let data = '';
+    let settled = false;
+    const socket = net.createConnection(address);
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const finish = (holder) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(holder);
+    };
+    socket.on('data', (chunk) => {
+      data += chunk.toString('utf8');
+      const newline = data.indexOf('\n');
+      if (newline !== -1) finish(parseAnswer(data.slice(0, newline)));
+    });
+    socket.once('end', () => finish(parseAnswer(data)));
+    socket.once('error', () => finish(null));
+  });
+}
+
+export async function acquireKernelLock({
+  address, holder, waitMs, retryMs, answerTimeoutMs, parseAnswer, label,
+  createServer = net.createServer,
+}) {
+  const accepted = new Set();
+  const onConnection = (socket) => {
+    accepted.add(socket);
+    socket.once('close', () => accepted.delete(socket));
+    socket.end(`${JSON.stringify(holder)}\n`);
+  };
+  const deadline = Date.now() + waitMs;
+
+  for (;;) {
+    const server = createServer(onConnection);
+    try {
+      await listen(server, address);
+      holder.acquiredAt = new Date().toISOString();
+      await selfCheck(server, address, createServer, label);
+      server.unref();
+      let releasePromise;
+      const release = async () => {
+        const closing = closeServer(server);
+        for (const socket of accepted) socket.destroy();
+        await closing;
+      };
+      return { held: true, release: () => (releasePromise ??= release()) };
+    } catch (error) {
+      await closeQuietly(server);
+      if (!error || error.code !== 'EADDRINUSE') throw error;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) break;
+      await wait(Math.min(retryMs, remaining));
+    }
+  }
+
+  return { held: false, holder: await readSocketHolder(address, answerTimeoutMs, parseAnswer) };
+}

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

@@ -12,6 +12,10 @@ import { createHash } from 'node:crypto';
 import { startedRuns } from './pre-start.mjs';
 import { normalizePath, readJson } from './paths.mjs';
 
+// Plan_75 D5: 2 hashes the header-free body. Runs without this field used earlier schemes:
+// the whole task text, then the task without grant lines (Plan_75 P1).
+export const TASK_HASH_SCHEME = 2;
+
 /**
  * What makes two runs the same task when their names disagree.
  *
@@ -21,6 +25,8 @@ import { normalizePath, readJson } from './paths.mjs';
  * built to refuse. Whitespace and case are normalized away because the same order re-sent
  * through a shell is rewrapped, not rewritten; anything more forgiving would tie together
  * tasks that merely look alike.
+ * Plan_75 D5: the runner supplies the header-free body; every body line counts, including
+ * prose beginning with a grant label. Stripping it again would silently change identity.
  */
 export const taskFingerprint = (taskText) => {
   const normalized = String(taskText ?? '').replace(/\s+/g, ' ').trim().toLowerCase();
@@ -35,14 +41,19 @@ export const taskFingerprint = (taskText) => {
  * honestly, changed nothing and was told it had done no work. Folder names rather than
  * full paths; the current run joins the list as soon as its status.json exists.
  */
-export function chainRuns(runsRoot, repo, slug, taskHash = '', orderId = '') {
+export function chainRuns(runsRoot, repo, slug, taskHash = '', orderId = '', grantRun = '') {
   const wantedRepo = normalizePath(repo);
-  const wantedSlug = String(slug ?? '').trim().toLowerCase();
-  const wantedHash = String(taskHash ?? '').trim().toLowerCase();
-  const wantedOrderId = String(orderId ?? '').trim();
+  if (!wantedRepo) return [];
+  const namedStatus = typeof grantRun === 'string' && grantRun &&
+    !/[\\/]/.test(grantRun) && grantRun !== '.' && grantRun !== '..'
+    ? readJson(path.join(runsRoot, grantRun, 'status.json')) : null;
+  const namedRun = namedStatus && normalizePath(namedStatus.repo) === wantedRepo ? namedStatus : null;
+  const wantedSlugs = new Set([slug, namedRun?.slug].map((value) => String(value ?? '').trim().toLowerCase()).filter(Boolean));
+  const wantedHashes = new Set([taskHash, namedRun?.task_hash].map((value) => String(value ?? '').trim().toLowerCase()).filter(Boolean));
+  const wantedOrderIds = new Set([orderId, namedRun?.order_id].map((value) => String(value ?? '').trim()).filter(Boolean));
   // No handle on the task, or no repo, means nothing to chain — an empty context must find
   // nothing rather than fall back to "every run in this folder".
-  if (!wantedRepo || (!wantedSlug && !wantedHash && !wantedOrderId)) return [];
+  if (!wantedSlugs.size && !wantedHashes.size && !wantedOrderIds.size) return [];
   let entries;
   try {
     entries = fs.readdirSync(runsRoot, { withFileTypes: true });
@@ -56,9 +67,9 @@ export function chainRuns(runsRoot, repo, slug, taskHash = '', orderId = '') {
     if (!status) continue;
     // Either handle identifies the task. The hash catches a repeat that renamed itself; the
     // slug still catches the follow-up whose wording the orchestrator edited on purpose.
-    const sameSlug = Boolean(wantedSlug) && String(status.slug ?? '').trim().toLowerCase() === wantedSlug;
-    const sameTask = Boolean(wantedHash) && String(status.task_hash ?? '').trim().toLowerCase() === wantedHash;
-    const sameOrder = Boolean(wantedOrderId) && String(status.order_id ?? '').trim() === wantedOrderId;
+    const sameSlug = wantedSlugs.has(String(status.slug ?? '').trim().toLowerCase());
+    const sameTask = wantedHashes.has(String(status.task_hash ?? '').trim().toLowerCase());
+    const sameOrder = wantedOrderIds.has(String(status.order_id ?? '').trim());
     if (!sameSlug && !sameTask && !sameOrder) continue;
     if (normalizePath(status.repo) !== wantedRepo) continue;
     runs.push({ name: entry.name, at: String(status.started_at || '') });

package/src/home/lib/meta/context-only.mjs

@@ -0,0 +1,43 @@
+/**
+ * Judges startup-context references and unread repository coordinates in scout responses.
+ * Plan_60 D1: honest answers about handed context need no command, unlike the 2026-09-16
+ * dead sandbox; a marker must never excuse invented addresses or an unsourced answer.
+ */
+import { QUESTION_KIND } from '../runner/question-kind.mjs';
+
+export function allStartupContext(questions) {
+  return Array.isArray(questions) && questions.length > 0
+    && questions.every((question) => question?.kind === QUESTION_KIND.STARTUP_CONTEXT);
+}
+
+export function contextOnlyGap({ questions, result, commandsExecuted }) {
+  const answers = Array.isArray(result?.answers) ? result.answers : [];
+  const byId = new Map();
+  for (const answer of answers) {
+    const id = String(answer?.question_id || '').trim().toUpperCase();
+    if (id && !byId.has(id)) byId.set(id, answer);
+  }
+  const unsourced = (Array.isArray(questions) ? questions : [])
+    .filter((question) => question?.kind === QUESTION_KIND.STARTUP_CONTEXT)
+    .filter((question) => {
+      const answer = byId.get(String(question.id || '').trim().toUpperCase());
+      return !Array.isArray(answer?.evidence)
+        || !answer.evidence.some((item) => /^startup:\s*\S/.test(String(item ?? '')));
+    })
+    .map((question) => question.id);
+  if (unsourced.length) {
+    return `responses to startup-context questions without a startup:<source> reference: ${unsourced.join(', ')}`;
+  }
+  if (commandsExecuted !== 0) return null;
+  const references = answers.flatMap((answer) => Array.isArray(answer?.evidence) ? answer.evidence : []);
+  references.push(...(Array.isArray(result?.findings) ? result.findings : []).map((finding) => finding?.where));
+  for (const reference of references) {
+    const text = String(reference ?? '');
+    if (text.startsWith('startup:')) continue;
+    const coordinate = text.match(/\S*\.[A-Za-z0-9]+:\d+/)?.[0];
+    if (coordinate) {
+      return `scout cited ${coordinate.slice(0, 60)} without executing a command: an address nobody read`;
+    }
+  }
+  return null;
+}

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

@@ -14,6 +14,15 @@ import { safeSlice } from './paths.mjs';
  */
 const LIMIT_RE = /rate[\s_-]*limit|usage[\s_-]*limit|quota|too many requests|\b429\b/i;
 
+// Plan_60 D2: add a new measured sample only together with its verbatim fixture.
+const UNAVAILABLE_SAMPLES = [
+  {
+    cli: 'codex-cli 0.159.0',
+    measured: '2026-10-03',
+    pattern: /^unexpected status 401 Unauthorized: Missing bearer or basic authentication in header\b/,
+  },
+];
+
 const record = (value) => value && typeof value === 'object' && !Array.isArray(value);
 
 const compact = (value, max = 300) =>
@@ -129,6 +138,8 @@ function transportErrorOf(event) {
   const status = payload.status ?? nested.status ?? null;
   const marker = [errorType, message].join(' ');
   const quota = Number(status) === 429 || LIMIT_RE.test(marker);
+  const unavailable = !quota && event.type === 'turn.failed' &&
+    UNAVAILABLE_SAMPLES.some((sample) => sample.pattern.test(message));
   const reason = compact(
     [errorType, message, status === null || status === undefined ? '' : `status ${status}`]
       .filter(Boolean)
@@ -137,7 +148,7 @@ function transportErrorOf(event) {
       (typeof event.error?.message === 'string' ? event.error.message : '') ||
       event.type,
   );
-  return { event, payload, status, error_type: errorType, message, quota, reason };
+  return { event, payload, status, error_type: errorType, message, quota, unavailable, reason };
 }
 
 /**
@@ -150,7 +161,8 @@ export function readEvents(runDir) {
   const accounting = usageOf(events);
   const started = events.find((event) => event.type === 'thread.started' && event.thread_id);
   const errors = events.map(transportErrorOf).filter(Boolean);
-  const transport_error = errors.find((error) => error.quota) || errors[0] || null;
+  const transport_error = errors.find((error) => error.quota) ||
+    errors.find((error) => error.unavailable) || errors[0] || null;
   return {
     events,
     // The file was written, whatever it holds. Pass 2 judges a run by this: a stream the

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/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-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.