@codedology/code-forge 0.15.3 → 0.16.0

package/src/ledger/tail.mjs

@@ -0,0 +1,89 @@
+import { open, readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { ledgerPath } from './paths.mjs';
+
+/**
+ * A worker's project-wide ledger view. Concurrent callers share one serialized
+ * cursor; incomplete UTF-8/JSON bytes stay buffered until a newline arrives.
+ * @param {string} slug
+ * @returns {{read: () => Promise<Record<string, any>[]>}}
+ */
+export function createTailReader(slug) {
+  const file = ledgerPath(slug);
+  const dir = path.dirname(file);
+  const rotatedName = new RegExp(`^${slug}\\.(\\d+)\\.jsonl$`);
+  /** @type {Record<string, any>[]} */
+  let rows = [];
+  let files = '';
+  let inode = '';
+  let offset = 0;
+  /** @type {Buffer} */
+  let pending = Buffer.alloc(0);
+  let chain = Promise.resolve();
+
+  /** @param {Buffer} bytes */
+  function parse(bytes) {
+    const end = bytes.lastIndexOf(0x0a) + 1;
+    return {
+      rows: bytes.subarray(0, end).toString('utf8').split('\n').filter((line) => line.length > 0).map((line) => JSON.parse(line)),
+      pending: bytes.subarray(end),
+    };
+  }
+
+  /** @param {import('node:fs/promises').FileHandle} handle @param {number} start @param {number} size */
+  async function readBytes(handle, start, size) {
+    const bytes = Buffer.alloc(Math.max(0, size - start));
+    let n = 0;
+    while (n < bytes.length) {
+      const { bytesRead } = await handle.read(bytes, n, bytes.length - n, start + n);
+      if (bytesRead === 0) break;
+      n += bytesRead;
+    }
+    return bytes.subarray(0, n);
+  }
+
+  async function update() {
+    let names;
+    try { names = await readdir(dir); } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+      names = [];
+    }
+    const rotated = names.filter((name) => rotatedName.test(name))
+      .sort((a, b) => Number(rotatedName.exec(a)[1]) - Number(rotatedName.exec(b)[1]));
+    let handle;
+    try { handle = await open(file, 'r'); } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+    try {
+      const info = await handle?.stat();
+      const identity = info ? `${info.dev}:${info.ino}` : '';
+      const listing = JSON.stringify(rotated);
+      const reset = listing !== files || identity !== inode || (info?.size ?? 0) < offset;
+      let next = reset ? [] : rows;
+      if (reset) {
+        for (const name of rotated) {
+          const history = await open(path.join(dir, name), 'r');
+          try {
+            next = next.concat(parse(await readBytes(history, 0, (await history.stat()).size)).rows);
+          } finally { await history.close(); }
+        }
+      }
+      const start = reset ? 0 : offset;
+      const bytes = handle ? await readBytes(handle, start, info.size) : Buffer.alloc(0);
+      const parsed = parse(Buffer.concat([reset ? Buffer.alloc(0) : pending, bytes]));
+      // Commit only after every complete line parsed, so corruption cannot poison the cursor.
+      rows = next.concat(parsed.rows);
+      pending = parsed.pending;
+      offset = start + bytes.length;
+      files = listing;
+      inode = identity;
+      return rows.slice();
+    } finally { await handle?.close(); }
+  }
+
+  return { read() {
+    const result = chain.then(update);
+    chain = result.then(() => {}, () => {});
+    return result;
+  } };
+}

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

@@ -0,0 +1,170 @@
+/** Best-effort JavaScript/TypeScript definition context, with caller-supplied I/O. */
+import nodePath from 'node:path';
+import { isSecretLike } from './packet.mjs';
+
+const KEYWORDS = new Set(['if', 'for', 'while', 'switch', 'catch', 'function', 'return', 'typeof', 'new']);
+const EXTENSIONS = ['.mjs', '.js', '.ts', '.cjs', '.tsx'];
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+
+/** @typedef {{path: string, name: string, start: number, end: number, lines: string[]}} Definition */
+
+/** Comments and literals stay opaque; positions still refer to the original source.
+ * @param {string} text
+ */
+function tokensOf(text) {
+  const tokens = [];
+  let line = 1;
+  let offset = 0;
+  for (const match of text.matchAll(/\/\/[^\r\n]*|\/\*[\s\S]*?\*\/|`(?:\\[\s\S]|[^`\\])*`|'(?:\\[\s\S]|[^'\\])*'|"(?:\\[\s\S]|[^"\\])*"|\/(?:\\.|\[(?:\\.|[^\]\\])*\]|[^/\n\\])+\/[dgimsuvy]*|[A-Za-z_$][\w$]*|=>|[^\s]/g)) {
+    line += text.slice(offset, match.index).split('\n').length - 1;
+    offset = match.index;
+    if (!/^\/[/\*]/.test(match[0])) tokens.push({ value: match[0], line });
+  }
+  return tokens;
+}
+
+/** @param {string} rel */
+function safePath(rel) {
+  return !nodePath.posix.isAbsolute(rel) && !/[\\\x00-\x1f\x7f]/.test(rel) &&
+    !rel.split('/').some((part) => ['', '.', '..', '.git', '.code-forge'].includes(part)) && !isSecretLike(rel);
+}
+
+/** @param {ReturnType<typeof tokensOf>} tokens @param {number} start */
+function closing(tokens, start) {
+  const open = tokens[start]?.value;
+  const close = { '(': ')', '{': '}', '[': ']' }[open];
+  let depth = 0;
+  for (let i = start; i < tokens.length; i++) {
+    if (tokens[i].value === open) depth++;
+    if (tokens[i].value === close && --depth === 0) return i;
+  }
+  return -1;
+}
+
+/** @param {string} text @param {string} file @param {string} name @param {boolean} exported
+ * @returns {Definition | null}
+ */
+function declaration(text, file, name, exported) {
+  const tokens = tokensOf(text);
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i].value !== name) continue;
+    const prev = tokens[i - 1]?.value;
+    const kind = ['function', 'const', 'class'].includes(prev) ? prev : null;
+    let start = i - 1;
+    while (start > 0 && ['async', 'default', 'export', 'declare'].includes(tokens[start - 1].value)) start--;
+    if (exported && !tokens.slice(start, i).some((token) => token.value === 'export')) continue;
+    if (kind === null && (exported || tokens[i + 1]?.value !== '(' || !['{', '}', ';', 'async', 'static', 'get', 'set'].includes(prev))) continue;
+    if (kind === null && tokens[closing(tokens, i + 1) + 1]?.value !== '{') continue;
+    if (kind === null) start = ['async', 'static', 'get', 'set'].includes(prev) ? i - 1 : i;
+    if (kind === 'const' && tokens[i + 1]?.value !== '=') continue;
+    let body = i + 1;
+    let end = -1;
+    for (; body < tokens.length; body++) {
+      const value = tokens[body].value;
+      if (value === '(' || value === '[') {
+        const last = closing(tokens, body);
+        if (last < 0) break;
+        body = last;
+      } else if (value === '{') {
+        end = closing(tokens, body);
+        break;
+      } else if (value === ';' || (kind === 'const' && tokens[body].line > tokens[i].line && tokens[body - 1]?.value !== '=')) {
+        end = value === ';' ? body : body - 1;
+        break;
+      }
+    }
+    if (end < 0) continue; // Malformed or incomplete declaration: keep looking.
+    const firstLine = tokens[start].line;
+    const lastLine = tokens[end].line;
+    const lastShown = Math.min(lastLine, firstLine + 39);
+    return { path: file, name, start: firstLine, end: lastShown,
+      lines: [...lines.slice(firstLine - 1, lastShown), ...(lastLine > lastShown ? ['…'] : [])] };
+  }
+  return null;
+}
+
+/** Parse local bindings, preserving aliases and namespace owners.
+ * @param {string} header
+ */
+function importsOf(header) {
+  const tokens = tokensOf(header);
+  const imports = new Map();
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i].value !== 'import' || ['(', '.'].includes(tokens[i + 1]?.value)) continue;
+    let end = i + 1;
+    while (end < tokens.length && !['from', ';', 'import'].includes(tokens[end].value)) end++;
+    if (tokens[end]?.value !== 'from') continue;
+    const source = tokens[end + 1]?.value;
+    if (!/^['"]\.\.?\//.test(source ?? '')) continue;
+    const specifier = source.slice(1, -1);
+    for (let j = i + 1; j < end; j++) {
+      const name = tokens[j].value;
+      if (!IDENTIFIER.test(name) || ['as', 'type'].includes(name)) continue;
+      if (tokens[j - 1]?.value === 'as') continue;
+      const alias = tokens[j + 1]?.value === 'as' ? tokens[j + 2]?.value : name;
+      imports.set(alias, { name, specifier, namespace: tokens[j - 1]?.value === '*' });
+    }
+    // `* as owner` has no ordinary imported name.
+    if (tokens[i + 1]?.value === '*' && tokens[i + 2]?.value === 'as') {
+      imports.set(tokens[i + 3]?.value, { name: '*', specifier, namespace: true });
+    }
+    i = end + 1;
+  }
+  return imports;
+}
+
+/**
+ * Calls on added unified-diff lines only. Missing or malformed source never aborts a packet.
+ * `readFile` takes an absolute path, as in relatedFiles; windows are current-file line ranges.
+ * @param {{path: string, diffLines: string[], header: string, io: {
+ *   repoRoot: string, readFile: (file: string) => string | null | Promise<string | null>,
+ *   windows?: Array<{start: number, end: number}>
+ * }}} opts
+ * @returns {Promise<Definition[]>}
+ */
+export async function findDefinitions({ path, diffLines, header, io }) {
+  const found = [];
+  if (!safePath(path) || !EXTENSIONS.includes(nodePath.posix.extname(path).toLowerCase())) return found;
+  try {
+    const cache = new Map();
+    const read = async (rel) => {
+      if (!safePath(rel)) return null;
+      if (!cache.has(rel)) {
+        try { cache.set(rel, await io.readFile(nodePath.resolve(io.repoRoot, rel))); }
+        catch { cache.set(rel, null); }
+      }
+      return cache.get(rel);
+    };
+    const text = await read(path);
+    if (typeof text !== 'string') return found;
+    const added = tokensOf(diffLines.filter((line) => line.startsWith('+') && !line.startsWith('+++')).map((line) => line.slice(1)).join('\n'));
+    const defined = new Set(added.filter((token, i) => ['function', 'const', 'class', 'let', 'var'].includes(added[i - 1]?.value) ||
+      (added[i + 1]?.value === '(' && added[closing(added, i + 1) + 1]?.value === '{')).map((token) => token.value));
+    const imports = importsOf(header);
+    const seen = new Set();
+    for (let i = 0; i < added.length; i++) {
+      const name = added[i].value;
+      if (!IDENTIFIER.test(name) || added[i + 1]?.value !== '(' || KEYWORDS.has(name) || defined.has(name)) continue;
+      const receiver = added[i - 1]?.value === '.' ? added[i - 2]?.value : null;
+      const binding = imports.get(receiver ?? name);
+      let definition = declaration(text, path, name, false);
+      if (definition && io.windows?.some((w) => w.start <= definition.start && definition.end <= w.end)) definition = null;
+      if (!definition && binding && (!receiver || binding.namespace)) {
+        const target = nodePath.posix.normalize(nodePath.posix.join(nodePath.posix.dirname(path), binding.specifier));
+        if (!safePath(target)) continue;
+        const candidates = nodePath.posix.extname(target) ? [target] : [target, ...EXTENSIONS.map((ext) => target + ext), ...EXTENSIONS.map((ext) => `${target}/index${ext}`)];
+        for (const candidate of candidates) {
+          const imported = await read(candidate);
+          if (typeof imported !== 'string') continue;
+          definition = declaration(imported, candidate, binding.namespace ? name : binding.name, true);
+          break;
+        }
+      }
+      if (!definition) continue;
+      const key = `${definition.path}:${definition.start}`;
+      if (!seen.has(key)) { seen.add(key); found.push(definition); }
+    }
+  } catch { /* Partial context is preferable to aborting review on unparseable source. */ }
+  return found;
+}

package/src/review/fixloop.mjs

@@ -19,7 +19,7 @@
  *     ≥ `escalation.warning_threshold` (2) warnings or any `critical` — climb at once (rule 2c,
  *     B34: `trigger: review_warnings`); `warn_rounds_at_level` counts them and resets on a climb.
  *  5. Cap: `review.max_rounds_per_file` (4) reached with an open finding ⇒ the L3 patch rung
- *     (rule 6; once per block — shared with rule 5's ceiling), whose `patch_check` round is
+ *     (rule 6; once per file — shared with rule 5's ceiling), whose `patch_check` round is
  *     OUTSIDE the cap. The rung is also rule 5: rule 2/2b at the running ceiling (L2 — L3 is never
  *     a coding level, R1) takes it, so for an L2 block the rung IS the +1 at round 2. After the
  *     patch the block continues at L2 (§3.6, Fable ruling A): `l3_rung_used = true`,
@@ -127,7 +127,7 @@ import { afterSchemaMiss, logSecondLevelMiss, packetHash } from './schema-fallba
  * @property {string[]} [finding_history] - claim/evidence keys from earlier rounds of this file.
  * @property {string[]} [finding_ids] - ids seen in earlier rounds, including closed findings.
  * @property {string | null} reviewed_content - the content the last counted round reviewed.
- * @property {boolean} l3_rung_used - the block's L3 rung (rule 5 or 6) was used — once per block.
+ * @property {boolean} l3_rung_used - the file's L3 rung (rule 5 or 6) was used — once per file.
  * @property {'open' | 'complete' | 'stopped'} status
  * @property {string} [stop_content_hash] - bytes reviewed by a stop (absent in legacy states).
  * @property {string} [stop_lens] - the lens whose packet stopped before a round.
@@ -146,7 +146,7 @@ import { afterSchemaMiss, logSecondLevelMiss, packetHash } from './schema-fallba
  * @property {import('./triage.mjs').JevAsk} [jev]
  * @property {import('./triage.mjs').RuleFn} [rule]
  * @property {(row: Record<string, any>) => Promise<unknown>} [writeRow]
- * @property {(req: {file: string, round: number, level: string, open: Finding[], l3_patch: boolean}) => Promise<unknown>} [fix] - a fresh coder session at `level`; `l3_patch` = the block's L3 patch is in the tree (§3.6).
+ * @property {(req: {file: string, round: number, level: string, open: Finding[], l3_patch: boolean}) => Promise<unknown>} [fix] - a fresh coder session at `level`; `l3_patch` = the file's L3 patch is in the tree (§3.6).
  * @property {(req: {file: string, level: 'L3', open: Finding[]}) => Promise<unknown>} [patch] - the L3 patch rung (≤ 80 lines, owned files only).
  * @property {string | null} [base] - the block base (`recheck_scope: file`, and the B56 moved-code diff).
  * @property {ReadonlyArray<string>} [peers] - B56: the block's other changed files (moved-code hints).
@@ -582,7 +582,7 @@ async function recheckSession(packet, deps, open) {
 function decideNext(state, openBefore, s, kind, closedIds) {
   if (state.open.length === 0) return { action: 'complete' };
   if (kind === 'patch_check') {
-    // the block's one rung is spent: a patch that closed no old finding stops FIRST — even when
+    // the file's one rung is spent: a patch that closed no old finding stops FIRST — even when
     // the rung was taken at the cap — then the cap; else (B73: ≥ 1 old id closed is progress,
     // whatever new findings its fix hunks brought) the block continues at L2: a fix, no stall
     if (closedIds === 0) return { action: 'stop', reason: 'l3_patch_exhausted', trigger: 'review_stall' };

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
@@ -904,15 +908,31 @@ export function repoRelativePath(raw) {
 /**
  * The block's file set (§4.1): changed tracked files since `base` (deletions included, hashed
  * `DELETED_HASH`) ∪ untracked files, filtered to `owned` (`matchOwned`, default the registry's `ownsFile` with `ownedKinds`: an exact entry owns its path and the paths below it unless recorded as a regular file, B57), each with its content hash.
- * Every path goes through `repoRelativePath`.
- * @param {{repoRoot: string, base: string, owned: string[], ownedKinds?: Record<string, string>, matchOwned?: (file: string) => boolean, changed?: string[]}} opts
+ * Every path goes through `repoRelativePath`; files deleted now get a git base-existence check
+ * and, if absent at base, a history check. Omit them only when git confirms commits since base
+ * touched them in this workspace. Failed or empty history checks keep the deletion for review.
+ * Other files need no extra git call; deleted files need at most two.
+ * @param {{repoRoot: string, base: string, owned: string[], ownedKinds?: Record<string, string>, matchOwned?: (file: string) => boolean, changed?: string[], gitRun?: (argv: string[], opts: Parameters<typeof exec>[1]) => Promise<{result: 'ok' | 'failed', stdout?: string, timedOut?: boolean}>}} opts
  *   `changed`: the tree's changed files when the caller already listed them ({@link changedFiles}).
+ *   `gitRun`: the base-existence and history runner (defaults to {@link exec}).
  * @returns {Promise<Array<{file: string, content_hash: string}>>}
  */
-export async function blockFileSet({ repoRoot, base, owned, ownedKinds, matchOwned, changed }) {
+export async function blockFileSet({ repoRoot, base, owned, ownedKinds, matchOwned, changed, gitRun = exec }) {
   const all = changed ?? (await changedFiles({ repoRoot, base }));
   const isOwned = matchOwned ?? ((/** @type {string} */ f) => ownsFile(owned, f, ownedKinds));
-  return all.filter((f) => isOwned(f)).map((file) => ({ file, content_hash: currentHash(repoRoot, file) }));
+  const files = [];
+  for (const file of all.filter((f) => isOwned(f))) {
+    const content_hash = currentHash(repoRoot, file);
+    if (content_hash === DELETED_HASH) {
+      const atBase = await gitRun(['git', 'ls-tree', '--name-only', '-z', base, '--', file], { cwd: repoRoot, env: gitChildEnv(), timeoutMs: 30000 });
+      if (atBase.result === 'ok' && atBase.stdout === '') {
+        const history = await gitRun(['git', 'log', '--format=%H', `${base}..HEAD`, '--', file], { cwd: repoRoot, env: gitChildEnv(), timeoutMs: 30000 });
+        if (history.result === 'ok' && typeof history.stdout === 'string' && history.stdout.trim() !== '') continue;
+      }
+    }
+    files.push({ file, content_hash });
+  }
+  return files;
 }
 
 /** Safety check for npm locks excluded from model review; other formats are not parsed.