@codedology/code-forge 0.15.3 → 0.16.0

package/src/cli/block.mjs

@@ -8,7 +8,8 @@
  *   block attempt <id> --run <r>
  *   block rebase <id> --run <r> [--head <ref>]
  *   block claim <id> <path> --run <r>
- *   block close <id> --run <r> [--worker-pid <pid>] [--remove-worktree]
+ *   block close <id> --run <r> [--worker-pid <pid>] [--remove-worktree] [--auto-claim]
+ *   block land <id> --run <r> --report <file> --transcript <file> [--max <dur>] [--merge] [--no-merge-gate] [--json]
  *   block stop <id> --run <r> --reason <text>
  *   block waive <id> <finding-id> --run <r> --file <path> --reason <text> [--yes]   (orchestrator --yes: evidence and a fresh judge)
  *   block reopen <id> --run <r> --file <path> --reason <text> [--yes]   (B124c: evidence and a fresh judge for the agent path)
@@ -197,9 +198,12 @@
 
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, statSync } from 'node:fs';
-import { readFile, realpath } from 'node:fs/promises';
+import { mkdtemp, readFile, realpath, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { parse as parseYAML } from 'yaml';
+import { runGatesVerb } from './gates.mjs';
+import { parseTapPassed } from '../gates/acceptance.mjs';
+import { parseMax, requeueStoppedFiles, runReviewFile } from './review-file.mjs';
 import { approvalCheckText, expiryChecks } from '../autopilot/limits.mjs';
 import { fallbackLane } from '../decide/fallback-rules.mjs';
 import { laneFacts } from '../decide/lane-facts.mjs';
@@ -296,9 +300,236 @@ async function reopenBlockFile({ runId, id, file, reason, record, writeRow, agen
   return { row, cleared, ticket };
 }
 
+/** Quote a displayed command for a POSIX shell; execution always uses argv.
+ * @param {string[]} argv @returns {string}
+ */
+function landCommand(argv) {
+  return argv.map((arg) => /^[\w./:@=-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", "'\\''")}'`).join(' ');
+}
+
+/** Claim only changes the normal scope check cannot account for, then join real review tickets.
+ * @param {{record: Record<string, any>, runId: string, id: string, writeRow: import('../state/run.mjs').WriteRow, print: (line: string) => void, join?: boolean}} opts
+ */
+async function autoClaimChanges({ record, runId, id, writeRow, print, join = true }) {
+  const entry = record.blocks[id];
+  const wt = await blockTree(record.workspace, entry);
+  const mainTop = await repoTop(record.workspace);
+  const top = wt?.top ?? mainTop;
+  const prefix = path.relative(mainTop, await realpath(record.workspace)).split(path.sep).join('/');
+  const owns = ownsAt(prefix);
+  const ownState = new Set([path.posix.join(prefix, `.code-forge/runs/${runId}.json`), path.posix.join(prefix, `.code-forge/runs/${runId}/${id}.log`)]);
+  const changed = (await changedFiles({ repoRoot: top, base: wt?.base_sha ?? entry.base_sha })).filter((f) => !ownState.has(f));
+  const scope = await unownedChanges({ top, changed, id, blocks: record.blocks, rows: (await readAllRows(record.project)).filter((r) => r.run === runId), key: await loadKey(runId),
+    isMine: (file) => owns(entry.owned_files, file, entry.owned_kinds), owns, ownTree: wt !== null });
+  const files = [...new Set([...(scope?.unowned ?? []), ...(scope?.siblings.map((s) => s.file) ?? [])])].sort();
+  if (files.length === 0) return;
+  const invoke = async (/** @type {string[]} */ args) => {
+    let output = '', error = '';
+    const code = await runReviewFile(args, { cwd: top, stdout: { write: (s) => { output += s; } }, stderr: { write: (s) => { error += s; } } });
+    let data;
+    try { data = JSON.parse(output); } catch { /* Excluded files print a text line. */ }
+    if (code !== 0) throw new StateError('auto-claim-review', error || output || 'auto-claim review failed');
+    return { data, output };
+  };
+  for (const file of files) {
+    await claimPath({ runId, id, file, writeRow, auto: true });
+    Object.assign(entry, (await readRun(runId)).blocks[id]);
+    print(`block ${id} auto-claimed ${file}\n`);
+    await invoke([file, '--block', id, '--run', runId]);
+  }
+  if (!join) return; // Land joins all claimed and originally owned paths under one deadline.
+  const joined = await invoke(['--wait-block', id, '--run', runId]);
+  if (joined.data?.done !== true) throw new StateError('auto-claim-review', `auto-claim reviews did not finish: ${joined.output.trim()}`);
+  for (const file of joined.data.files) {
+    if (file.status === 'excluded' || file.outcome === 'approved') continue;
+    const detail = file.ticket ? (await invoke(['--wait', file.ticket])).output : file.outcome ?? file.status;
+    throw new StateError('auto-claim-review', `auto-claim review refused ${file.file}: ${detail}`);
+  }
+}
+
+/** Join, gates and close share their existing CLI handlers, without spawning the CLI.
+ * @param {{id: string, runId: string, record: Record<string, any>, report: string, transcript: string, maxMs: number, merge: boolean, noMergeGate: boolean, json: boolean}} options
+ * @param {NonNullable<Parameters<typeof runBlock>[1]>} deps
+ * @returns {Promise<number>}
+ */
+async function landBlock({ id, runId, record, report, transcript, maxMs, merge, noMergeGate, json }, deps) {
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  const emit = (/** @type {Record<string, any>} */ value) => writeSafe(stdout, `${JSON.stringify(value)}\n`);
+  let step = 'join';
+  let next = landCommand(['code-forge', 'review-file', '--wait-block', id, '--run', runId]);
+  const stop = (/** @type {string} */ reason) => {
+    if (step === 'join' && reason === 'wait_timeout') {
+      next = landCommand(['code-forge', 'block', 'land', id, '--run', runId, '--report', report, '--transcript', transcript,
+        '--max', `${Math.max(1800, Math.ceil(maxMs / 500))}s`, ...(merge ? ['--merge'] : []), ...(noMergeGate ? ['--no-merge-gate'] : []), ...(json ? ['--json'] : [])]);
+    }
+    writeSafe(stderr, `block ${id} land stopped at ${step}: ${reason.trim()}\nnext: ${next}\n`);
+    if (json) emit({ block: id, event: 'refused', step, reason: reason.trim(), next });
+    return 1;
+  };
+  /** @param {(streams: {stdout: {write: (s: string) => void}, stderr: {write: (s: string) => void}}) => Promise<number>} run */
+  const capture = async (run) => {
+    let output = '';
+    let error = '';
+    const code = await run({ stdout: { write: (s) => { output += s; } }, stderr: { write: (s) => { error += s; } } });
+    /** @type {Record<string, any> | null} */
+    let data = null;
+    try { data = JSON.parse(output); } catch { /* A thrown refusal may only write stderr. */ }
+    return { code, output, error, data };
+  };
+  try {
+    const entry = record.blocks?.[id];
+    if (!entry) return stop(`unknown block in run ${runId}`);
+    if (entry.status !== 'open') return stop(`block is ${entry.status}, not open`);
+    const tree = await blockTree(record.workspace, entry);
+    if (!tree) return stop('block has no recorded worktree and branch');
+    const deadline = Date.now() + maxMs;
+    await autoClaimChanges({ record, runId, id, writeRow: (row) => appendRow(row, { slug: record.project }), print: (line) => writeSafe(json ? stderr : stdout, line), join: false });
+    let joined;
+    // Findings are usually final; cap retries so land does not wait the full --max on them.
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const remaining = Math.max(0, deadline - Date.now());
+      if (remaining === 0) return stop('wait_timeout');
+      const duration = remaining > 9_999_999 ? `${Math.floor(remaining / 1000)}s` : `${remaining}ms`;
+      joined = await capture((streams) => runReviewFile(['--wait-block', id, '--run', runId, '--max', duration], { ...streams, cwd: tree.workspace }));
+      for (const line of joined.error.split('\n')) if (line.startsWith('auto-requeue ')) writeSafe(stderr, `${line}\n`);
+      if (joined.code !== 0 || !joined.data?.done || !joined.data.files.some((file) => file.status === 'findings')) break;
+    }
+    if (joined.code !== 0 || !joined.data?.done) {
+      if (joined.data?.status === 'wait_timeout' || joined.data?.reason === 'wait_timeout' || Date.now() >= deadline) return stop('wait_timeout');
+      return stop(joined.error || joined.data?.message || joined.data?.reason || joined.data?.status || 'reviews did not finish');
+    }
+    const problems = joined.data.files.filter((/** @type {Record<string, any>} */ file) => file.status !== 'excluded' && file.outcome !== 'approved');
+    if (problems.length > 0) {
+      const details = [];
+      for (const file of problems) {
+        details.push(`${file.file}: ${file.outcome ?? file.status}`);
+        if (file.ticket) {
+          const result = await capture((streams) => runReviewFile(['--wait', file.ticket], { ...streams, cwd: tree.workspace }));
+          details.push(result.output.trim() || result.error.trim());
+        }
+      }
+      next = landCommand(['code-forge', 'review-file', '--wait', problems[0].ticket]);
+      return stop(details.join('\n'));
+    }
+
+    step = 'gates';
+    next = landCommand(['code-forge', 'gates', 'run', '--run', runId, '--block', id, '--changed']);
+    const gates = await capture((streams) => runGatesVerb(['run', '--run', runId, '--block', id, '--changed', '--cwd', tree.workspace], streams));
+    if (gates.code !== 0 || gates.data?.allOk !== true) return stop(gates.error + (gates.output || 'gates did not pass'));
+    if (gates.error) writeSafe(stderr, gates.error);
+
+    step = 'close';
+    const closeArgs = ['close', id, '--run', runId, '--report', report, '--transcript', transcript];
+    next = landCommand(['code-forge', 'block', ...closeArgs]);
+    const closed = await capture((streams) => runBlock([...closeArgs, '--json'], { ...deps, ...streams }));
+    if (closed.code !== 0 || closed.data?.status !== 'closed') {
+      if (typeof closed.data?.next_command === 'string') next = closed.data.next_command;
+      return stop(closed.error || closed.data?.reason || closed.data?.status || 'close refused');
+    }
+    if (closed.error) writeSafe(stderr, closed.error);
+
+    step = 'merge';
+    const main = await repoTop(record.workspace);
+    if (typeof entry.base_branch !== 'string' || !entry.base_branch) return stop('block has no recorded base branch');
+    const mergeArgs = ['git', '-C', main, 'merge', '--no-ff', '--no-edit', '--', tree.branch];
+    const command = landCommand(mergeArgs);
+    next = command;
+    if (!merge) {
+      writeSafe(json ? stderr : stdout, 'hint: the merge gate runs only with --merge\n');
+      if (json) emit({ block: id, event: 'closed', merge: command });
+      else writeSafe(stdout, `block ${id} closed; merge: ${command}\n`);
+      return 0;
+    }
+    const gitOptions = { cwd: main, env: gitChildEnv(), timeoutMs: 120000 };
+    const branch = await exec(['git', 'symbolic-ref', '-q', 'HEAD'], gitOptions);
+    if (branch.result !== 'ok' || branch.stdout.trim() !== `refs/heads/${entry.base_branch}`) {
+      next = `${landCommand(['git', '-C', main, 'checkout', entry.base_branch])} && ${command}`;
+      return stop(`main checkout must be on recorded base branch ${entry.base_branch}`);
+    }
+    const status = await exec(['git', 'status', '--porcelain', '--untracked-files=all'], gitOptions);
+    if (status.result !== 'ok') return stop(status.stderr || 'cannot check main checkout');
+    if (status.stdout) {
+      next = landCommand(['git', '-C', main, 'status', '--short']);
+      return stop('main checkout is dirty; commit or stash its changes before merging');
+    }
+    // Close measures uncommitted content too; never call that content landed if git cannot merge it.
+    const blockStatus = await exec(['git', 'status', '--porcelain', '--untracked-files=all'], { ...gitOptions, cwd: tree.top });
+    if (blockStatus.result !== 'ok' || blockStatus.stdout) {
+      next = landCommand(['git', '-C', tree.top, 'status', '--short']);
+      return stop('block worktree is dirty or unreadable; commit and review its changes before merging');
+    }
+    if (noMergeGate || configInForce(record)?.gates?.merge_gate === false) {
+      writeSafe(stderr, 'warning: merge gate skipped; merged full suite was not checked\n');
+    } else {
+      step = 'merge-gate';
+      next = landCommand(['code-forge', 'gates', 'run', '--cwd', tree.workspace]);
+      const mainHead = await exec(['git', 'rev-parse', '--verify', 'HEAD'], gitOptions);
+      const blockHead = await exec(['git', 'rev-parse', '--verify', `refs/heads/${tree.branch}`], gitOptions);
+      if (mainHead.result !== 'ok' || blockHead.result !== 'ok') return stop('cannot resolve merge parents');
+      const started = Date.now();
+      // A sibling of this run's block worktree, never the process temp directory.
+      const temporary = await mkdtemp(path.join(path.dirname(tree.path), '.merge-gate-'));
+      let added = false;
+      let failure = '';
+      try {
+        // mkdtemp gives an empty directory; git worktree add accepts an existing empty path.
+        const created = await exec(['git', 'worktree', 'add', '--detach', temporary, mainHead.stdout.trim()], gitOptions);
+        added = created.result === 'ok';
+        if (!added) throw new Error(created.stderr || 'cannot create merge-gate worktree');
+        const merged = await exec(['git', 'merge', '--no-ff', '--no-edit', '--', blockHead.stdout.trim()], { ...gitOptions, cwd: temporary });
+        if (merged.result !== 'ok') {
+          const conflicts = await exec(['git', 'diff', '--name-only', '--diff-filter=U'], { ...gitOptions, cwd: temporary });
+          failure = conflicts.stdout.trim() ? `merge conflict:\n${conflicts.stdout.trim()}` : merged.stderr || merged.stdout || 'trial merge failed';
+        } else {
+          const workspace = path.join(temporary, path.relative(main, record.workspace));
+          // No block scope: the shared gate runner drops scope tokens and runs the full suite.
+          const suite = await capture((streams) => runGatesVerb(['run', '--cwd', workspace], streams));
+          if (suite.code !== 0 || suite.data?.allOk !== true) {
+            const results = suite.data?.results ?? [];
+            const output = results.filter((r) => !r.ok).map((r) => `${r.stdout}\n${r.stderr}`).join('\n');
+            const failed = [...parseTapPassed(output).failed].slice(0, 10);
+            failure = failed.length ? `full suite failed:\n${failed.join('\n')}`
+              : `full suite failed:\n${(suite.error || output || suite.output).trim().split('\n').slice(-20).join('\n')}`;
+          } else if (!suite.data.results.some((r) => r.gate === 'test' && !r.skipped)) {
+            failure = 'full suite unavailable: configure gates.test before merging';
+          }
+        }
+      } finally {
+        const removed = await exec(['git', 'worktree', 'remove', '--force', temporary], gitOptions);
+        if (added && removed.result !== 'ok') throw new Error(`cannot remove merge-gate worktree ${temporary}: ${removed.stderr}`);
+        await rm(temporary, { recursive: true, force: true });
+      }
+      if (failure) return stop(failure);
+      // Refuse a moving target: only merge the same parents whose combined suite passed.
+      const currentMain = await exec(['git', 'rev-parse', '--verify', 'HEAD'], gitOptions);
+      const currentBlock = await exec(['git', 'rev-parse', '--verify', `refs/heads/${tree.branch}`], gitOptions);
+      const currentBranch = await exec(['git', 'symbolic-ref', '-q', 'HEAD'], gitOptions);
+      const currentStatus = await exec(['git', 'status', '--porcelain', '--untracked-files=all'], gitOptions);
+      if (currentMain.result !== 'ok' || currentBlock.result !== 'ok' || currentBranch.result !== 'ok' || currentStatus.result !== 'ok'
+        || currentMain.stdout !== mainHead.stdout || currentBlock.stdout !== blockHead.stdout || currentBranch.stdout !== branch.stdout || currentStatus.stdout) {
+        return stop('merge parents or main checkout changed during the full suite; check the checkout and rerun the merge gate');
+      }
+      writeSafe(json ? stderr : stdout, `merge gate: full suite passed (${((Date.now() - started) / 1000).toFixed(1)}s)\n`);
+    }
+    step = 'merge';
+    next = command;
+    const merged = await exec(mergeArgs, gitOptions);
+    if (merged.result !== 'ok') {
+      next = landCommand(['git', '-C', main, 'status']);
+      return stop(merged.stderr || merged.stdout || 'git merge failed; resolve the merge before continuing');
+    }
+    if (json) emit({ block: id, event: 'landed', merge: command });
+    else writeSafe(stdout, `block ${id} landed\n`);
+    return 0;
+  } catch (thrown) {
+    return stop(thrown?.message ?? String(thrown));
+  }
+}
+
 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|light] [--tests <paths…>] [--after <ids…>] [--after-outcome <ids…>]\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 attempt|rebase <id> --run <r> · block close <id> --run <r> [--transcript <file>] [--report <file>] [--no-require-reviews] [--remove-worktree] [--auto-claim] · 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' +
@@ -306,6 +537,7 @@ const USAGE =
   '       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' +
+  '       code-forge block land <id> --run <r> --report <file> --transcript <file> [--max <dur>] [--merge] [--no-merge-gate]\n' +
   '       every block verb takes --json: one JSON line on stdout ({"block","event",…}) instead of the text\n';
 
 /** @type {Record<string, string>} */
@@ -314,7 +546,8 @@ const VERB_USAGE = {
   attempt: '<id> --run <r>',
   rebase: '<id> --run <r> [--head <ref>] [--accept-changed <file>… --reason <text>]',
   claim: '<id> <path> --run <r>',
-  close: '<id> --run <r> [--worker-pid <pid>] [--transcript <file>] [--report <file>] [--no-require-reviews] [--remove-worktree] [--decide]',
+  close: '<id> --run <r> [--worker-pid <pid>] [--transcript <file>] [--report <file>] [--no-require-reviews] [--remove-worktree] [--auto-claim] [--decide]',
+  land: '<id> --run <r> --report <file> --transcript <file> [--max <dur>] [--merge] [--no-merge-gate]',
   stop: '<id> --run <r> --reason <text>',
   waive: '<id> <finding-id> --run <r> --file <path> --reason <text> [--yes]',
   reopen: '<id> --run <r> --file <path> --reason <text> [--yes]',
@@ -334,7 +567,11 @@ function verbUsage(sub) {
     (sub === 'open' || sub === 'amend-acceptance'
       ? '  --acceptance <file>  JSON/YAML list [{clause, tests}]; tests is a nonempty list of test ids.\n' +
         '                       Human checks use {clause, kind: human_check} without tests.\n' : '') +
-    (sub === 'open' ? '  --brief <file>       A file inside the repository, not inline text.\n' : '');
+    (sub === 'open' ? '  --brief <file>       A file inside the repository, not inline text.\n' : '') +
+    (sub === 'land' ? '  Join block reviews, run changed gates in its worktree, then close.\n' +
+      '  --max <dur>  Total review wait (default 30m); accepts 90s, 30m or 1500ms.\n' +
+      '  --merge     Check the merged full suite, then merge with --no-ff in the clean main checkout.\n' +
+      '  --no-merge-gate  Skip the merged full suite with a warning.\n' : '');
 }
 
 /** Refuse likely shell quoting slips before any row is written.
@@ -361,7 +598,7 @@ function checkWhitespacePaths(workspace, entries, label) {
     }
   }
 }
-const FLAG_VALUES = ['run', 'level', 'acceptance', 'brief', 'attempt', 'base', 'lines', 'head', 'worker-pid', 'reason', 'file', 'transcript', 'kind', 'report', 'rule', 'line', 'note', 'proof'];
+const FLAG_VALUES = ['run', 'level', 'acceptance', 'brief', 'attempt', 'base', 'lines', 'head', 'worker-pid', 'reason', 'file', 'transcript', 'kind', 'report', 'rule', 'line', 'note', 'proof', 'max'];
 
 /** Check specialist outcomes against the run's project, before state open can write anything.
  * @param {string} root @param {string} id @param {string[]} ids
@@ -423,7 +660,7 @@ export async function runBlock(args, deps = {}) {
   }
   let jsonOpenId;
   try {
-    const { flags, positionals } = parseFlags(rest, { values: FLAG_VALUES, multi: ['owned', 'tests', ...(sub === 'rebase' ? ['accept-changed'] : []), ...(sub === 'open' ? ['after', 'after-outcome'] : [])], booleans: ['no-require-reviews', 'remove-worktree', 'json', ...(sub === 'close' ? ['decide'] : []), ...(['waive', 'reopen'].includes(sub) ? ['yes'] : [])] });
+    const { flags, positionals } = parseFlags(rest, { values: FLAG_VALUES, multi: ['owned', 'tests', ...(sub === 'rebase' ? ['accept-changed'] : []), ...(sub === 'open' ? ['after', 'after-outcome'] : [])], booleans: ['no-require-reviews', 'remove-worktree', 'json', ...(sub === 'land' ? ['merge', 'no-merge-gate'] : []), ...(sub === 'close' ? ['decide', 'auto-claim'] : []), ...(['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;
@@ -441,6 +678,19 @@ export async function runBlock(args, deps = {}) {
     if (sub === 'open' && json) jsonOpenId = id;
     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 === 'land' && (positionals.length !== 1 || typeof flags.report !== 'string' || typeof flags.transcript !== 'string' || Object.keys(flags).some((key) => !['run', 'report', 'transcript', 'max', 'merge', 'no-merge-gate', 'json'].includes(key)))) {
+      throw new StateError('usage', 'block land takes one block id, --run, --report, --transcript and optional --max/--merge/--no-merge-gate/--json');
+    }
+    let landMaxMs = 30 * 60_000;
+    if (sub === 'land' && flags.max !== undefined) {
+      // Reuse review-file's parser, with minutes as a convenience for long lands.
+      try {
+        landMaxMs = typeof flags.max === 'string' && /^\d{1,7}m$/.test(flags.max)
+          ? parseMax(`${Number(flags.max.slice(0, -1)) * 60}s`) : parseMax(flags.max);
+      } catch {
+        throw new StateError('usage', '--max must look like 90s, 30m or 1500ms');
+      }
+    }
     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');
     }
@@ -469,6 +719,7 @@ export async function runBlock(args, deps = {}) {
       return 0;
     }
     const record = await readRun(runId);
+    if (sub === 'land') return await landBlock({ id, runId, record, report: /** @type {string} */ (flags.report), transcript: /** @type {string} */ (flags.transcript), maxMs: landMaxMs, merge: flags.merge === true, noMergeGate: flags['no-merge-gate'] === true, json }, deps);
     if (sub === 'amend-acceptance') {
       /** @type {ReturnType<typeof prepareAcceptanceAmendment> | null} */
       let prepared = null;
@@ -665,7 +916,7 @@ export async function runBlock(args, deps = {}) {
         }
         afterOutcome = acceptedOutcomes(record.workspace, id, flags['after-outcome']);
       }
-      const { block, pointer, worktreeReused } = await openBlock({
+      const { block, pointer, worktreeReused, keptClaims } = await openBlock({
         runId,
         id,
         level,
@@ -690,6 +941,7 @@ export async function runBlock(args, deps = {}) {
       const testCount = Array.isArray(block.test_files) ? block.test_files.length : 0;
       const tests = testCount > 0 ? ` · ${testCount} test file${testCount === 1 ? '' : 's'}` : '';
       say(`block ${id} open · ${block.level}${raised}${chosen} · ${block.kind} · attempt ${block.attempt} · base ${block.base_sha.slice(0, 12)}${tests}\n`);
+      if (keptClaims > 0) say(`kept claims: ${keptClaims}\n`);
       if (block.worktree) say(`worktree ${block.worktree.path} · branch ${block.worktree.branch}${worktreeReused ? ' · reused' : ''}\n`);
       say(`${pointer ?? 'brief: none given (--brief <file>)'}\n`);
       if (json) {
@@ -701,6 +953,7 @@ export async function runBlock(args, deps = {}) {
           source: typeof flags.level === 'string' ? 'flag' : rules ? 'rules' : 'autopilot',
           kind: block.kind,
           attempt: block.attempt,
+          ...(keptClaims > 0 ? { kept_claims: keptClaims } : {}),
           base_sha: block.base_sha,
           tests: testCount,
           worktree: block.worktree ? { path: block.worktree.path, branch: block.worktree.branch, reused: Boolean(worktreeReused) } : null,
@@ -710,9 +963,10 @@ export async function runBlock(args, deps = {}) {
       return 0;
     }
     if (sub === 'attempt') {
-      const n = await attemptBlock({ runId, id, writeRow });
+      const { attempt: n, keptClaims } = await attemptBlock({ runId, id, writeRow });
       say(`block ${id} attempt ${n}\n`);
-      if (json) emit({ block: id, event: 'attempt', attempt: n });
+      if (keptClaims > 0) say(`kept claims: ${keptClaims}\n`);
+      if (json) emit({ block: id, event: 'attempt', attempt: n, ...(keptClaims > 0 ? { kept_claims: keptClaims } : {}) });
       return 0;
     }
     if (sub === 'rebase') {
@@ -802,9 +1056,28 @@ export async function runBlock(args, deps = {}) {
       }
       // B58: the owner's other way out — `review.external.required` in the run's config snapshot
       // (set before `run start`, immutable): no TTY, allowed under autopilot, the human flag wins
+      if (flags['auto-claim'] === true) await autoClaimChanges({ record, runId, id, writeRow, print: json ? err : say });
       const external = reviewsWaived ? null : externalReviewer(record);
       const reviewConfig = configInForce(record);
-      const rows = (await readAllRows(record.project)).filter((row) => row.run === runId);
+      let rows = (await readAllRows(record.project)).filter((row) => row.run === runId);
+      // Restart changed stopped findings before entering closeBlock's run lock: the worker
+      // needs that lock to publish its fresh review. Refresh rows after the join finishes.
+      if (!reviewsWaived && external === null && !deciding && routineGrant === null) {
+        const mainTop = await repoTop(record.workspace);
+        const restarted = await requeueStoppedFiles({ repoRoot: mainTop, run: runId, block: id,
+          tree: wt?.top ?? mainTop, files: reviewedFiles(rows, id), print: err });
+        if (restarted.size > 0) {
+          let output = '';
+          const code = await runReviewFile(['--wait-block', id, '--run', runId], {
+            cwd: wt?.workspace ?? record.workspace, stdout: { write: (text) => { output += text; } }, stderr: { write: err },
+          });
+          if (code !== 0 || JSON.parse(output).done !== true) {
+            err(`block ${id} open: automatic requeue did not finish\n`);
+            return code || 1;
+          }
+          rows = (await readAllRows(record.project)).filter((row) => row.run === runId);
+        }
+      }
       // B52: ONE path base and ONE listing, memoised as a promise and shared by every check. The
       // base is the repository top level: the worker signs every review row with a repo-root-
       // relative `file` and keeps its queue and signed result files under `<top>/.code-forge/`

package/src/cli/doctor.mjs

@@ -10,12 +10,16 @@
 import { randomBytes } from 'node:crypto';
 import { rmSync } from 'node:fs';
 import path from 'node:path';
-import { loadProjectConfig } from '../config/load.mjs';
+import { loadProjectConfig, projectRootFor } from '../config/load.mjs';
 import { runDoctor } from '../doctor/index.mjs';
 import { counts, exitCode, renderJSON, renderText } from '../doctor/rows.mjs';
 import { parseFlags } from '../state/cli-args.mjs';
+import { configInForce } from '../state/config-snapshot.mjs';
+import { readRun } from '../state/run.mjs';
+import { daemonEnabled, daemonRequest, nativePath, runNative } from '../util/native.mjs';
 import { writeSafe } from '../util/redact.mjs';
 import { runRoot, setRunRoot } from '../util/tmp.mjs';
+import { liveWorker } from '../worker/queue.mjs';
 
 const USAGE = 'usage: code-forge doctor [--quick] [--json] [--cwd <dir>]\n';
 
@@ -56,6 +60,33 @@ export async function runDoctorCli(args, deps = {}, adopt = false) {
   }
   try {
     const rows = await runDoctor({ cwd, quick: flags.quick === true, ...(root ? { runRootDir: root } : {}) }, deps);
+    if (!flags.quick) {
+      const binary = nativePath();
+      let nativeDetail = 'not found, using Node';
+      let nativeOK = false;
+      if (binary) {
+        const result = await runNative(['version']);
+        try {
+          const version = result?.code === 0 ? JSON.parse(result.stdout) : null;
+          if (typeof version?.version === 'string') {
+            nativeOK = true;
+            nativeDetail = `${binary}, version ${version.version}`;
+          } else nativeDetail = `${binary}: unavailable, using Node`;
+        } catch { nativeDetail = `${binary}: unavailable, using Node`; }
+      }
+      rows.push({ id: 'native', status: nativeOK ? 'OK' : 'INFO', label: 'native binary', detail: nativeDetail });
+      let daemon = 'off';
+      try {
+        const loaded = await loadProjectConfig(cwd);
+        const worker = liveWorker(projectRootFor(cwd));
+        const config = (worker ? configInForce(await readRun(worker.run)) : null)
+          ?? (loaded.ok ? loaded.config : { native: { daemon: false } });
+        if (daemonEnabled(config)) {
+          daemon = worker && await daemonRequest(worker.run, { method: 'ping' }, { config }) ? 'live' : 'fallback';
+        }
+      } catch { /* an unreadable config or worker leaves native acceleration off */ }
+      rows.push({ id: 'native_daemon', status: 'INFO', label: 'native daemon', detail: daemon });
+    }
     writeSafe(stdout, flags.json ? renderJSON(rows) : renderText(rows));
     const c = counts(rows);
     writeSafe(stderr, `doctor: ${c.OK} ok, ${c.WARN} warn, ${c.FAIL} fail\n`);

package/src/cli/help.mjs

@@ -47,6 +47,7 @@ export default async function help(_args, context = {}) {
   process.stdout.write('\nBlock usage: code-forge block <verb> --help (or -h).\n');
   process.stdout.write('  block open --acceptance <file>: JSON/YAML list [{clause, tests}]; tests is a nonempty list of test ids.\n');
   process.stdout.write('  block open --brief <file>: a file inside the repository, not inline text.\n');
+  process.stdout.write('  block land <id> --run <r> --report <file> --transcript <file> [--merge] [--json]: join reviews, run changed gates, close, then optionally merge with --no-ff.\n');
   process.stdout.write('  Configuration fallback entries must be {provider, model} objects, not model-name strings (optional effort).\n');
   return 0;
 }

package/src/cli/native-status.mjs

@@ -0,0 +1,13 @@
+// One companion per native daemon: reuse status's config and review-gate rules
+// over the daemon's cached record/rows, without rereading the ledger or running ps.
+import { createInterface } from 'node:readline';
+import { statusOf } from './status.mjs';
+
+for await (const line of createInterface({ input: process.stdin, crlfDelay: Infinity })) {
+  try {
+    const { record, rows } = JSON.parse(line);
+    process.stdout.write(`${JSON.stringify({ runs: [await statusOf(record, rows)] })}\n`);
+  } catch {
+    process.stdout.write(`${JSON.stringify({ ok: false, error: 'status-unreadable' })}\n`);
+  }
+}