@codedology/code-forge 0.15.3 → 0.15.4

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 };
@@ -604,15 +704,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 +759,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/status.mjs

@@ -54,9 +54,11 @@ 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 { daemonRequest } from '../util/native.mjs';
 import { writeSafe } from '../util/redact.mjs';
 
 const USAGE = 'usage: code-forge status [--run <id>] [--json]\n';
@@ -80,15 +82,18 @@ async function realOr(p) {
 /**
  * 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 {
@@ -113,6 +118,22 @@ async function statusOf(record) {
     ...(awaiting.length > 0 ? { awaiting_human_check: awaiting } : {}) };
 }
 
+/** 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 } : {}),
+  };
+}
+
 /**
  * Every run that is not ended whose workspace is `root`, newest first.
  * @param {string} root
@@ -155,7 +176,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 +219,22 @@ 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; }
+      shown.push(summary ?? await statusOf(record));
+    }
     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/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 });
 }
 
 /**

package/src/review/agent-waiver.mjs

@@ -5,6 +5,7 @@ import { createHash } from 'node:crypto';
 import { DELEGABLE_SEVERITIES, ownsAt, recordedSeverity, waiveFinding } from './gate-check.mjs';
 import { checkFileForm, checkFindingId } from './verb-forms.mjs';
 import { StateError } from '../state/paths.mjs';
+import { readRun } from '../state/run.mjs';
 import { loadKey, verifyRow } from '../state/signer.mjs';
 import { configInForce } from '../state/config-snapshot.mjs';
 import { readAllRows } from '../ledger/write.mjs';
@@ -15,6 +16,10 @@ import { verifyResult } from '../worker/queue.mjs';
 import { resolveLevel } from '../config/known-ids.mjs';
 import { runRootFor, spawnSession } from '../session/spawn.mjs';
 import { spawnWithBrokenFallback } from './session-retry.mjs';
+import { splitLines } from './context.mjs';
+import { grantState } from '../autopilot/grant.mjs';
+import { lastGate } from '../state/brief-status.mjs';
+import { fileBaseline, testScope } from '../gates/expand.mjs';
 
 const SCHEMA = {
   type: 'object', additionalProperties: false, required: ['verdict', 'reason'],
@@ -35,6 +40,15 @@ function refuse(code, detail) {
   throw new StateError(code, `${code}: ${detail}; nothing was recorded`);
 }
 
+/** The checkExpiry grant rule, without lazy expiry writes on a refused waiver.
+ * @param {Record<string, any>} record
+ */
+function activeGrant(record) {
+  const grant = record.autopilot;
+  return record.status === 'active' && grant?.status === 'active'
+    && Number.isFinite(Date.parse(grant.until)) && grantState(grant, new Date()) === 'active';
+}
+
 /** A citation must name a real regular file inside this tree, without following symlinks.
  * @param {string} root @param {string} file @returns {boolean}
  */
@@ -47,16 +61,48 @@ function existsInTree(root, file) {
   }
 }
 
+/** @param {string} reason */
+const evidenceTokens = (reason) => reason.split(/[\s"'`()[\]{},;<>]+/u).filter(Boolean);
+
+/** Numbered windows for the first ten readable repo citations, never following a link out.
+ * Each window includes ten lines either side, clipped to the file and eighty lines total.
+ * @param {string} reason @param {string} root
+ */
+export function citedEvidence(reason, root) {
+  const evidence = [];
+  for (const token of evidenceTokens(reason)) {
+    const match = /^(.+):([1-9][0-9]*)(?:-([1-9][0-9]*))?[.!?]?$/.exec(token);
+    if (!match) continue;
+    const first = Number(match[2]);
+    const last = Number(match[3] ?? match[2]);
+    if (!Number.isSafeInteger(first) || !Number.isSafeInteger(last) || last < first) continue;
+    try {
+      const file = assertRowPath(match[1]);
+      const bytes = readRegularFileNoFollow(root, file);
+      if (bytes === null) continue;
+      const lines = splitLines(bytes.toString('utf8'));
+      if (first > lines.length) continue;
+      const start = Math.max(1, first - 10);
+      const end = Math.min(lines.length, last + 10, start + 79);
+      const content = lines.slice(start - 1, end).map((line, i) => `${start + i}| ${line}`).join('\n');
+      evidence.push({ path: file, start, end, content });
+      if (evidence.length === 10) break;
+    } catch {
+      // Invalid, missing, unreadable and escaping citations never become packet content.
+    }
+  }
+  return evidence;
+}
+
 /** @param {string} reason @param {string} root @param {Record<string, any>} entry */
 export function hasEvidence(reason, root, entry) {
+  if (citedEvidence(reason, root).length > 0) return true;
   for (const match of reason.matchAll(/\bclause\s+([0-9]+)\b/gi)) {
     const n = Number(match[1]);
     if (n >= 1 && n <= (Array.isArray(entry.acceptance) ? entry.acceptance.length : 0)) return true;
   }
-  const tokens = reason.split(/[\s"'`()[\]{},;<>]+/u).filter(Boolean);
+  const tokens = evidenceTokens(reason);
   for (const token of tokens) {
-    const line = /^(.+):([1-9][0-9]*)[.!?]?$/.exec(token);
-    if (line && existsInTree(root, line[1])) return true;
     const file = token.replace(/[.!?]+$/, '');
     const testFile = /(^|\/)(?:test|tests|__tests__)\//.test(file) || /(?:^|[./_-])(?:test|spec)\.[^/]+$/.test(file) || entry.test_files?.includes(file);
     if (testFile && existsInTree(root, file)) return true;
@@ -64,6 +110,37 @@ export function hasEvidence(reason, root, entry) {
   return false;
 }
 
+/** Require a cited acceptance test measured by the latest signed gate at these exact bytes.
+ * Gate rows summarize test success, not individual assertions; only full or known related
+ * scopes prove that the cited file ran. A changed scope does not record its file list.
+ * @param {string} reason @param {string} root @param {Record<string, any>} entry
+ * @param {Record<string, any>[]} rows @param {string} id @param {Buffer} key
+ */
+async function passingAcceptanceTest(reason, root, entry, rows, id, key) {
+  const named = new Set((entry.acceptance ?? []).flatMap((clause) => clause.tests ?? []));
+  const cited = evidenceTokens(reason).map((token) => token.replace(/:[1-9][0-9]*(?:-[1-9][0-9]*)?[.!?]?$/, '').replace(/[.!?]+$/, ''))
+    .filter((file) => named.has(file) && existsInTree(root, file));
+  if (cited.length === 0) refuse('waive-yes-critical-no-test', 'cite an existing test file named in this block\'s acceptance tests');
+  const mine = rows.filter((row) => row.block === id);
+  const latest = mine.filter((row) => row.event === 'gate.done' || row.event === 'gate.red').at(-1);
+  if (!latest || !verifyRow(latest, key).ok || lastGate(mine).result !== 'pass'
+    || latest.worktree !== entry.worktree?.path
+    || !Array.isArray(latest.results)
+    || !latest.results.some((result) => result.gate === 'test' && result.ok === true && result.skipped === false)) {
+    refuse('waive-yes-critical-no-test', 'the cited acceptance test needs a passing test result in this block\'s latest signed gate record');
+  }
+  const current = await fileBaseline(root, entry.owned_files ?? [], entry.owned_kinds);
+  if (!current || !latest.files || Object.keys(current.files).length !== Object.keys(latest.files).length
+    || Object.entries(current.files).some(([file, hash]) => latest.files[file] !== hash)) {
+    refuse('waive-yes-critical-no-test', 'rerun the acceptance test: the latest gate record does not cover the current block content');
+  }
+  const scope = testScope({ testFiles: entry.test_files, owned: entry.owned_files ?? [] });
+  const test = cited.find((file) => latest.files[file] && (latest.scope === 'full'
+    || (latest.scope === 'related' && scope.scope === 'related' && scope.files.includes(file))));
+  if (!test) refuse('waive-yes-critical-no-test', 'the latest passing gate record must cover the cited acceptance test file and its current content');
+  return test;
+}
+
 /** The full finding is normally in the signed worker result; older rows may carry it directly.
  * @param {Record<string, any>[]} rows @param {{root: string, runId: string, id: string, file: string, finding: string, key: Buffer}} where
  */
@@ -130,17 +207,26 @@ export async function waiveAsAgent({ runId, id, finding, file, reason, record, w
   const rows = (await readAllRows(record.project)).filter((r) => r.run === runId);
   const key = await loadKey(runId);
   const recorded = recordedSeverity(rows, { block: id, file, finding, key });
-  if (!DELEGABLE_SEVERITIES.includes(recorded.severity)) refuse('waive-yes-critical', `finding ${finding} is ${recorded.severity ?? recorded.why}; only warning or nit findings may use --yes`);
+  const critical = recorded.severity === 'critical';
+  if (!DELEGABLE_SEVERITIES.includes(recorded.severity) && !(critical && activeGrant(record))) {
+    refuse('waive-yes-critical', `finding ${finding} is ${recorded.severity ?? recorded.why}; a critical finding needs an active autopilot grant; otherwise only warning or nit findings may use --yes`);
+  }
   const tree = await blockTree(record.workspace, entry);
   const contentRoot = tree?.top ?? root;
-  if (!hasEvidence(reason, contentRoot, entry)) refuse('waive-yes-no-evidence', 'cite an existing repo path with :line, an existing test file, or a block acceptance clause number');
+  const test = critical ? await passingAcceptanceTest(reason, contentRoot, entry, rows, id, key) : null;
+  if (critical ? !citedEvidence(reason, contentRoot).some((item) => item.path === file) : !hasEvidence(reason, contentRoot, entry)) {
+    refuse('waive-yes-no-evidence', critical ? `cite the finding's path ${file} with :line or :start-end`
+      : 'cite an existing repo path with :line or :start-end, an existing test file, or a block acceptance clause number');
+  }
   const bytes = readRegularFileNoFollow(contentRoot, file);
   if (bytes === null) refuse('waive-yes-disagreed', 'The current file cannot be read');
   const text = await findingText(rows, { root, runId, id, file, finding, key });
-  const answer = await judgeAgentReview({ finding: { id: finding, severity: recorded.severity, ...text }, reason, file: { path: file, content: bytes.toString('utf8') } }, { record, runId, id, judge });
+  const evidence = citedEvidence(reason, contentRoot);
+  const answer = await judgeAgentReview({ finding: { id: finding, severity: recorded.severity, ...text }, reason, file: { path: file, content: bytes.toString('utf8') }, ...(evidence.length > 0 ? { evidence } : {}) }, { record, runId, id, judge });
   if (answer.verdict === 'broken') refuse('waive-yes-broken', answer.reason);
   if (answer.verdict !== 'agree') refuse('waive-yes-disagreed', answer.reason);
-  return waiveFinding({ runId, id, finding, file, reason, writeRow, by: 'agent', extra: { severity: recorded.severity, verdict: 'agree', judge_reason: answer.reason } });
+  if (critical && !activeGrant(await readRun(runId))) refuse('waive-yes-critical', 'the critical finding still needs an active autopilot grant after the judge returns');
+  return waiveFinding({ runId, id, finding, file, reason, writeRow, by: 'agent', extra: { severity: recorded.severity, verdict: 'agree', judge_reason: answer.reason, ...(critical ? { autopilot: true, test } : {}) } });
 }
 
 /** Verified ledger-order cancellation, scoped to one run, block, file and finding.
@@ -159,7 +245,8 @@ export function isUnwaived(rows, waiver, key, verify = (r) => verifyRow(r, key).
  */
 export function countedAgentWaivers(rows, block, key, verify = (r) => verifyRow(r, key).ok) {
   return rows.filter((r) => r.block === block && r.event === 'review.waived' && r.by === 'agent'
-    && r.verdict === 'agree' && DELEGABLE_SEVERITIES.includes(r.severity) && verify(r)
+    && r.verdict === 'agree' && (DELEGABLE_SEVERITIES.includes(r.severity)
+      || (r.severity === 'critical' && r.autopilot === true && typeof r.test === 'string' && r.test.length > 0)) && verify(r)
     && !isUnwaived(rows, r, key, verify)
     && recordedSeverity(rows.filter((other) => other.run === r.run), { block, file: r.file, finding: r.finding, key, verify }).severity === r.severity);
 }

package/src/review/gate-check.mjs

@@ -17,7 +17,7 @@
  *    the latest refusal row for the hash is signed, carries `content_hash` (a hash-less one does
  *    not qualify, though it still refuses) and names at least one finding, and every finding it
  *    names and every open id of the file's unsuperseded `review.cap` rows is cleared by a waiver the gate
- *    accepts (the same rule as below: a critical only by `by: human`). Such a file is never
+ *    accepts (a critical needs a human or an agreed agent waiver issued in autopilot). Such a file is never
  *    approved; the close writes one signed `gate.review_waived_all` row for it ({@link reviewGateCheck});
  *  - `unsigned`:   the file's approvals for that hash exist but none carries a valid MAC;
  *  - `not_approved`: (B52) the file's signed approval for its current hash is STALE — a later row of
@@ -26,8 +26,8 @@
  *    reviewed the content, {@link neverReviewed}; a `review.round` with `open_after` not 0; a
  *    `review.cap`; a refusal row with no `content_hash` counts for every hash of its file). One
  *    refusal per open finding the latest such row names, each cleared only by a valid waiver for
- *    the severity that row RECORDS (anything but warning/nit — a critical — only by a signed
- *    `by: human` waiver); a row that names no finding is one `not_approved <file>` that only a
+ *    the severity that row RECORDS (a critical needs a signed human waiver or an agreed agent
+ *    waiver issued in autopilot); a row that names no finding is one `not_approved <file>` that only a
  *    fresh approval clears. An old ledger's `review.result` row has no `approved` field and is
  *    trusted neither way: the ticket's signed result file decides ({@link resultFilesFor}); a
  *    file that is missing or fails its MAC refuses `not_approved <file>`. Refusal rows count
@@ -43,7 +43,7 @@
  *  - `review_cap`: a file stopped at `review_cap` has an open finding with no signed
  *    `review.waived {by: human}` row — unless a signed approval of the file's current hash comes
  *    AFTER the cap row (ledger order) and no later refusal row made it stale (the human fixed it
- *    by hand and it was reviewed), or a verified human or agreed agent reopen after the cap is followed by a
+ *    by hand and it was reviewed), or a verified human, agreed agent or automatic reopen after the cap is followed by a
  *    signed review round of the current bytes; a finding already refused as `not_approved` for that file is
  *    not repeated. B73: this detail, and an `unreviewed` detail for a file with a cap row, ends
  *    with the stop's ways out (`exits: block reopen, block waive, review-file --answers,
@@ -85,6 +85,7 @@ import { lstatSync } from 'node:fs';
 import path from 'node:path';
 import { acceptedTranscriptHits } from './accept-hit.mjs';
 import { countedAgentWaivers } from './agent-waiver.mjs';
+import { isAutomaticReopen } from './reopen.mjs';
 import { exec } from '../util/exec.mjs';
 import { readRun, writeSigned } from '../state/run.mjs';
 import { StateError } from '../state/paths.mjs';
@@ -287,7 +288,7 @@ function reviewRules({ block, runId, rows, key, resultFiles = {}, current, verif
   // Acceptance is a review input. Every older review verdict belongs to the previous input.
   const mine = rows.filter((r, i) => r?.block === block && (runId === undefined || r.run === undefined || r.run === runId)
     && !(i < amendedAt && typeof r.event === 'string' && r.event.startsWith('review.')));
-  /** A verified human or agreed agent reopen followed by a real review clears older cap ids.
+  /** A verified human, agreed agent or automatic reopen followed by a real review clears older cap ids.
    * @param {Record<string, any>} cap @returns {boolean}
    */
   const supersededCap = (cap) => {
@@ -295,7 +296,7 @@ function reviewRules({ block, runId, rows, key, resultFiles = {}, current, verif
     if (hash === undefined) return false;
     const at = mine.indexOf(cap);
     return mine.some((r, i) => i > at && r.event === 'review.reopened' && r.run === runId && r.file === cap.file
-      && (r.by === 'human' || (r.by === 'agent' && r.verdict?.verdict === 'agree')) && ok(r)
+      && (r.by === 'human' || (r.by === 'agent' && r.verdict?.verdict === 'agree') || isAutomaticReopen(r)) && ok(r)
       && mine.some((round, j) => j > i && round.event === 'review.round' && round.run === runId && round.file === cap.file && round.content_hash === hash && ok(round)));
   };
   /**
@@ -368,7 +369,8 @@ function reviewRules({ block, runId, rows, key, resultFiles = {}, current, verif
    * row RECORDS for it — REQUIRED: only an explicit null (none recorded there; the signed review
    * rows decide, {@link autopilotWaiverProblem}) or warning/nit may be delegated; anything else
    * (`undefined`, a critical, an unknown value) is the human's alone ({@link delegableSeverity}),
-   * except that an answer also clears a critical. `invalid`: why the autopilot waivers naming it do
+   * except that an answer or a counted agent waiver issued in autopilot also clears a critical.
+   * `invalid`: why the autopilot waivers naming it do
    * not count (null when none names it).
    * `exceptTicket`: see {@link answered}. `answerSeverity`: the severity the answer rule reads
    * (default `severity`); the late-finding, cap and proof loops pass the one RECORDED for the id,
@@ -379,9 +381,11 @@ function reviewRules({ block, runId, rows, key, resultFiles = {}, current, verif
   const waiverOf = (file, finding, severity, exceptTicket = null, answerSeverity = severity) => {
     if (waivers.some((r) => matches(r, file, finding))) return { by: 'human', invalid: null };
     if (answered(file, finding, answerSeverity, exceptTicket)) return { by: 'answer', invalid: null };
-    if (finding !== PROOF_FINDING && delegableSeverity(severity)) {
+    if (finding !== PROOF_FINDING && (delegableSeverity(severity) || severity === 'critical')) {
       const recorded = recordedSeverity(mine, { block, file, finding, key, verify: ok });
-      if (DELEGABLE_SEVERITIES.includes(recorded.severity) && agentWaivers.some((r) => matches(r, file, finding) && r.severity === recorded.severity)) return { by: 'agent', invalid: null };
+      const agentMayWaive = (delegableSeverity(severity) && DELEGABLE_SEVERITIES.includes(recorded.severity))
+        || (severity === 'critical' && recorded.severity === 'critical');
+      if (agentMayWaive && agentWaivers.some((r) => matches(r, file, finding) && r.severity === recorded.severity)) return { by: 'agent', invalid: null };
     }
     const named = autopilotWaivers.filter((r) => matches(r, file, finding));
     // the unverified pre-check (`verify` given) reads no autopilot waiver: it cannot check a grant