@codedology/code-forge 0.14.1 → 0.15.1

package/src/cli/block.mjs

@@ -3,7 +3,7 @@
  * `block open` before every spawn in every engine; it prints the brief pointer (≤ 200 bytes).
  *
  *   block open <id> --run <r> [--level L<n>] --owned <paths…> --acceptance <file>
- *              [--brief <file>] [--attempt <n>] [--base <sha>] [--lines <forecast>] [--kind code|docs|contract]
+ *              [--brief <file>] [--attempt <n>] [--base <sha>] [--lines <forecast>] [--kind code|docs|contract|light]
  *              [--tests <paths…>]
  *   block attempt <id> --run <r>
  *   block rebase <id> --run <r> [--head <ref>]
@@ -187,12 +187,14 @@
  * autopilot`). The prompt checks only that stdin and stdout are terminals; a pseudo-terminal
  * passes it, so it does not prove a human. The coder deny-list entries stay.
  *
- * `--acceptance` is a YAML/JSON list of `{clause, tests: [test ids…]}`. `block close` runs B8's
+ * `--acceptance` is a YAML/JSON list of `{clause, tests: [test ids…]}` or `{clause, kind: human_check}`
+ * without tests. Human checks leave a successful close awaiting the human's terminal pass.
+ * `block close` runs B8's
  * rows of the gate (worker pin, MACs, orphans); the gate rows owned by later blocks join it
  * through `closeBlock`'s `extraChecks`.
  */
 
-import { statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { readFile, realpath } from 'node:fs/promises';
 import path from 'node:path';
 import { parse as parseYAML } from 'yaml';
@@ -200,16 +202,16 @@ import { approvalCheckText, expiryChecks } from '../autopilot/limits.mjs';
 import { fallbackLane } from '../decide/fallback-rules.mjs';
 import { laneFacts } from '../decide/lane-facts.mjs';
 import { appendRow, readAllRows } from '../ledger/write.mjs';
-import { attemptBlock, claimPath, closeBlock, openBlock, rebaseBlock, repoTop, stopBlock } from '../state/block.mjs';
-import { lastGate } from '../state/brief-status.mjs';
+import { amendAcceptanceBlock, attemptBlock, claimPath, closeBlock, humanPassBlock, openBlock, prepareAcceptanceAmendment, rebaseBlock, repoTop, stopBlock } from '../state/block.mjs';
 import { intFlag, parseFlags } from '../state/cli-args.mjs';
 import { configInForce, externalReviewer, requireCoderTests } from '../state/config-snapshot.mjs';
+import { readFileDiff } from '../review/packet.mjs';
 import { StateError } from '../state/paths.mjs';
 import { readRun, writeSigned } from '../state/run.mjs';
 import { loadKey, verifyRow } from '../state/signer.mjs';
-import { PROOF_FINDING, blockFileSet, changedFiles, openFindings, ownsAt, resultFilesFor, reviewedFiles, reviewGateCheck, unownedChanges, waiveFinding } from '../review/gate-check.mjs';
+import { PROOF_FINDING, blockFileSet, changedFiles, checkBlockReviews, openFindings, ownsAt, recordedSeverity, resultFilesFor, reviewedFiles, reviewGateCheck, routineCloseProblem, unownedChanges, waiveFinding } from '../review/gate-check.mjs';
 import { agentWaivers, agentWaiversAcked, prepareAckWaivers, prepareUnwaive, waiveAsAgent } from '../review/agent-waiver.mjs';
-import { checkExpiry } from '../autopilot/grant.mjs';
+import { checkExpiry, grantFor, grantState } from '../autopilot/grant.mjs';
 import { redact, writeSafe } from '../util/redact.mjs';
 import { blockTree, prepareWorktree, removeWorktree, worktreeSettings } from '../proof/worktree.mjs';
 import { DEFAULT_CONFIG_FILENAME, loadProjectConfig } from '../config/load.mjs';
@@ -217,7 +219,7 @@ import { validateConfig } from '../config/validate.mjs';
 import { migrateConfig } from '../config/migrate.mjs';
 import { exec } from '../util/exec.mjs';
 import { contentHash, gitChildEnv, readRegularFileNoFollow } from '../worker/ticket.mjs';
-import { clearDone, resolveTicket } from '../worker/queue.mjs';
+import { clearDone, resetAcceptanceWatch, resolveTicket } from '../worker/queue.mjs';
 import { loadState } from '../worker/review-state.mjs';
 import { agentReopens, openBlockEntry, reopenFile } from '../review/reopen.mjs';
 import { checkFileForm, checkFindingId } from '../review/verb-forms.mjs';
@@ -227,7 +229,7 @@ import { reportMismatches, reviewedLines } from '../review/reviewed-lines.mjs';
 import { blockEndHook, runBlockEndHook, writeDoneFile } from '../state/block-end.mjs';
 import { blockOpenFindings } from '../review/open-findings.mjs';
 import { hookForbidden, scanTranscript } from '../util/forbidden.mjs';
-import { prepareAcceptHit, writeAcceptedHit } from '../review/accept-hit.mjs';
+import { acceptedTranscriptHits, prepareAcceptHit, writeAcceptedHit } from '../review/accept-hit.mjs';
 
 /**
  * B72: `block reopen` — the file's content is read where the block works (its worktree, else the
@@ -290,23 +292,32 @@ async function reopenBlockFile({ runId, id, file, reason, record, writeRow, agen
 }
 
 const USAGE =
-  'usage: code-forge block open <id> --run <r> [--level L<n>] --owned <paths…> --acceptance <file> [--brief <file>] [--attempt <n>] [--base <sha>] [--lines <n>] [--kind code|docs|contract] [--tests <paths…>]\n' +
+  'usage: code-forge block open <id> --run <r> [--level L<n>] --owned <paths…> --acceptance <file> [--brief <file>] [--attempt <n>] [--base <sha>] [--lines <n>] [--kind code|docs|contract|light] [--tests <paths…>]\n' +
   '       code-forge block attempt|rebase <id> --run <r> · block close <id> --run <r> [--transcript <file>] [--report <file>] [--no-require-reviews] [--remove-worktree] · block claim <id> <path> --run <r> · block stop <id> --run <r> --reason <text>\n' +
   '       code-forge block waive <id> <finding-id> --run <r> --file <path> --reason <text> [--yes]\n' +
   '       code-forge block reopen <id> --run <r> --file <path> --reason <text> [--yes]\n' +
-  '       code-forge block accept-hit <id> --run <r> --rule <rule-id> --line <n> --transcript <path> --reason <text>\n' +
+  '       code-forge block accept-hit <id> --run <r> [--rule <rule-id>] --line <n> --transcript <path> --reason <text>\n' +
   '       code-forge block unwaive <id> <finding-id> --run <r> --file <path> --reason <text>\n' +
   '       code-forge block ack-waivers <id> --run <r>\n' +
+  '       code-forge block human-pass <id> --run <r> --note <text> [--proof <dir-or-file>]\n' +
+  '       code-forge block amend-acceptance <id> --run <r> --acceptance <file> --reason <text>\n' +
   '       every block verb takes --json: one JSON line on stdout ({"block","event",…}) instead of the text\n';
 
-const SUBCOMMANDS = ['open', 'attempt', 'rebase', 'claim', 'close', 'stop', 'waive', 'reopen', 'accept-hit', 'unwaive', 'ack-waivers'];
+const SUBCOMMANDS = ['open', 'attempt', 'rebase', 'claim', 'close', 'stop', 'waive', 'reopen', 'accept-hit', 'unwaive', 'ack-waivers', 'human-pass', 'amend-acceptance'];
 
 /** Refuse likely shell quoting slips before any row is written.
  * @param {string} workspace @param {string[]} entries @param {string} label
  */
 function checkWhitespacePaths(workspace, entries, label) {
   for (const entry of entries) {
-    if (!/\s/u.test(entry)) continue;
+    let depth = 0;
+    let separator = /\s/u.test(entry);
+    for (const char of entry) {
+      if (char === '{') depth += 1;
+      else if (char === '}') depth = Math.max(0, depth - 1);
+      else if (char === ',' && depth === 0) separator = true;
+    }
+    if (!separator) continue;
     let stat;
     try {
       stat = statSync(path.join(workspace, entry));
@@ -314,11 +325,11 @@ function checkWhitespacePaths(workspace, entries, label) {
       // A missing or unreadable path cannot establish a literal whitespace-containing name.
     }
     if (!stat?.isFile() && !stat?.isDirectory()) {
-      throw new StateError(label === 'owned files' ? 'bad-owned' : 'bad-tests', `${label}: invalid path ${JSON.stringify(entry)}: contains whitespace but names no existing file or directory`);
+      throw new StateError('usage', `${label} entry ${JSON.stringify(entry)} matches no file; use spaces, not commas`);
     }
   }
 }
-const FLAG_VALUES = ['run', 'level', 'acceptance', 'brief', 'attempt', 'base', 'lines', 'head', 'worker-pid', 'reason', 'file', 'transcript', 'kind', 'report', 'rule', 'line'];
+const FLAG_VALUES = ['run', 'level', 'acceptance', 'brief', 'attempt', 'base', 'lines', 'head', 'worker-pid', 'reason', 'file', 'transcript', 'kind', 'report', 'rule', 'line', 'note', 'proof'];
 
 /**
  * @param {string[]} args
@@ -349,7 +360,7 @@ export async function runBlock(args, deps = {}) {
     return 2;
   }
   try {
-    const { flags, positionals } = parseFlags(rest, { values: FLAG_VALUES, multi: ['owned', 'tests'], booleans: ['no-require-reviews', 'remove-worktree', 'json', ...(['waive', 'reopen'].includes(sub) ? ['yes'] : [])] });
+    const { flags, positionals } = parseFlags(rest, { values: FLAG_VALUES, multi: ['owned', 'tests'], booleans: ['no-require-reviews', 'remove-worktree', 'json', ...(sub === 'close' ? ['decide'] : []), ...(['waive', 'reopen'].includes(sub) ? ['yes'] : [])] });
     // B64a: --json prints ONE JSON line on success instead of the text lines (`emit`, one object
     // per verb, built where the text is); without it every output is exactly as before (`say` is `out`)
     const json = flags.json === true;
@@ -366,6 +377,9 @@ export async function runBlock(args, deps = {}) {
     const [id, extra] = positionals;
     const runId = typeof flags.run === 'string' ? flags.run : undefined;
     if (!id || !runId) throw new StateError('usage', 'a block id and --run are required');
+    if (sub === 'amend-acceptance' && (positionals.length !== 1 || typeof flags.acceptance !== 'string' || typeof flags.reason !== 'string' || !flags.reason.trim() || /\p{Cc}/u.test(flags.reason))) {
+      throw new StateError('usage', 'amend-acceptance needs one block id, --acceptance and a nonblank --reason without control characters');
+    }
     if (sub === 'open' && (typeof flags.acceptance !== 'string' || !Array.isArray(flags.owned) || (flags.level !== undefined && typeof flags.level !== 'string'))) {
       throw new StateError('usage', 'block open needs --level, --owned and --acceptance');
     }
@@ -377,16 +391,60 @@ export async function runBlock(args, deps = {}) {
     if (sub === 'reopen' && typeof flags.file !== 'string') throw new StateError('usage', 'block reopen needs --file <path>');
     if (sub === 'waive' && typeof flags.file !== 'string') throw new StateError('usage', 'block waive needs --file <path> (a finding id is scoped to one file)');
     if (sub === 'accept-hit') {
-      const { record, row } = await prepareAcceptHit({ runId, id, flags, positionals, extraTokens });
-      const asked = await confirmHumanVerb(sub, runId, id, { rule: row.rule, line: row.line, file: /** @type {string} */ (flags.transcript) }, record, deps);
+      // prepareAcceptHit (review/accept-hit.mjs) returns every accepted hit as rows (all hits on --line, or only the --rule hit).
+      const { record, rows } = await prepareAcceptHit({ runId, id, flags, positionals, extraTokens });
+      const asked = await confirmHumanVerb(sub, runId, id, { rule: rows[0].rule, line: rows[0].line, ...(flags.rule === undefined ? { hits: rows } : {}), file: /** @type {string} */ (flags.transcript) }, record, deps);
       if (asked === 'no-tty') { err(`${humanVerbNoTTY(sub)}\n`); return 2; }
       if (asked === 'cancelled') { err(`block ${id} ${sub}: cancelled — nothing was recorded\n`); return 1; }
-      await writeAcceptedHit({ runId, row, writeRow: (signed) => appendRow(signed, { slug: record.project }) });
-      say(`block ${id} accepted ${row.rule} transcript line ${row.line} (by: human)\n`);
-      if (json) emit({ block: id, event: 'rule_break.accepted', rule: row.rule, line: row.line, reason: row.reason, by: 'human' });
+      for (const row of rows) {
+        await writeAcceptedHit({ runId, row, writeRow: (signed) => appendRow(signed, { slug: record.project }) });
+        say(`block ${id} accepted ${row.rule} transcript line ${row.line} (by: human)\n`);
+      }
+      const accepted = rows.map(({ rule, line, reason, by }) => ({ rule, line, reason, by }));
+      if (json) emit({ block: id, event: 'rule_break.accepted', ...(flags.rule === undefined ? { accepted_hits: accepted } : accepted[0]) });
       return 0;
     }
     const record = await readRun(runId);
+    if (sub === 'amend-acceptance') {
+      /** @type {ReturnType<typeof prepareAcceptanceAmendment> | null} */
+      let prepared = null;
+      const what = { file: '', oldCount: 0, newCount: 0 };
+      const noGrant = (/** @type {Record<string, any>} */ current) => {
+        if (current.autopilot && grantState(current.autopilot, (deps.now ?? (() => new Date()))()) === 'active') throw new StateError('autopilot-active', 'amend-acceptance is refused while an autopilot grant is active');
+      };
+      const asked = await confirmHumanVerb(sub, runId, id, what, record, deps, async () => {
+        noGrant(record);
+        const clauses = parseYAML(await readFile(/** @type {string} */ (flags.acceptance), 'utf8'), { prettyErrors: false });
+        prepared = prepareAcceptanceAmendment(record, id, clauses);
+        what.oldCount = prepared.oldCount;
+        what.newCount = prepared.acceptance.length;
+      });
+      if (asked === 'no-tty') { err(`${humanVerbNoTTY(sub)}\n`); return 2; }
+      if (asked === 'cancelled') { err(`block ${id} ${sub}: cancelled — nothing was recorded\n`); return 1; }
+      if (prepared === null) throw new Error('acceptance was not prepared');
+      const accepted = /** @type {ReturnType<typeof prepareAcceptanceAmendment>} */ (prepared);
+      const row = await amendAcceptanceBlock({ runId, id, acceptance: accepted.acceptance, old_sha256: accepted.old_sha256, reason: /** @type {string} */ (flags.reason), writeRow: (signed) => appendRow(signed, { slug: record.project }), before: noGrant });
+      resetAcceptanceWatch(await repoTop(record.workspace), id);
+      say(`block ${id} acceptance amended (${row.clauses} clauses; by: human)\n`);
+      if (json) emit(row);
+      return 0;
+    }
+    const deciding = sub === 'close' && flags.decide === true;
+    if (deciding) {
+      if (positionals.length !== 1 || typeof flags.reason !== 'string' || !flags.reason.trim() || /[\x00-\x1f\x7f]/.test(flags.reason)) throw new StateError('usage', '--decide needs one block id and a nonblank --reason without control characters');
+      if (flags['no-require-reviews']) throw new StateError('usage', '--decide cannot skip reviews');
+      if (!(deps.stdinIsTTY ?? deps.isTTY ?? process.stdin.isTTY === true) || !(deps.stdoutIsTTY ?? deps.isTTY ?? process.stdout.isTTY === true)) {
+        err(`${humanVerbNoTTY('close')}\n`); return 2;
+      }
+      if (record.autopilot && grantState(record.autopilot, (deps.now ?? (() => new Date()))()) === 'active') throw new StateError('autopilot-active', 'block close --decide is refused while an autopilot grant is active');
+    }
+    if (sub === 'human-pass') {
+      if (positionals.length !== 1 || typeof flags.note !== 'string' || flags.note.trim().length === 0) throw new StateError('usage', 'block human-pass needs one block id and --note <text>');
+      if (typeof flags.proof === 'string' && !existsSync(flags.proof)) throw new StateError('usage', '--proof must name an existing directory or file');
+      const asked = await confirmHumanVerb(sub, runId, id, { file: '' }, record, deps);
+      if (asked === 'no-tty') { err(`${humanVerbNoTTY(sub)}\n`); return 2; }
+      if (asked === 'cancelled') { err(`block ${id} ${sub}: cancelled — nothing was recorded\n`); return 1; }
+    }
     if (sub === 'unwaive' || sub === 'ack-waivers') {
       if (positionals.length !== (sub === 'unwaive' ? 2 : 1)) throw new StateError('usage', `block ${sub} takes ${sub === 'unwaive' ? 'one block id and one finding id' : 'one block id'}`);
       const prepared = sub === 'unwaive'
@@ -403,8 +461,9 @@ export async function runBlock(args, deps = {}) {
       return 0;
     }
     if (sub === 'open') {
-      checkWhitespacePaths(record.workspace, /** @type {string[]} */ (flags.owned), 'owned files');
-      if (Array.isArray(flags.tests)) checkWhitespacePaths(record.workspace, flags.tests, 'test files');
+      const base = record.blocks?.[id]?.worktree?.path ?? record.workspace;
+      checkWhitespacePaths(base, /** @type {string[]} */ (flags.owned), 'owned');
+      if (Array.isArray(flags.tests)) checkWhitespacePaths(base, flags.tests, 'tests');
     }
     // B80: waive and reopen are the human's — asked at a terminal before anything is written (not
     // even the autopilot expiry rows below); no terminal is exit 2, a "no" is exit 1
@@ -471,10 +530,22 @@ export async function runBlock(args, deps = {}) {
         },
       };
     };
+    if (sub === 'human-pass') {
+      const row = await humanPassBlock({ runId, id, note: /** @type {string} */ (flags.note), proof: typeof flags.proof === 'string' ? flags.proof : null, writeRow, now: (deps.now ?? (() => new Date()))() });
+      const end = await ended('closed', 'block.human_pass', null);
+      try {
+        say(`block ${id} closed (human check passed)\n`);
+        if (json) emit({ ...row, status: 'closed', ...end.json });
+        return 0;
+      } finally { await end.runHook(); }
+    }
     // B48: every block command runs the lazy autopilot checks (grant expiry, expired approvals);
     // a failed check is a warning, never a reason to stop the block command
+    const requireHumanClose = sub === 'close' && configInForce(record)?.close?.require_human === true;
     try {
-      err(approvalCheckText(await expiryChecks(runId, (deps.now ?? (() => new Date()))(), { writeRow })));
+      if (!deciding && !requireHumanClose) {
+        err(approvalCheckText(await expiryChecks(runId, (deps.now ?? (() => new Date()))(), { writeRow })));
+      }
     } catch (thrown) {
       err(`autopilot: WARN the expiry check failed (${thrown?.message ?? String(thrown)})\n`);
     }
@@ -608,9 +679,22 @@ export async function runBlock(args, deps = {}) {
         throw thrown;
       });
       // ONE base for the whole close: a worktree block is measured against the commit its tree was
-      // made from (B62a keeps it equal to the block's base_sha: a re-open keeps it, a rebase is refused)
+      // made from (kept equal to base_sha, including after a closed worktree rebase)
       const base = wt !== null ? wt.base_sha : entry.base_sha;
       const reviewsWaived = flags['no-require-reviews'] === true;
+      let routineGrant = null;
+      if (!deciding && !reviewsWaived && requireHumanClose) {
+        const active = record.autopilot && grantState(record.autopilot, (deps.now ?? (() => new Date()))()) === 'active';
+        if (active) {
+          const allowed = await grantFor(runId, 'close:routine', (deps.now ?? (() => new Date()))());
+          if (!allowed.ok) throw new StateError('close-not-routine', `close-not-routine: ${allowed.reason}`);
+          routineGrant = allowed.grant;
+        } else {
+          const asked = await confirmAtTerminal(deps, `Close block ${id} of run ${runId}? Only the owner may say yes.`);
+          if (asked === 'no-tty') { err(`${humanVerbNoTTY('close')}\n`); return 2; }
+          if (asked === 'cancelled') { err(`block ${id} close: cancelled — nothing was recorded\n`); return 1; }
+        }
+      }
       // B52: the human's way out is confirmed by the human, at a terminal, before anything is written
       if (reviewsWaived) {
         const asked = await confirmNoReviews(runId, id, deps);
@@ -673,14 +757,16 @@ export async function runBlock(args, deps = {}) {
         const others = closeRows.filter((r) => r.event !== 'gate.review_waived_all');
         closeRows.splice(0, closeRows.length, ...others, ...files.map((f) => ({ event: 'gate.review_waived_all', block: id, file: f.file, content_hash: f.content_hash, findings: f.findings, by: f.by, ...(f.answered?.length ? { answered: f.answered } : {}) })));
       };
-      const gate = reviewGateCheck(async () => {
-        const transcript = await findTranscript(record, id, typeof flags.transcript === 'string' ? flags.transcript : null);
-        if (transcript === null) {
+      let dryRun = deciding || routineGrant !== null;
+      let transcriptFile = '';
+      const loadGate = async () => {
+        const transcript = await findTranscript(record, id, typeof flags.transcript === 'string' ? flags.transcript : null, (file) => { transcriptFile = file; });
+        if (transcript === null && !dryRun) {
           await writeSigned(runId, writeRow, { event: 'gate.transcript_missing', block: id });
           err(`WARN block ${id}: no coder transcript found (--transcript, run record, .code-forge/runs/${runId}/${id}.log); the transcript grep did not run\n`);
         }
         // the human's way out of the per-file review check leaves a signed audit row before the close
-        if (reviewsWaived) await writeSigned(runId, writeRow, { event: 'gate.reviews_waived', block: id, by: 'human' });
+        if (reviewsWaived && !dryRun) await writeSigned(runId, writeRow, { event: 'gate.reviews_waived', block: id, by: 'human' });
         // B20: the high paths come first — a base the workspace does not know refuses the close here
         const highPaths = await highPathsAt(record.workspace, base);
         const { top, mainTop, where, inTree, wsPrefix, owns, changed, fileSet, reviewed } = await tree();
@@ -723,7 +809,8 @@ export async function runBlock(args, deps = {}) {
           proofFiles: fileSet,
           highPaths,
         };
-      }, { onWaivedAll, onAcceptedHits: (hits) => { acceptedHits = hits; } });
+      };
+      const gate = reviewGateCheck(loadGate, { onWaivedAll, onAcceptedHits: (hits) => { acceptedHits = hits; } });
       // B96: `reviewsPassed` comes from the gate's own result, not from the onWaivedAll call. Each
       // extra check runs at most once per close (`closeBlock`'s one loop, src/state/block.mjs:562,
       // and `closeBlock` is called once below), so the gate's one pass is its final one.
@@ -799,6 +886,35 @@ export async function runBlock(args, deps = {}) {
       };
       /** @type {Array<() => Promise<{ok: boolean, reason?: string}>>} */
       const extraChecks = [reviews, report];
+      if (entry.kind === 'light') extraChecks.unshift(async () => {
+        const { top, changed, owns } = await tree();
+        const files = changed.filter((file) => owns(entry.owned_files, file, entry.owned_kinds));
+        let lines = 0;
+        for (const file of files) {
+          const diff = await readFileDiff({ repoRoot: top, file, base });
+          lines += diff.plusCount + diff.minusCount;
+        }
+        const cfg = configInForce(record);
+        return files.length > (cfg?.light?.max_files ?? 5) || lines > (cfg?.light?.max_lines ?? 300)
+          ? { ok: false, reason: `light-limits ${files.length} files, ${lines} lines` } : { ok: true };
+      });
+      if (configInForce(record)?.gates?.test != null) {
+        const testGate = async () => {
+          const green = rows.filter((row) => row.block === id && row.event === 'gate.done' && row.all_ok === true);
+          // Only commits after the block base that touch its owned paths belong to this block.
+          // Older rows without timestamps remain usable, but a failed history lookup cannot prove freshness.
+          const commit = green.length === 0 ? null : await exec(['git', 'log', '-1', '--format=%ct', `${base}..HEAD`, '--', ...entry.owned_files], {
+            cwd: wt?.workspace ?? record.workspace, env: gitChildEnv(), timeoutMs: 10000,
+          });
+          const committed = commit?.result === 'ok' ? Number.parseInt(commit.stdout.trim(), 10) * 1000 : Number.NaN;
+          const ok = commit?.result === 'ok' && (commit.stdout.trim() === '' || Number.isFinite(committed)) &&
+            green.some((row) => !Number.isFinite(committed) || !Number.isFinite(Date.parse(row.ts)) || Date.parse(row.ts) > committed);
+          return ok ? { ok: true } : { ok: false, reason: `no green gates run; run: code-forge gates run --run ${runId} --block ${id}` };
+        };
+        // Keep human-bypass diagnostics ahead of the test gate; waiving reviews still needs green tests.
+        if (reviewsWaived) extraChecks.push(testGate);
+        else extraChecks.unshift(testGate);
+      }
       extraChecks.unshift(async () => agentWaiversAcked(record, rows, id, await loadKey(runId))
         ? { ok: true } : { ok: false, reason: 'agent-waivers-not-acked' });
       // B63b: `context.require_coder_tests` in the run's config snapshot (never the live config)
@@ -824,7 +940,72 @@ export async function runBlock(args, deps = {}) {
           return hit ? { ok: false, reason: `rule_break transcript line ${hit.line}: ${hit.id}` } : { ok: true };
         });
       }
-      const result = await closeBlock({ runId, id, rows, writeRow, livePid: intFlag(flags['worker-pid'], 'worker-pid'), probe, extraChecks, closeRows });
+      const closeOptions = { runId, id, rows, writeRow, livePid: intFlag(flags['worker-pid'], 'worker-pid'), probe, extraChecks, closeRows };
+      if (deciding) {
+        const data = await loadGate();
+        const initial = checkBlockReviews(data);
+        const descriptions = await resultFilesFor({ repoRoot: (await tree()).mainTop, runId, block: id, rows, includeCurrent: true });
+        const claimOf = (/** @type {string} */ file, /** @type {string} */ finding) => rows
+          .filter((r) => r.block === id && r.file === file && verifyRow(r, data.key).ok).flatMap((r) => {
+            const full = descriptions[r.ticket]?.findings;
+            return [...(r.finding === finding ? [r] : []), ...(Array.isArray(r.open) ? r.open : []), ...(Array.isArray(full) ? full : [])]
+              .filter((f) => (f?.id === finding || f?.finding === finding) && typeof f.claim === 'string');
+          }).at(-1)?.claim;
+        /** @type {Array<{label: string, write: (sink: (row: Record<string, any>) => Promise<unknown>) => Promise<unknown>}>} */
+        const actions = [];
+        const seen = new Set();
+        for (const refusal of initial.refusals) {
+          if (!['not_approved', 'late_unruled', 'review_cap', 'autopilot_waiver_invalid'].includes(refusal.code) || !refusal.file || !refusal.finding || refusal.finding === PROOF_FINDING) continue;
+          const { file, finding } = refusal;
+          const pair = `${file}\0${finding}`;
+          if (seen.has(pair)) continue;
+          seen.add(pair);
+          await waivePrecheck(record, runId, id, finding, file);
+          const severity = recordedSeverity(rows, { block: id, file, finding, key: data.key }).severity ?? 'unknown';
+          actions.push({ label: `${file} ${finding} ${severity}: ${claimOf(file, finding) ?? refusal.detail}`, write: (sink) => waiveFinding({ runId, id, file, finding, reason: /** @type {string} */ (flags.reason), writeRow: sink }) });
+        }
+        if (!agentWaiversAcked(record, rows, id, data.key)) {
+          const ack = await prepareAckWaivers(record, runId, id);
+          actions.push({ label: ack.counted.map((w) => `${w.file} ${w.finding} ${w.severity}: agent-waivers-not-acked ${claimOf(w.file, w.finding) ?? w.reason}; reason: ${w.reason}; verdict: ${w.verdict}`).join('; '), write: (sink) => writeSigned(runId, sink, ack.row) });
+        }
+        const hits = acceptedTranscriptHits(data).remaining;
+        for (const hit of hits) {
+          const prepared = await prepareAcceptHit({ runId, id, flags: { rule: hit.id, line: String(hit.line), transcript: transcriptFile, reason: flags.reason }, positionals: [id], extraTokens });
+          for (const row of prepared.rows) actions.push({ label: `${transcriptFile} ${row.rule} severity rule_break line ${row.line}: ${data.transcript?.split('\n')[row.line - 1]}`, write: (sink) => writeAcceptedHit({ runId, row, writeRow: sink }) });
+        }
+        const count = rows.length;
+        const buffered = async (/** @type {Record<string, any>} */ row) => { rows.push(row); };
+        for (const action of actions) await action.write(buffered);
+        const preview = await closeBlock({ ...closeOptions, dryRun: true });
+        rows.splice(count);
+        // Reset anything buffered by report, proof and review checks before the real pass.
+        closeRows.splice(0, closeRows.length, ...(external === null ? [] : [{ event: 'gate.reviews_waived', block: id, by: 'config', reviewer: external }]));
+        linesOnce = undefined;
+        actions.forEach((action, index) => (json ? err : say)(`${index + 1}. ${action.label}\n`));
+        if (!preview.ok) { err(`cannot decide here: ${preview.reason}\n`); return 1; }
+        const asked = await confirmAtTerminal(deps, `Apply these decisions and close block ${id} of run ${runId}? Only the owner may say yes.`);
+        if (asked === 'no-tty') { err(`${humanVerbNoTTY('close')}\n`); return 2; }
+        if (asked === 'cancelled') { err(`block ${id} close: cancelled — nothing was recorded\n`); return 1; }
+        for (const action of actions) await action.write(writeRow);
+        rows.splice(0, rows.length, ...(await readAllRows(record.project)).filter((row) => row.run === runId));
+      }
+      if (routineGrant !== null) {
+        const data = await loadGate();
+        const problem = external !== null ? 'external reviews' : routineCloseProblem(data);
+        if (problem !== null) { err(`close-not-routine: ${problem}\n`); return 1; }
+        const preview = await closeBlock({ ...closeOptions, dryRun: true });
+        if (!preview.ok) { err(`close-not-routine: ${preview.reason}\n`); return 1; }
+        closeRows.splice(0, closeRows.length, { event: 'autopilot.close', block: id, grant: routineGrant.grant_id });
+        linesOnce = undefined;
+      }
+      dryRun = false;
+      // The confirmation can take arbitrarily long: measure current bytes again at real close.
+      if (deciding || routineGrant !== null) {
+        treeOnce = undefined;
+        linesOnce = undefined;
+        lineWarnings.length = 0;
+      }
+      const result = await closeBlock(closeOptions);
       const agentRows = agentWaivers(rows, id, await loadKey(runId));
       const reopenedRows = agentReopens(rows.filter((r) => r.run === runId), id, await loadKey(runId));
       // B64b: the block ended (closed, or stopped by a worker pin event or ledger.tamper) — its rows
@@ -840,9 +1021,7 @@ export async function runBlock(args, deps = {}) {
         // B70: each file that passed as reviewed_by_waiver is named before the closed line
         // B71: an answered finding is named as answered; a file with only answered findings has no `by`
         if (result.ok) {
-          if (configInForce(record)?.gates?.test != null && lastGate(rows.filter((row) => row.block === id)).result !== 'pass') {
-            err(`WARN block ${id}: no green gates run for this block; run gates run --run ${runId} --block ${id} before close\n`);
-          }
+          await warnMovedBase(record.workspace, entry, id, runId, err);
           for (const w of lineWarnings) err(w);
           for (const l of reviewedJson) say(`reviewed ${l.file} ticket ${l.ticket}\n`);
           for (const f of waivedAll) {
@@ -854,7 +1033,10 @@ export async function runBlock(args, deps = {}) {
           for (const r of reopenedRows) say(`agent reopen ${r.file}: ${r.reason} (verdict: ${r.verdict?.verdict})\n`);
           for (const hit of acceptedHits) say(`accepted rule_break ${hit.rule} transcript line ${hit.line}: ${hit.reason} (by: human)\n`);
         }
-        (result.ok ? say : err)(`block ${id} ${result.status}${result.event ? ` (${result.event})` : ''}${result.reason ? `: ${result.reason}` : ''}\n`);
+        if (result.status === 'awaiting_human_check') {
+          for (const check of entry.human_checks) say(`block ${id} awaiting human check: ${check}\n`);
+          say(`next: code-forge block human-pass ${id} --run ${runId} --note "<device check note>" [--proof <dir-or-file>]\n`);
+        } else (result.ok ? say : err)(`block ${id} ${result.status}${result.event ? ` (${result.event})` : ''}${result.reason ? `: ${result.reason}` : ''}\n`);
         // B64a: a refused close also names itself on stdout under --json (its stderr is unchanged)
         if (json && !result.ok) emit({ block: id, ok: false, reason: result.reason ?? null, ...(end?.json ?? {}) });
         const closedJson = {
@@ -863,6 +1045,7 @@ export async function runBlock(args, deps = {}) {
           status: result.status,
           reason: result.reason ?? null,
           close_event: result.event ?? null,
+          ...(result.status === 'awaiting_human_check' ? { human_checks: entry.human_checks, next_command: `code-forge block human-pass ${id} --run ${runId} --note "<device check note>"` } : {}),
           ...(end?.json ?? {}),
           // B70: only when a file passed as reviewed_by_waiver (otherwise the output is unchanged)
           ...(result.ok && waivedAll.length > 0 ? { reviewed_by_waiver: waivedAll.map((f) => ({ file: f.file, content_hash: f.content_hash, status: f.status, findings: f.findings, by: f.by, ...(f.answered?.length ? { answered: f.answered } : {}) })) } : {}),
@@ -872,7 +1055,7 @@ export async function runBlock(args, deps = {}) {
           ...(reopenedRows.length > 0 ? { agent_reopens: reopenedRows } : {}),
           ...(acceptedHits.length > 0 ? { accepted_hits: acceptedHits } : {}),
         };
-        if (!result.ok || !removeTree) {
+        if (!result.ok || !removeTree || result.status === 'awaiting_human_check') {
           if (json && result.ok) emit(closedJson);
           return result.ok ? 0 : 1;
         }
@@ -896,6 +1079,32 @@ export async function runBlock(args, deps = {}) {
   return 2;
 }
 
+/**
+ * Advisory only, after a successful close: missing refs or failed history reads cannot change
+ * the close's exit code. Resolve the recorded branch, regardless of the workspace's checkout.
+ * @param {string} cwd @param {Record<string, any>} block @param {string} id @param {string} runId
+ * @param {(text: string) => unknown} warn
+ */
+async function warnMovedBase(cwd, block, id, runId, warn) {
+  if (!block.base_branch) return;
+  try {
+    const opts = { cwd, env: gitChildEnv(), timeoutMs: 10000 };
+    const head = await exec(['git', 'rev-parse', '--verify', '--end-of-options', `refs/heads/${block.base_branch}^{commit}`], opts);
+    if (head.result !== 'ok' || head.stdout.trim() === block.base_sha) return;
+    const blockHead = await exec(['git', 'rev-parse', '--verify', 'HEAD^{commit}'], { ...opts, cwd: block.worktree?.path ?? cwd });
+    if (blockHead.result !== 'ok') return;
+    // A base advanced by this block's own commits is already incorporated. Only exit 1
+    // means "not an ancestor"; errors and timeouts must not produce an advisory.
+    const ancestor = await exec(['git', 'merge-base', '--is-ancestor', head.stdout.trim(), blockHead.stdout.trim()], { ...opts, okExitCodes: [0, 1] });
+    if (ancestor.result !== 'ok' || ancestor.code !== 1) return;
+    const count = await exec(['git', 'rev-list', '--count', `${block.base_sha}..${head.stdout.trim()}`], opts);
+    if (count.result !== 'ok' || !/^\d+$/.test(count.stdout.trim())) return;
+    warn(`WARN block ${id}: base moved: ${block.base_branch} is ${count.stdout.trim()} commit(s) ahead of the block base; run: code-forge block rebase ${id} --run ${runId}\n`);
+  } catch {
+    // The close already succeeded; this warning is best effort.
+  }
+}
+
 /**
  * B62a: `block close --remove-worktree`, after the block closed: `git worktree remove <path>` (no
  * `--force`, the branch is kept), then a signed `worktree.removed {block, path, branch}` or
@@ -959,7 +1168,7 @@ export const NO_REVIEWS_NO_TTY = '--no-require-reviews needs the human at a term
 
 /**
  * B80: the refusal when `block waive` or `block reopen` has no terminal to ask the human at.
- * @param {'waive' | 'reopen' | 'accept-hit' | 'unwaive' | 'ack-waivers'} verb @returns {string}
+ * @param {'waive' | 'reopen' | 'accept-hit' | 'unwaive' | 'ack-waivers' | 'human-pass' | 'amend-acceptance' | 'close'} verb @returns {string}
  */
 export const humanVerbNoTTY = (verb) => verb === 'waive'
   ? 'block waive needs the human at a terminal to confirm; nothing was recorded (--yes works only for a recorded warning or nit finding, with evidence)'
@@ -979,7 +1188,7 @@ export const humanVerbNoTTY = (verb) => verb === 'waive'
  * terminal check and the question (a refusal it throws means the human is never asked).
  * `deps.stdinIsTTY` / `deps.stdoutIsTTY` inject each side, `deps.isTTY` both at once, `deps.ui`
  * the prompt (default `@clack/prompts`). A "no" or a cancel (Ctrl-C) is `cancelled`.
- * @param {ConfirmDeps} deps @param {string} message
+ * @param {ConfirmDeps} deps @param {string | (() => string)} message
  * @param {() => Promise<unknown> | unknown} [before]
  * @returns {Promise<'no-tty' | 'confirmed' | 'cancelled'>}
  */
@@ -989,7 +1198,7 @@ async function confirmAtTerminal(deps, message, before) {
   if (!(stdinTTY && stdoutTTY)) return 'no-tty';
   if (before) await before();
   const ui = deps.ui ?? /** @type {any} */ (await import('@clack/prompts'));
-  const go = await ui.confirm({ message, initialValue: false });
+  const go = await ui.confirm({ message: typeof message === 'function' ? message() : message, initialValue: false });
   return ui.isCancel(go) || go !== true ? 'cancelled' : 'confirmed';
 }
 
@@ -1016,29 +1225,38 @@ async function confirmNoReviews(runId, id, deps) {
 /**
  * B80: `block waive` and `block reopen` are the human's alone (D1 = a): the human confirms at a
  * terminal through `confirmAtTerminal`, exactly like `--no-require-reviews`, but an active
- * autopilot grant changes nothing (autopilot waives through its own path, `by: autopilot`). The
+ * autopilot grant changes nothing for waive/reopen (autopilot waives through its own path,
+ * `by: autopilot`); human-pass instead refuses an active grant. The
  * pre-checks (`reopenPrecheck`, `waivePrecheck`) run first, at a terminal, so the human is never
  * asked about a waive or reopen the verb would refuse that way.
- * @param {'waive' | 'reopen' | 'accept-hit' | 'unwaive' | 'ack-waivers'} verb @param {string} runId @param {string} id
- * @param {{finding?: string, file: string, rule?: string, line?: number}} what @param {Record<string, any>} record @param {ConfirmDeps} deps
- * @param {() => void} [before]
+ * @param {'waive' | 'reopen' | 'accept-hit' | 'unwaive' | 'ack-waivers' | 'human-pass' | 'amend-acceptance'} verb @param {string} runId @param {string} id
+ * @param {{finding?: string, file: string, rule?: string, line?: number, hits?: {rule: string, line: number}[], oldCount?: number, newCount?: number}} what @param {Record<string, any>} record @param {ConfirmDeps} deps
+ * @param {() => Promise<unknown> | unknown} [before]
  * @returns {Promise<'no-tty' | 'confirmed' | 'cancelled'>}
  */
 function confirmHumanVerb(verb, runId, id, what, record, deps, before) {
-  const message =
-    verb === 'waive'
+  const message = () =>
+    verb === 'amend-acceptance'
+      ? `Amend acceptance of block ${id} (run ${runId}) from ${what.oldCount} clauses to ${what.newCount} clauses? Only the owner may say yes.`
+      : verb === 'human-pass'
+      ? `Confirm all device checks of block ${id} (run ${runId}) passed? Only the owner may say yes.`
+      : verb === 'waive'
       ? `Waive finding ${what.finding} in ${what.file} of block ${id} (run ${runId})? Only the owner may say yes.`
       : verb === 'unwaive'
         ? `Undo agent waivers for finding ${what.finding} in ${what.file} of block ${id} (run ${runId})? Only the owner may say yes.`
       : verb === 'ack-waivers'
         ? `Acknowledge the listed agent waivers of block ${id} (run ${runId})? Only the owner may say yes.`
       : verb === 'accept-hit'
-        ? `Accept false transcript hit ${what.rule} at line ${what.line} in ${what.file} of block ${id} (run ${runId})? Only the owner may say yes.`
+        ? `Accept false transcript ${what.hits ? `hits ${what.hits.map((hit) => `${hit.rule} at line ${hit.line}`).join(', ')}` : `hit ${what.rule} at line ${what.line}`} in ${what.file} of block ${id} (run ${runId})? Only the owner may say yes.`
         : `Reopen the review of ${what.file} in block ${id} (run ${runId})? Only the owner may say yes.`;
   return confirmAtTerminal(deps, message, async () => {
+    if (verb === 'human-pass') {
+      if (record.blocks?.[id]?.status !== 'awaiting_human_check') throw new StateError('not-awaiting', `block ${id} is not awaiting a human check`);
+      if ((await checkExpiry(runId, (deps.now ?? (() => new Date()))())).state === 'active') throw new StateError('autopilot-active', `block human-pass is refused while an autopilot grant is active on run ${runId}`);
+    }
     if (verb === 'reopen') await reopenPrecheck(record, runId, id, what.file);
     else if (verb === 'waive') await waivePrecheck(record, runId, id, /** @type {string} */ (what.finding), what.file);
-    before?.();
+    await before?.();
   });
 }
 
@@ -1148,10 +1366,11 @@ async function openConfig(workspace) {
  * The block's coder transcript: `--transcript`, else the run record's `blocks.<id>.transcript`
  * (workspace-relative), else `.code-forge/runs/<run>/<id>.log`; null when none exists.
  * @param {Record<string, any>} record @param {string} id @param {string | null} given
+ * @param {(file: string) => void} [onFile]
  * @returns {Promise<string | null>}
  */
-async function findTranscript(record, id, given) {
-  if (given !== null) return readFile(given, 'utf8');
+async function findTranscript(record, id, given, onFile) {
+  if (given !== null) { const text = await readFile(given, 'utf8'); onFile?.(given); return text; }
   const recorded = record.blocks?.[id]?.transcript;
   const candidates = [
     ...(typeof recorded === 'string' && recorded.length > 0 ? [path.resolve(record.workspace, recorded)] : []),
@@ -1159,7 +1378,9 @@ async function findTranscript(record, id, given) {
   ];
   for (const file of candidates) {
     try {
-      return await readFile(file, 'utf8');
+      const text = await readFile(file, 'utf8');
+      onFile?.(file);
+      return text;
     } catch (thrown) {
       if (/** @type {any} */ (thrown)?.code !== 'ENOENT') throw thrown;
     }