@codedology/code-forge 0.15.3 → 0.16.0

package/src/cli/review-file.mjs

@@ -67,11 +67,14 @@
  * needs its own review.
  */
 
-import { lstatSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { lstatSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, watch } from 'node:fs';
 import path from 'node:path';
-import { answersTicketId, assertAnswers, blockTickets, deliverBlockFindings, dropDoneIf, enqueue, enqueueAnswers, enqueueHash, isDone, liveWorker, MAX_ANSWERS, queueDir, resolveHashTicket, resolveTicket, reviewExclusionFor } from '../worker/queue.mjs';
+import { setTimeout as delay } from 'node:timers/promises';
+import { answersTicketId, assertAnswers, blockTickets, clearDone, deliverBlockFindings, dropDoneIf, enqueue, enqueueAnswers, enqueueHash, isDone, liveWorker, MAX_ANSWERS, queueDir, resolveHashTicket, resolveTicket, reviewExclusionFor } from '../worker/queue.mjs';
 import { assertBlockId, assertInsideRoot, assertTicketId, contentHash, mainRootOf, normalizeRequestPath, repoRootOf, WorkerError } from '../worker/ticket.mjs';
-import { changedFiles, namedOnHash } from '../review/gate-check.mjs';
+import { changedFiles, checkBlockReviews, namedOnHash, ownsAt } from '../review/gate-check.mjs';
+import { AUTO_REQUEUE_REASON, isAutomaticReopen, reopenFile, stopContentHash } from '../review/reopen.mjs';
+import { loadState } from '../worker/review-state.mjs';
 import { STOP_EXITS } from '../review/stop-exits.mjs';
 import { budgetFor } from '../review/packet.mjs';
 import { ownsFile } from '../state/registry.mjs';
@@ -79,12 +82,15 @@ import { appendRow, readAllRows } from '../ledger/write.mjs';
 import { parseFlags } from '../state/cli-args.mjs';
 import { StateError } from '../state/paths.mjs';
 import { assertRunId } from '../state/paths.mjs';
-import { readRun } from '../state/run.mjs';
+import { readRun, writeSigned } from '../state/run.mjs';
+import { loadKey } from '../state/signer.mjs';
 import { rebaseBlock } from '../state/block.mjs';
 import { configInForce } from '../state/config-snapshot.mjs';
 import { reviewExcludeRule } from '../config/validate.mjs';
 import { blockTree } from '../proof/worktree.mjs';
 import { writeSafe } from '../util/redact.mjs';
+import { daemonRequest } from '../util/native.mjs';
+import { runRootPath } from '../util/tmp.mjs';
 
 const USAGE =
   'usage: code-forge review-file [--cwd <dir>] <path> --block <id> [--run <id>] [--fresh] | review-file --wait <ticket> [--max <seconds>s]\n' +
@@ -510,13 +516,64 @@ function ticketTimings(value) {
     .filter((key) => value && Object.hasOwn(value, key)).map((key) => [key, value[key]]));
 }
 
+/** Restart only verified stopped reviews whose findings were not waived and whose bytes changed.
+ * Shared by the join and close; ordinary progress polling needs no signing key.
+ * @param {{repoRoot: string, run: string, block: string, tree: string, files: string[], print: (line: string) => unknown}} opts
+ * @returns {Promise<Map<string, string>>} restart timestamp by file
+ */
+export async function requeueStoppedFiles({ repoRoot, run, block, tree, files, print }) {
+  const restarted = new Map();
+  if (files.length === 0) return restarted;
+  const record = await readRun(run);
+  const entry = record.blocks?.[block];
+  if (entry?.status !== 'open') return restarted;
+  if (realpathSync(await mainRootOf(record.workspace)) !== realpathSync(repoRoot)) throw new WorkerError('other-workspace', 'the run belongs to another workspace');
+  const recordedTree = (await blockTree(record.workspace, entry))?.top ?? repoRoot;
+  if (realpathSync(recordedTree) !== realpathSync(tree)) throw new WorkerError('worktree-mismatch', 'the block scope does not match the recorded content tree');
+  const owns = ownsAt(path.relative(realpathSync(repoRoot), realpathSync(record.workspace)).split(path.sep).join('/'));
+  const key = await loadKey(run);
+  const rows = (await readAllRows(record.project)).filter((row) => row.run === run);
+  const root = configInForce(record)?.tmp?.root;
+  const runRootDir = runRootPath(run, root == null ? {} : { root });
+  const where = realpathSync(tree) === realpathSync(repoRoot) ? {} : { tree: realpathSync(tree) };
+  const writeRow = (row) => appendRow(row, { slug: record.project });
+  for (const file of files) {
+    if (!owns(entry.owned_files, file, entry.owned_kinds) || reviewExcludeRule(configInForce(record), file) !== null) continue;
+    if (Object.entries(record.blocks).some(([id, other]) => id !== block && other.status === 'open' && owns(other.owned_files, file, other.owned_kinds))) continue;
+    const loaded = loadState({ runId: run, block, file, key, rows, runRootDir, contentRoot: tree, migrate: false });
+    if (!['ok', 'restored'].includes(loaded.status) || loaded.state?.status !== 'stopped' || !loaded.state.open?.length) continue;
+    const fromHash = stopContentHash(loaded.state, rows, { runId: run, block, file, key });
+    const currentHash = contentHash(tree, file);
+    if (fromHash === null || fromHash === currentHash) continue;
+    // A newer accepted review wins over a stopped snapshot. At the stopped hash, use the
+    // same waiver rules as the gate, including severity and signature checks.
+    const needsReview = (hash) => checkBlockReviews({ runId: run, block, key,
+      rows: rows.filter((row) => row.file === undefined || row.file === file),
+      files: [{ file, content_hash: hash }], proofFiles: [], highPaths: [],
+    }).refusals.some((value) => value.file === file && ['unreviewed', 'unsigned', 'not_approved', 'review_cap', 'autopilot_waiver_invalid'].includes(value.code));
+    if (!needsReview(currentHash) || !needsReview(fromHash)) continue;
+    const result = await reopenFile({ runId: run, id: block, file, reason: AUTO_REQUEUE_REASON,
+      record, rows, key, writeRow, writeSigned, automatic: true,
+      io: {
+        owns, loadState: () => loaded, contentHash: (f) => contentHash(tree, f),
+        clearDone: (f) => clearDone({ repoRoot, run, block, file: f, ...where }).removed,
+        enqueue: (f, row) => enqueue({ repoRoot, run, block, file: f, ...where, after: row.ts }).ticket,
+      },
+    });
+    restarted.set(file, result.row.ts);
+    if (!result.existing) print(`auto-requeue ${file}: content changed after stopped review (ticket ${result.ticket})\n`);
+  }
+  return restarted;
+}
+
 /**
- * A block wait uses unsigned results only to classify retries; it never reads the signing key.
+ * Ordinary block progress uses unsigned results. Restarting changed stopped findings verifies
+ * the durable state and writes a signed restart before queuing the new attempt.
  * Re-scan metadata each poll and read content only after its stamp changes. Deliver unseen findings of the newest earlier ticket
- * before rechecking a blind edit; the next join queues the fix. Stopped files stay finished.
- * @param {{repoRoot: string, cwd: string, block: string, run: string, maxMs: number, pollMs: number, say: (obj: Record<string, any>) => unknown, dropDone?: typeof dropDoneIf, now?: () => number, sleep?: (ms: number) => Promise<unknown>}} opts
+ * before rechecking a blind edit; the next join queues the fix. Changed stopped findings restart.
+ * @param {{repoRoot: string, cwd: string, block: string, run: string, maxMs: number, pollMs: number, say: (obj: Record<string, any>) => unknown, print: (line: string) => unknown, dropDone?: typeof dropDoneIf, now?: () => number, sleep?: (ms: number, signal?: AbortSignal) => Promise<unknown>}} opts
  */
-async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, dropDone = dropDoneIf, now = Date.now, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)) }) {
+async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, print, dropDone = dropDoneIf, now = Date.now, sleep = (ms, signal) => delay(ms, undefined, { signal }).catch((err) => { if (err.name !== 'AbortError') throw err; }) }) {
   let scope = await waitBlockScope(repoRoot, cwd, run, block);
   const { tree } = scope;
   const gitPaths = waitGitPaths(tree);
@@ -531,7 +588,43 @@ async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, dropDo
   const hashes = new Map();
   let downPolls = 0;
   const deliveredHere = new Set();
+  let changed = false;
+  /** @type {(() => void) | null} */
+  let wake = null;
+  /** @type {import('node:fs').FSWatcher | undefined} */
+  let watcher;
+  const notify = () => { changed = true; wake?.(); };
+  // Install before scanning so a completion between the scan and the wait is retained.
+  // Queue .done markers are already published after their results, on macOS and Linux.
+  try {
+    watcher = watch(queueDir(repoRoot), (_event, name) => {
+      if (name === null || String(name).endsWith('.done')) notify();
+    });
+    watcher.on('error', () => { watcher.close(); notify(); });
+  } catch { /* unavailable watches retain the existing backoff polling */ }
+  try {
   for (;;) {
+    changed = false;
+    scope = await waitBlockScope(repoRoot, cwd, run, block, scope);
+    // Keep one daemon join for the remaining deadline: it retains findings already
+    // delivered while other files are pending, just like deliveredHere below.
+    const answer = await daemonRequest(run, { method: 'wait-block', block, max_ms: Math.max(0, deadline - now()) }, { config: scope.cfg });
+    // A stopped review may need a signed automatic reopen. Keep that mutation
+    // on the existing Node path; ordinary pending/completed polls stay read-free.
+    if (answer && !answer.files.some((/** @type {Record<string, any>} */ file) => file.outcome === 'stopped')) {
+      if (answer.reason === 'wait_timeout' && now() < deadline) continue;
+      // Go serializes map keys alphabetically; retain the CLI's byte order.
+      const files = answer.files.map((/** @type {Record<string, any>} */ f) => ({
+        file: f.file, ticket: f.ticket, status: f.status, outcome: f.outcome,
+        ...(f.rule !== undefined ? { rule: f.rule } : {}), ...ticketTimings(f),
+      }));
+      say({ block, files, done: answer.done,
+        ...(answer.status !== undefined ? { status: answer.status } : {}),
+        ...(answer.reason !== undefined ? { reason: answer.reason } : {}),
+        ...(answer.next !== undefined ? { next: answer.next } : {}),
+      });
+      return answer.status === 'worker_down' ? 3 : 0;
+    }
     const worker = liveWorker(repoRoot);
     const live = worker?.run === run;
     downPolls = live ? 0 : downPolls + 1;
@@ -543,6 +636,12 @@ async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, dropDo
       current = (await changedFiles({ repoRoot: tree, base: entry.base_sha })).filter((file) => ownsFile(entry.owned_files, file, entry.owned_kinds));
       treeStamp = stamp;
     }
+    const stopped = current.filter((file) => {
+      const latest = tickets.filter((ticket) => ticket.file === file).at(-1);
+      return latest && blockTicketMarker(repoRoot, latest.ticket)?.status === 'stopped'
+        && doneResult(repoRoot, latest.ticket)?.findings?.length > 0;
+    });
+    const restarted = live ? await requeueStoppedFiles({ repoRoot, run, block, tree, files: stopped, print }) : new Map();
     // Progress only, like answersPrecheck: sandboxed callers may not read the private ledger.
     // Reopens issued here also renew the workspace ticket, which needs no private read to join.
     let rows = [];
@@ -550,9 +649,10 @@ async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, dropDo
     const reopens = new Map();
     for (const row of rows) {
       if (row.event !== 'review.reopened' || row.run !== run || row.block !== block || !Number.isFinite(Date.parse(row.ts))) continue;
-      if (row.by !== 'human' && !(row.by === 'agent' && row.verdict?.verdict === 'agree')) continue;
+      if (row.by !== 'human' && !(row.by === 'agent' && row.verdict?.verdict === 'agree') && !isAutomaticReopen(row)) continue;
       if (!reopens.has(row.file) || row.ts > reopens.get(row.file)) reopens.set(row.file, row.ts);
     }
+    for (const [file, ts] of restarted) reopens.set(file, ts);
     const files = current.map((file) => {
       const rule = reviewExcludeRule(cfg, file);
       if (rule !== null) return { file, ticket: null, status: 'excluded', outcome: null, rule };
@@ -594,6 +694,11 @@ async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, dropDo
       say({ block, files, done: false, reason: 'split_required', next: `The owner raises review.budgets for ${split.file}, runs run reload, then review-file ${split.file} --fresh.` });
       return 0;
     }
+    const unavailable = files.find((f) => f.outcome === 'unavailable');
+    if (live && unavailable) {
+      say({ block, files, done: false, reason: 'review_unavailable', next: `review-file ${unavailable.file} --fresh re-runs it; if --fresh refuses, block reopen ${block} --run ${run} --file ${unavailable.file} --reason <text>` });
+      return 0;
+    }
     if (live && files.every((f) => f.status === 'done' || f.status === 'findings' || f.status === 'excluded')) {
       say({ block, files, done: true });
       return 0;
@@ -604,15 +709,22 @@ async function waitBlock({ repoRoot, cwd, block, run, maxMs, pollMs, say, dropDo
     }
     const ticketIds = [...new Set([...tickets.map((t) => t.ticket), ...files.map((f) => f.ticket).filter(Boolean)])].sort();
     const state = JSON.stringify([stamp, live, ticketIds, files]);
-    interval = seen === state ? Math.min(MAX_IDLE_MS, interval * 2) : pollMs;
-    seen = state;
-    await sleep(Math.min(interval, Math.max(0, deadline - now())));
+    if (!changed) {
+      interval = seen === state ? Math.min(MAX_IDLE_MS, interval * 2) : pollMs;
+      seen = state;
+      const abort = new AbortController();
+      try {
+        const event = new Promise((resolve) => { wake = () => resolve(undefined); });
+        await Promise.race([event, sleep(Math.min(interval, Math.max(0, deadline - now())), abort.signal)]);
+      } finally { wake = null; abort.abort(); }
+    }
   }
+  } finally { watcher?.close(); }
 }
 
 /**
  * @param {string[]} args
- * @param {{stdout?: {write: (s: string) => unknown}, stderr?: {write: (s: string) => unknown}, cwd?: string, pollMs?: number, dropDone?: typeof dropDoneIf, now?: () => number, sleep?: (ms: number) => Promise<unknown>}} [deps] - `dropDone`: B75's claim, for tests.
+ * @param {{stdout?: {write: (s: string) => unknown}, stderr?: {write: (s: string) => unknown}, cwd?: string, pollMs?: number, dropDone?: typeof dropDoneIf, now?: () => number, sleep?: (ms: number, signal?: AbortSignal) => Promise<unknown>}} [deps] - `dropDone`: B75's claim, for tests.
  * @returns {Promise<number>}
  */
 export async function runReviewFile(args, deps = {}) {
@@ -652,7 +764,7 @@ export async function runReviewFile(args, deps = {}) {
       if (positionals.length > 0 || flags.block !== undefined || flags.wait !== undefined || flags.answers !== undefined || flags.of !== undefined || flags.fresh === true || typeof flags.run !== 'string') {
         throw new WorkerError('usage', '--wait-block takes a block, --run and --max only');
       }
-      return await waitBlock({ repoRoot, cwd, block: assertBlockId(flags['wait-block']), run: assertRunId(flags.run), maxMs: flags.max === undefined ? DEFAULT_WAIT_MS : parseMax(flags.max), pollMs: deps.pollMs ?? POLL_MS, say, dropDone: deps.dropDone, now: deps.now, sleep: deps.sleep });
+      return await waitBlock({ repoRoot, cwd, block: assertBlockId(flags['wait-block']), run: assertRunId(flags.run), maxMs: flags.max === undefined ? DEFAULT_WAIT_MS : parseMax(flags.max), pollMs: deps.pollMs ?? POLL_MS, say, print: (line) => writeSafe(stderr, line), dropDone: deps.dropDone, now: deps.now, sleep: deps.sleep });
     }
 
     if (typeof flags.wait === 'string') {

package/src/cli/spawn.mjs

@@ -1,9 +1,10 @@
 /**
  * `code-forge spawn --level L<n> --role <role> --brief <file> [--schema <file>] [--cwd <dir>]
- *   [--run <id>] [--block <id>] [--timeout <s>] [--background]` (plan §5.2; block B9a).
+ *   [--run <id>] [--block <id>] [--timeout <s>] [--background] [--print-argv]` (plan §5.2; block B9a).
  *
  * Runs one isolated session through `src/session/spawn.mjs` and prints its result as one JSON line
  * on stdout; the `level=… provider=… model=… effort=… fallback_step=…` line goes to stderr.
+ * With `--print-argv`, prints the first step's argv and metadata instead of launching a session.
  * Exit codes: 0 ok / started, 1 failed (timeout, bad output, refused), 2 usage, 3 unavailable
  * (every step of the ladder reported unavailability).
  *
@@ -17,7 +18,7 @@
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { loadProjectConfig, projectRootFor, slugFor } from '../config/load.mjs';
-import { ROLES, runRootFor, SessionError, spawnSession } from '../session/spawn.mjs';
+import { previewArgv, ROLES, runRootFor, SessionError, spawnSession } from '../session/spawn.mjs';
 import { intFlag, parseFlags } from '../state/cli-args.mjs';
 import { StateError } from '../state/paths.mjs';
 import { readRun } from '../state/run.mjs';
@@ -43,7 +44,7 @@ async function readJSONFlag(file, flag) {
   }
 }
 
-const USAGE = `usage: code-forge spawn --level L0|L1|L2|L3 --role ${ROLES.join('|')} --brief <file> [--schema <file>] [--cwd <dir>] [--run <id>] [--block <id>] [--timeout <seconds>] [--background]\n`;
+const USAGE = `usage: code-forge spawn --level L0|L1|L2|L3 --role ${ROLES.join('|')} --brief <file> [--schema <file>] [--cwd <dir>] [--run <id>] [--block <id>] [--timeout <seconds>] [--background] [--print-argv]\n`;
 
 /**
  * @param {{status: string}} result
@@ -93,8 +94,8 @@ export async function runSpawn(args, deps = {}) {
   const stdout = deps.stdout ?? process.stdout;
   const stderr = deps.stderr ?? process.stderr;
   try {
-    const { flags, positionals } = parseFlags(args, { values: ['level', 'role', 'brief', 'schema', 'cwd', 'run', 'block', 'timeout'], booleans: ['background'] });
-    if (positionals.length > 0 || typeof flags.level !== 'string' || typeof flags.role !== 'string' || typeof flags.brief !== 'string') {
+    const { flags, positionals } = parseFlags(args, { values: ['level', 'role', 'brief', 'schema', 'cwd', 'run', 'block', 'timeout'], booleans: ['background', 'print-argv'] });
+    if (positionals.length > 0 || typeof flags.level !== 'string' || typeof flags.role !== 'string' || typeof flags.brief !== 'string' || (flags['print-argv'] && flags.background)) {
       writeSafe(stderr, USAGE);
       return 2;
     }
@@ -111,23 +112,26 @@ export async function runSpawn(args, deps = {}) {
     const runRootDir = typeof flags.run === 'string' ? runRootFor(flags.run, loaded.config?.tmp?.root) : undefined;
     // B93: only a coder reads coder.sandbox, so only a coder session is held to the run-start value
     const cfg = typeof flags.run === 'string' && flags.role === 'coder' ? await checkRunSandbox(loaded.config, flags.run) : loaded.config;
-    const result = await spawnSession(
-      {
-        cfg,
-        level: /** @type {any} */ (flags.level),
-        role: /** @type {any} */ (flags.role),
-        promptPath: path.resolve(flags.brief),
-        cwd: typeof flags.cwd === 'string' ? path.resolve(flags.cwd) : undefined,
-        schema,
-        timeoutMs: timeout === undefined ? undefined : timeout * 1000,
-        background: flags.background === true,
-        runRoot: runRootDir,
-        run: typeof flags.run === 'string' ? flags.run : undefined,
-        block: typeof flags.block === 'string' ? flags.block : undefined,
-        slug: slugFor(cfg, root),
-      },
-      { ...deps, stderr },
-    );
+    const opts = {
+      cfg,
+      level: /** @type {any} */ (flags.level),
+      role: /** @type {any} */ (flags.role),
+      promptPath: path.resolve(flags.brief),
+      cwd: typeof flags.cwd === 'string' ? path.resolve(flags.cwd) : undefined,
+      schema,
+      timeoutMs: timeout === undefined ? undefined : timeout * 1000,
+      background: flags.background === true,
+      runRoot: runRootDir,
+      run: typeof flags.run === 'string' ? flags.run : undefined,
+      block: typeof flags.block === 'string' ? flags.block : undefined,
+      slug: slugFor(cfg, root),
+    };
+    if (flags['print-argv']) {
+      const preview = await previewArgv(opts, { ...deps, stderr });
+      writeSafe(stdout, `${JSON.stringify(preview)}\n`);
+      return 0;
+    }
+    const result = await spawnSession(opts, { ...deps, stderr });
     const { text: _text, ...shown } = /** @type {Record<string, any>} */ (result);
     writeSafe(stdout, `${JSON.stringify(shown)}\n`);
     return exitCodeFor(result);

package/src/cli/status.mjs

@@ -15,11 +15,12 @@
  *
  * Text: at most {@link STATUS_MAX_LINES} lines per run, runs separated by one blank line:
  *   run <id> · <status> · <plan|brief> · spent $<x>[ of $<budget>]
- *   <id> <state> <level> · <model or -> · gate <pass|fail|none>[ (<gate>)] · findings <n>
+ *   <id> <state> <level> · <model or -> · gate <pass|fail|timeout|none>[ (<gate>)] · findings <n>
  *   … +<k> more blocks                  (only when the open blocks do not fit)
  *   closed <a> · stopped <b>            (only when any exist; printed last, but block lines are
  *                                        dropped first to keep it inside the cap)
- * The gate field is `gate pass`, `gate fail (<gate>)`, `gate fail` (no gate named) or `gate none`.
+ * The gate field is `gate pass`, `gate fail (<gate>)`, `gate timeout (<gate>)`, `gate fail`
+ * (no gate named) or `gate none`.
  * `<x>` is `run status`'s spent_usd with 2 decimals, followed by `+?` when some session has no
  * known price (`run status`'s unknown_usd_sessions > 0); the whole amount is `$?` when the ledger
  * cannot be read. A run record with no status shows `-`.
@@ -54,9 +55,12 @@ import { budgetUsdOf } from '../ledger/spend.mjs';
 import { readAllRows } from '../ledger/write.mjs';
 import { findingsKey, openFindingsOf } from '../review/open-findings.mjs';
 import { briefStatus } from '../state/brief-status.mjs';
+import { configInForce } from '../state/config-snapshot.mjs';
 import { parseFlags } from '../state/cli-args.mjs';
 import { runsDir, StateError } from '../state/paths.mjs';
 import { readRun } from '../state/run.mjs';
+import { unpinnedWorkerWarnings } from '../worker/worker-warning.mjs';
+import { daemonRequest } from '../util/native.mjs';
 import { writeSafe } from '../util/redact.mjs';
 
 const USAGE = 'usage: code-forge status [--run <id>] [--json]\n';
@@ -65,7 +69,8 @@ const USAGE = 'usage: code-forge status [--run <id>] [--json]\n';
 const STATUS_MAX_LINES = 10;
 
 /**
- * @typedef {import('../state/brief-status.mjs').RunStatus & {awaiting_human_check?: string[]}} RunStatus
+ * @typedef {Omit<import('../state/brief-status.mjs').BlockStatus, 'gate'> & {gate: {result: 'pass'|'fail'|'timeout'|'none', name: string | null}}} BlockStatus
+ * @typedef {Omit<import('../state/brief-status.mjs').RunStatus, 'blocks'> & {blocks: BlockStatus[], awaiting_human_check?: string[]}} RunStatus
  */
 
 /** @param {string} p @returns {Promise<string>} */
@@ -77,18 +82,46 @@ async function realOr(p) {
   }
 }
 
+/** Recover timeout reasons from the last gate run, including older rows without timed_out.
+ * @param {RunStatus} summary @param {Array<Record<string, any>> | null} rows
+ * @returns {RunStatus}
+ */
+function timeoutStatus(summary, rows) {
+  const pending = new Set(), timedOut = new Set();
+  for (const row of rows ?? []) {
+    if (row.run !== summary.run_id || typeof row.block !== 'string') continue;
+    if (row.event === 'gate.red') {
+      if (row.reason === 'timeout' || row.timed_out === true) {
+        pending.add(row.block);
+        timedOut.add(row.block);
+      } else {
+        pending.delete(row.block);
+        timedOut.delete(row.block);
+      }
+    } else if (row.event === 'gate.done') {
+      if (row.all_ok === true || !pending.has(row.block)) timedOut.delete(row.block);
+      pending.delete(row.block);
+    }
+  }
+  return { ...summary, blocks: summary.blocks.map((block) => block.gate.result === 'fail' && timedOut.has(block.id)
+    ? { ...block, gate: { ...block.gate, result: 'timeout' } } : block) };
+}
+
 /**
  * The status data of one run.
  * @param {Record<string, any>} record
+ * @param {Array<Record<string, any>> | null | undefined} [cachedRows] - daemon's incrementally read ledger
  * @returns {Promise<RunStatus>}
  */
-async function statusOf(record) {
+export async function statusOf(record, cachedRows) {
   /** @type {Array<Record<string, any>> | null} null: the ledger cannot be read */
-  let rows = null;
-  try {
-    rows = await readAllRows(record.project);
-  } catch {
-    rows = null;
+  let rows = cachedRows ?? null;
+  if (cachedRows === undefined) {
+    try {
+      rows = await readAllRows(record.project);
+    } catch {
+      rows = null;
+    }
   }
   let budget = null;
   try {
@@ -109,8 +142,24 @@ async function statusOf(record) {
     else byBlock.set(r.block, [r]);
   }
   const awaiting = Object.keys(record.blocks ?? {}).filter((id) => record.blocks[id].status === 'awaiting_human_check').sort();
-  return { ...briefStatus({ record, rows, budget, findingsOf: (block) => openFindingsOf({ block, runId, mine: byBlock.get(block) ?? [], rows: all, key }) }),
-    ...(awaiting.length > 0 ? { awaiting_human_check: awaiting } : {}) };
+  return timeoutStatus({ ...briefStatus({ record, rows, budget, findingsOf: (block) => openFindingsOf({ block, runId, mine: byBlock.get(block) ?? [], rows: all, key }) }),
+    ...(awaiting.length > 0 ? { awaiting_human_check: awaiting } : {}) }, rows);
+}
+
+/** Restore the Node renderer's insertion order after Go's sorted JSON map encoding.
+ * @param {Record<string, any>} s @returns {RunStatus}
+ */
+function daemonStatus(s) {
+  return {
+    run_id: s.run_id, status: s.status, mode: s.mode, spent_usd: s.spent_usd,
+    unknown_usd_sessions: s.unknown_usd_sessions, budget_usd: s.budget_usd,
+    blocks: s.blocks.map((/** @type {Record<string, any>} */ b) => ({
+      id: b.id, state: b.state, level: b.level, model: b.model,
+      gate: { result: b.gate.result, name: b.gate.name }, findings: b.findings,
+    })),
+    more: s.more, closed: s.closed, stopped: s.stopped,
+    ...(s.awaiting_human_check ? { awaiting_human_check: s.awaiting_human_check } : {}),
+  };
 }
 
 /**
@@ -155,7 +204,7 @@ export function runLines(s) {
   const lines = [`run ${s.run_id} · ${s.status ?? '-'} · ${s.mode} · spent ${spent}${s.budget_usd !== null ? ` of ${usd(s.budget_usd)}` : ''}`];
   const tally = s.closed + s.stopped > 0 ? `closed ${s.closed} · stopped ${s.stopped}` : null;
   const awaiting = s.awaiting_human_check?.length ? `awaiting_human_check: ${JSON.stringify(s.awaiting_human_check)}` : null;
-  const room = STATUS_MAX_LINES - 1 - (tally === null ? 0 : 1) - (awaiting === null ? 0 : 1);
+  const room = STATUS_MAX_LINES - lines.length - (tally === null ? 0 : 1) - (awaiting === null ? 0 : 1);
   const shown = s.blocks.length <= room ? s.blocks : s.blocks.slice(0, room - 1);
   for (const b of shown) {
     lines.push(`${b.id} ${b.state} ${b.level ?? '-'} · ${b.model ?? '-'} · gate ${b.gate.result}${b.gate.name ? ` (${b.gate.name})` : ''} · findings ${b.findings}`);
@@ -198,9 +247,26 @@ export default async function status(args) {
       records = await activeRunsFor(projectRootFor(process.cwd()));
     }
     const shown = [];
-    for (const record of records) shown.push(await statusOf(record));
+    for (const record of records) {
+      let config;
+      try {
+        config = configInForce(record);
+        if (!config) {
+          const loaded = await loadProjectConfig(record.workspace);
+          config = loaded.ok ? loaded.config : { native: { daemon: false } };
+        }
+      } catch { config = { native: { daemon: false } }; }
+      const answer = await daemonRequest(String(record.run_id), { method: 'status' }, { config });
+      let summary;
+      try { summary = answer ? daemonStatus(answer.runs[0]) : null; } catch { summary = null; }
+      if (summary?.blocks.some((block) => block.gate.result === 'fail')) {
+        summary = timeoutStatus(summary, await readAllRows(record.project).catch(() => null));
+      }
+      shown.push(summary ?? await statusOf(record));
+      for (const warning of await unpinnedWorkerWarnings(record)) err(`${warning}\n`);
+    }
     if (json) {
-      out(`${JSON.stringify({ runs: shown })}\n`); // briefStatus builds exactly the clause-3 run object
+      out(`${JSON.stringify({ runs: shown })}\n`);
       return 0;
     }
     if (shown.length === 0) {

package/src/decide/escalation.mjs

@@ -220,13 +220,13 @@ export function runningCeiling(stopAt = 'L3') {
 
 /**
  * Rules 1, 2b and 2 share this: below the running ceiling ⇒ +1 level (never to L3); at the
- * running ceiling ⇒ rule 5, the block's one L3 rung (R1), then `stop`.
+ * running ceiling ⇒ rule 5, the file's one L3 rung (R1), then `stop`.
  * @param {'retries'|'review_rounds'|'review_stall'|'review_warnings'} trigger
  * @param {string} currentLevel
  * @param {string} stopAt
  * @param {'patch'|'code'} l3Mode
- * @param {boolean} l3RungAlreadyUsed - the L3 rung was already used once on THIS block, in
- *   EITHER mode and from either rule 5 or rule 6 (one rung per block, not per trigger). A second
+ * @param {boolean} l3RungAlreadyUsed - the L3 rung was already used once on THIS file, in
+ *   EITHER mode and from either rule 5 or rule 6 (one rung per file, not per trigger). A second
  *   hit always stops.
  * @returns {EscalationResult}
  */
@@ -270,8 +270,8 @@ function finalizeEscalate(trigger, currentLevel, stopAt, l3Mode, l3RungAlreadyUs
  * @property {string} [stopAt] - `escalation.stop_at`, default `'L3'`.
  * @property {'patch'|'code'} [l3Mode] - `escalation.l3_mode`, default `'patch'` (R1).
  * @property {boolean} [l3RungAlreadyUsed] - the L3 rung (ceiling, rule 5, OR the file's review
- *   cap, rule 6) was already used once before on THIS block, from either source. A second hit
- *   always `stop`s — the plan's L3 rung is one per block, not one per trigger.
+ *   cap, rule 6) was already used once before on THIS file, from either source. A second hit
+ *   always `stop`s — the plan's L3 rung is one per file, not one per trigger.
  * @property {number} [roundsAtFile] - rule 6 (v1.3, §4.11): total review rounds run on this file
  *   so far, counted across every level — unlike `reviewRoundsAtLevel`, this is never reset by a
  *   level escalation.

package/src/doctor/index.mjs

@@ -11,6 +11,8 @@ import { mkdirSync, rmSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { cliNameForProvider } from '../engines/provider-cli.mjs';
+import { readAllRows } from '../ledger/write.mjs';
+import { modelStats, reviewerLines } from '../review/model-stats.mjs';
 import { newRunId } from '../state/paths.mjs';
 import { runRoot } from '../util/tmp.mjs';
 import { checkCommands, checkConfig, checkJev, checkKeys, checkLedger, checkLinks, checkLocks, checkReviewConcurrency, checkReviewState, checkTmp, checkTools } from './local.mjs';
@@ -53,6 +55,15 @@ export async function runDoctor(opts = {}, deps = {}) {
   const keys = await checkKeys(cfg, { env, store: deps.store, opRead: deps.opRead });
   /** @type {Row[]} */
   const rows = [...checked.rows, ...links, ...keys.rows];
+  if (cfg?.project?.slug) {
+    try {
+      const lines = reviewerLines(modelStats(await readAllRows(cfg.project.slug), cfg.review?.adaptive));
+      rows.push(...lines.map((line, i) => {
+        const at = line.indexOf(': ');
+        return row(`reviewer.${i}`, 'INFO', line.slice(0, at), line.slice(at + 2));
+      }));
+    } catch { /* a corrupt ledger is diagnosed by the existing ledger check */ }
+  }
   if (opts.quick) return rows;
 
   if (cfg) {

package/src/doctor/worker-probe.mjs

@@ -69,7 +69,7 @@ function removeRun(runId) {
   } catch {
     return;
   }
-  for (const name of names) if (name === `${runId}.json` || name === `${runId}.key` || name === `${runId}.lock` || name.startsWith(`${runId}.json.`)) rmSync(path.join(runsDir(), name), { recursive: true, force: true });
+  for (const name of names) if (name === runId || name === `${runId}.json` || name === `${runId}.key` || name === `${runId}.lock` || name.startsWith(`${runId}.json.`)) rmSync(path.join(runsDir(), name), { recursive: true, force: true });
 }
 
 /**