@codedology/code-forge 0.15.2 → 0.15.4

package/src/session/facts.mjs

@@ -104,9 +104,9 @@ export class FactsError extends Error {
 const PATTERNS = /** @type {ReadonlyArray<[ClaimKind, RegExp]>} */ ([
   ['endpoint', /https?:\/\/[^\s`'"<>)\]|]+/g],
   ['package', /(?<![\w./@-])@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*/g],
-  ['path', /(?<![\w/.~-])(?:~|\.{1,2})\/[^\s`'"<>)\]|,;]*/g],
+  ['path', /(?<![\w/.~-])(?:~|\.{1,2}|[\w.-]+)?\/[^\s`'"<>)\]|,;]*/g],
   ['flag', /(?<![\w-])--[a-z][a-z0-9-]*/g],
-  ['version', /(?<![\w.§])\d+\.\d+(?:\.\d+)*/g],
+  ['version', /(?<![\w.§])(?<!§ )\d+\.\d+(?:\.\d+)*/g],
   ['env', /(?<![\w])\$?[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+(?![\w])/g],
 ]);
 
@@ -122,6 +122,7 @@ const trimTail = (token) => token.replace(/[.,:;]+$/, '');
  *   `bin` keys, {@link readProjectBins}); none ⇒ command claims are kept as written.
  * @property {string} [briefText] - the brief alone (no sources): only IT can name the project CLI
  *   that a command claim gets prefixed with (default: the whole text).
+ * @property {string} [projectDir] - project root whose top-level folders admit extensionless paths.
  */
 
 /**
@@ -205,6 +206,8 @@ export function readProjectBins(projectDir) {
  */
 export function extractClaims(text, opts = {}) {
   let masked = String(text);
+  const topLevelFolders = new Set(opts.projectDir === undefined ? [] : readdirSync(opts.projectDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory()).map((entry) => entry.name));
   /** @type {Array<{index: number, token: string, kind: ClaimKind}>} */
   const found = [];
   /** @param {number} start @param {number} length */
@@ -215,7 +218,9 @@ export function extractClaims(text, opts = {}) {
   const scan = (kind, re) => {
     for (const m of [...masked.matchAll(re)]) {
       const token = trimTail(kind === 'env' ? m[0].replace(/^\$/, '') : m[0]);
-      if (token.length === 0 || (kind === 'path' && /^(~|\.{1,2})\/$/.test(token))) continue;
+      if (token.length === 0 || (kind === 'path' && /^(~|\.{1,2})?\/$/.test(token))) continue;
+      if (kind === 'path' && !/^(~|\.{1,2})?\//.test(token)
+        && !/\.[a-zA-Z0-9][\w-]*$/.test(token) && !topLevelFolders.has(token.split('/')[0])) continue;
       found.push({ index: /** @type {number} */ (m.index), token, kind });
       mask(/** @type {number} */ (m.index), m[0].length);
     }
@@ -778,7 +783,8 @@ function ruleBroken(row, claim, ctx) {
 
 /**
  * Validate the delegate's answer (step 3). Null commands/excerpts are normalized on a copy and
- * their matched claims downgraded; every other schema-invalid answer is refused. A row answers
+ * their matched claims downgraded; long excerpts are capped without changing the tag. Every other
+ * schema-invalid answer is refused. A row answers
  * claim `F<n>` when its fact_id is `F<n>` and its kind is the claim's kind (the id is the anchor,
  * the claim text may be reworded); failing that, when its echoed claim ({@link echoedClaim})
  * equals the claim token and its fact_id is `F<n>` or its kind is the claim's kind. Claims the
@@ -802,9 +808,11 @@ export function validateFacts(answer, claims, opts = {}) {
     for (const row of normalized.facts) {
       if (!row || typeof row !== 'object' || Array.isArray(row)) continue;
       const fields = ['command', 'output_excerpt'].filter((field) => row[field] === null);
-      if (fields.length === 0) continue;
       for (const field of fields) row[field] = '';
-      nullFields.set(row, fields);
+      if (fields.length > 0) nullFields.set(row, fields);
+      if (typeof row.output_excerpt === 'string' && row.output_excerpt.length > EXCERPT_MAX) {
+        row.output_excerpt = `${row.output_excerpt.slice(0, EXCERPT_MAX - 1)}…`;
+      }
     }
   }
   if (!validateFile(normalized)) {
@@ -1194,8 +1202,12 @@ export async function buildFacts(opts, deps = {}) {
   if (opts.projectDir !== undefined) {
     try { projectBins = readProjectBins(opts.projectDir); } catch { projectBins = []; }
   }
-  const extractOpts = opts.projectDir === undefined ? {} : { projectBins, briefText };
+  const extractOpts = opts.projectDir === undefined ? {} : { projectBins, briefText, projectDir: opts.projectDir };
   const claims = extractClaims([briefText, ...readSourcesText(opts.sources ?? [])].join('\n'), extractOpts);
+  const lines = briefText.split(/\r?\n/).length - Number(briefText.endsWith('\n'));
+  if (lines > 40 && claims.length < 5) {
+    (deps.stderr ?? process.stderr).write(`forge facts: the brief has ${lines} lines but only ${claims.length} claims; the sheet checks almost nothing\n`);
+  }
   const root = opts.runRoot ?? currentRunRoot();
   // B9b.1: a run root inside a git work tree (`tmp.root` configured in the project) cannot hold
   // the snapshot — git and the harness would walk up into the live repo — so the facts area moves

package/src/session/plan-check.mjs

@@ -358,7 +358,10 @@ export function checkPlan(text, opts = {}) {
   const projectBins = () => (binsCache ??= typeof given === 'function' ? given() : given ?? []);
   for (const b of blocks) {
     for (const clause of splitClauses(b.acceptance)) {
-      const unbacked = extractClaims(clause).filter((c) => !isVerified(c, verified, projectBins));
+      // A trailing parenthesized test citation names planned coverage, not a fact about
+      // an existing file. Paths in the clause itself still need facts or tolerances.
+      const factualClause = clause.replace(/\((?:\s*`(?:\.\/)?(?:test|tests|spec)\/[^`\n]+\.[\w]+`[\s,]*)+\)\s*$/, '');
+      const unbacked = extractClaims(factualClause).filter((c) => !isVerified(c, verified, projectBins));
       if (unbacked.every((c) => tolerances.some((t) => t.includes(c.token) && idRe(b.id).test(t)))) continue;
       errors.push(`unbackable clause without tolerance: ${b.id} ${clause}`);
     }

package/src/session/spawn.mjs

@@ -51,6 +51,7 @@ import { Ajv2020 } from 'ajv/dist/2020.js';
 import { CODEX_CLOSED_BOOK_REFUSAL, closedBookRefused, isNoToolRole, openBookCodexAllowed } from '../config/closed-book.mjs';
 import { resolveLevel } from '../config/known-ids.mjs';
 import { compileSchema } from '../config/schema-compile.mjs';
+import { blockTaskLines, ContextError, readBlockBrief } from '../context/pack.mjs';
 import { buildArgv } from '../engines/builders/index.mjs';
 import { removeCodexHome } from '../engines/codex-home.mjs';
 import { cliNameForProvider } from '../engines/provider-cli.mjs';
@@ -61,6 +62,7 @@ import { budgetUsdOf, checkBudget, estimateSessionUsd, priceSession, reservedUsd
 import { appendRow, readAllRows } from '../ledger/write.mjs';
 import { categoryGate, categoryPlan, RECORD_UNKNOWN_MESSAGE } from '../autopilot/limits.mjs';
 import { StateError } from '../state/paths.mjs';
+import { readRun } from '../state/run.mjs';
 import { exec } from '../util/exec.mjs';
 import { isForbidden, mergeForbidden } from '../util/forbidden.mjs';
 import { semaphore } from '../util/locks.mjs';
@@ -68,6 +70,7 @@ import { readStartTime, registerPid, UNKNOWN_START_TIME } from '../util/reaper.m
 import { asText, stderrTail } from '../util/diagnostic-tail.mjs';
 import { redact, writeSafe } from '../util/redact.mjs';
 import { currentRunRoot, pidsDir, runRoot, tmpBase, untrustedReason } from '../util/tmp.mjs';
+import { assertBlockId, mainRootOf } from '../worker/ticket.mjs';
 
 export const ROLES = Object.freeze(['coder', 'reviewer', 'judge', 's2', 'author', 'facts', 'delegate']);
 export const LEVELS = Object.freeze(['L0', 'L1', 'L2', 'L3']);
@@ -538,6 +541,8 @@ export async function spawnSession(opts, deps = {}) {
   if (!LEVELS.includes(level)) throw new SessionError('usage', `level must be one of ${LEVELS.join(', ')}`);
   if (!ROLES.includes(role)) throw new SessionError('usage', `role must be one of ${ROLES.join(', ')}`);
   if (typeof promptPath !== 'string' || !path.isAbsolute(promptPath)) throw new SessionError('usage', 'promptPath must be an absolute path');
+  /** @type {string | null} */
+  let coderPrompt = null;
   const stderr = deps.stderr ?? process.stderr;
   const runRootDir = opts.runRoot ?? currentRunRoot();
   if (role === 'facts' && opts.cwd !== undefined) assertFactsCwd(opts.cwd, runRootDir);
@@ -570,6 +575,9 @@ export async function spawnSession(opts, deps = {}) {
       // in the `finally` below on every other exit path (a throw, a background start)
       const releaseReservation = gate.release;
       try {
+        // Budget refusals take precedence over task loading, including legacy runs without
+        // this block. A failed context load must still release the accepted reservation.
+        if (role === 'coder' && opts.block && coderPrompt === null) coderPrompt = await coderPromptFor(opts);
         const outcome = await runAttempt(step, i + 1 === steps.length, releaseReservation);
         if (outcome.result) return outcome.result;
         waitMs = outcome.waitMs;
@@ -602,7 +610,7 @@ export async function spawnSession(opts, deps = {}) {
     mkdirSync(sessionDir, { recursive: true, mode: 0o700 });
     let keep = false;
     try {
-      const built = buildStep(opts, step, sessionDir, openBook);
+      const built = buildStep(opts, step, sessionDir, openBook, coderPrompt);
       const cli = built.cli;
       built.argv[0] = deps.bins?.[cli] ?? built.argv[0];
       if (role === 'coder') {
@@ -659,6 +667,42 @@ export async function spawnSession(opts, deps = {}) {
   }
 }
 
+/**
+ * Add the recorded task and completion contract without overwriting the caller's brief.
+ * @param {SessionOpts} opts @returns {Promise<string>}
+ */
+async function coderPromptFor(opts) {
+  let blockId;
+  let original;
+  try {
+    blockId = assertBlockId(opts.block);
+    original = readFileSync(opts.promptPath, 'utf8');
+  } catch (err) {
+    throw new SessionError('usage', err instanceof Error ? err.message : 'the coder brief cannot be read');
+  }
+  let task = [];
+  if (opts.run) {
+    let record;
+    try {
+      record = await readRun(opts.run);
+    } catch (err) {
+      if (!(err instanceof StateError && err.code === 'no-run')) throw err;
+    }
+    if (record) {
+      const block = record.blocks?.[blockId];
+      if (!block) throw new SessionError('usage', `run ${opts.run} has no block ${blockId}`);
+      try {
+        const repoRoot = await mainRootOf(record.workspace);
+        task = blockTaskLines({ brief: readBlockBrief(repoRoot, block), acceptance: block.acceptance }, original);
+      } catch (err) {
+        if (err instanceof ContextError) throw new SessionError('usage', err.message);
+        throw err;
+      }
+    }
+  }
+  return `${original.trimEnd()}\n\n${task.length ? `${task.join('\n')}\n\n` : ''}Report the changed files and pass/fail counts. Print TESTS <command> exit=<n> on its own line before the sentinel. On success, print this exact sentinel as your last line:\n===BLOCK ${blockId} COMPLETE===\n`;
+}
+
 /**
  * B33: a session row's dollars from its tokens and the static price table — `{usd, cost_source:
  * 'estimated'}`, or `{usd: null, usd_unknown: true}` when the provider/level has no price.
@@ -812,8 +856,9 @@ async function checkGate(opts, deps, writeRow, stderr, budget, estimate) {
  * @param {{provider: string, model: string, effort?: string, flagFallback?: {provider: string, model: string}}} step
  * @param {string} sessionDir
  * @param {boolean} openBook - B32: `review.allow_open_book_codex`, read once by `spawnSession`.
+ * @param {string | null} [coderPrompt]
  */
-function buildStep(opts, step, sessionDir, openBook) {
+function buildStep(opts, step, sessionDir, openBook, coderPrompt = null) {
   const closedBook = opts.role !== 'coder';
   // B9b.1: the facts delegate may run in the caller's read-only project snapshot; nobody else may
   const snapshot = opts.role === 'facts' && opts.cwd !== undefined ? realpathSync(path.resolve(opts.cwd)) : null; // validated by assertFactsCwd
@@ -823,11 +868,17 @@ function buildStep(opts, step, sessionDir, openBook) {
   if (cli === undefined) throw new SessionError('usage', `provider "${step.provider}" has no CLI mapping`);
   /** @type {Record<string, any>} */
   const params = { provider: step.provider, role: opts.role, model: step.model, promptPath: opts.promptPath, cwd };
+  if (coderPrompt !== null) {
+    params.promptPath = path.join(sessionDir, 'coder-brief.md');
+    writeFileSync(params.promptPath, coderPrompt, { mode: 0o600 });
+  }
   if (step.effort) params.effort = step.effort;
   if (step.flagFallback) params.fallback = [step.flagFallback];
   if (cli === 'claude' && opts.maxBudgetUsd !== undefined) params.maxBudgetUsd = opts.maxBudgetUsd;
   if (closedBook && opts.systemPromptText !== undefined && cli !== 'codex') params.systemPromptText = opts.systemPromptText;
   if (cli === 'codex') params.outPath = path.join(sessionDir, 'out.json');
+  // The session owns this home: a named run must not use the spawning process's lazy root.
+  if (cli === 'codex' && !closedBook) params.runRoot = opts.runRoot ?? currentRunRoot();
   // B32 opt-in: only a no-tools role needs it; coder and facts build exactly as without it
   if (cli === 'codex' && openBook && isNoToolRole(opts.role)) params.allowOpenBook = true;
   // B93: the Codex coder's sandbox profile; no `coder.sandbox` key builds exactly today's argv
@@ -903,7 +954,7 @@ async function runForeground(built, opts, deps) {
     });
   } finally {
     // B4.1: the Codex coder's per-session CODEX_HOME (rules + auth copy) dies with the session.
-    if (built.env?.CODEX_HOME) removeCodexHome(built.env.CODEX_HOME);
+    if (built.env?.CODEX_HOME) removeCodexHome(built.env.CODEX_HOME, opts.runRoot);
   }
   const duration_ms = Date.now() - started;
   /** @type {string | null} */

package/src/state/block.mjs

@@ -24,9 +24,10 @@ import { isAncestorArgv, revParseArgv } from '../util/git.mjs';
 import { StateError } from './paths.mjs';
 import { assertOwned, blocksOverlap, isExactEntry, ownsFile, scopeGate } from './registry.mjs';
 import { checkWorkerPin, readRun, saveRun, withRunLock, writeSigned } from './run.mjs';
-import { canonicalJSON, verifyRow, loadKey } from './signer.mjs';
+import { canonicalJSON, verifyRow, loadKey, signRow } from './signer.mjs';
+import { readAllRows } from '../ledger/write.mjs';
 import * as reviewQueue from '../worker/queue.mjs';
-import { repoRootOf } from '../worker/ticket.mjs';
+import { assertInsideRoot, contentHash, repoRootOf } from '../worker/ticket.mjs';
 
 /** @typedef {import('./run.mjs').WriteRow} WriteRow */
 
@@ -292,6 +293,16 @@ function activeBlocks(record) {
   return Object.fromEntries(Object.entries(record.blocks).filter(([, b]) => b.status === 'open'));
 }
 
+/** Earlier claims are authoritative only when their run, block and MAC match.
+ * @param {Record<string, any>} record @param {string} id @returns {Promise<string[]>}
+ */
+async function signedClaims(record, id) {
+  const key = await loadKey(record.run_id);
+  const rows = await readAllRows(record.project);
+  return [...new Set(rows.filter((row) => row.event === 'block.claim' && row.run === record.run_id && row.block === id && verifyRow(row, key).ok)
+    .map((row) => assertOwned([row.path])[0]))];
+}
+
 /**
  * B58: with `review.external.required` set in the run's snapshot, the project's `.code-forge.yml`
  * is the owner's switch past the local per-file review, so no block may own it. These are the
@@ -362,6 +373,11 @@ function refuseConfigOwner(owned, kinds, guarded) {
  * B60: `tests` (`block open --tests <paths…>`, the same path rules as owned entries, else
  * `bad-tests`) is recorded as the entry's `test_files` and on the dispatch row; a gate argv item
  * `{test_files}` expands to them (`gates/expand.mjs`). Left out, neither carries the key.
+ * B148: `after` lists dependencies in this run. Under the same run lock, every dependency must
+ * be closed (`after-not-done`); self-dependency is `bad-after`. Unique ids are recorded on the
+ * entry and dispatch only when supplied, and a later attempt checks only its own supplied list.
+ * B153: `after_outcome` carries the specialist step ids and outcome byte hashes accepted by
+ * the CLI against the run's project root; it is recorded on the entry and dispatch when supplied.
  * B62a: `worktree` (given by `block open` under `proof.isolation: worktree`, `proof/worktree.mjs`;
  * this module never imports it) plans the block's own worktree, or the reuse of the one an earlier
  * entry of the same id recorded (`previous`); its `make()` makes or reuses it. Both are called
@@ -376,11 +392,12 @@ function refuseConfigOwner(owned, kinds, guarded) {
  * @param {{
  *   runId: string, id: string, level: string, owned: string[], acceptance: unknown,
  *   attempt?: number, base?: string, lines?: number, brief?: {path: string, content: Buffer | string},
- *   kind?: string, cfg?: Record<string, any>, writeRow: WriteRow, now?: Date, tests?: string[],
+ *   kind?: string, cfg?: Record<string, any>, writeRow: WriteRow, now?: Date, tests?: string[], after?: string[],
+ *   after_outcome?: {step: string, sha256: string}[],
  *   decision?: {question: 'lane', answer: string, source: 'rules', facts: Record<string, unknown>}, decisionId?: string,
- *   worktree?: (ctx: {baseSha: string, previous: TreeRecord | null}) => Promise<{path: string, make: () => Promise<OpenTree>}>,
+ *   worktree?: (ctx: {baseSha: string, baseExplicit: boolean, previous: TreeRecord | null}) => Promise<{path: string, make: () => Promise<OpenTree>}>,
  * }} opts
- * @returns {Promise<{block: Record<string, any>, pointer: string | null, worktreeReused: boolean}>} `worktreeReused`:
+ * @returns {Promise<{block: Record<string, any>, pointer: string | null, worktreeReused: boolean, keptClaims: number}>} `worktreeReused`:
  *   the block took an earlier attempt's worktree as it was.
  */
 export async function openBlock(opts) {
@@ -391,11 +408,12 @@ export async function openBlock(opts) {
   if (lines !== null && !(Number.isInteger(lines) && lines > 0)) throw new StateError('bad-lines', 'lines forecast must be a positive integer');
   if (opts.kind !== undefined && opts.kind !== 'light' && !BLOCK_KINDS.includes(opts.kind)) throw new StateError('bad-kind', `kind must be one of ${[...BLOCK_KINDS, 'light'].join(', ')}`);
   if (opts.decision && opts.decision.answer !== level) throw new StateError('bad-decision', `the decision answer ${opts.decision.answer} is not the requested level ${level}`);
-  const owned = assertOwned(opts.owned);
+  const declaredOwned = assertOwned(opts.owned);
   const acceptance = assertAcceptance(opts.acceptance);
   const humanChecks = acceptance.filter((c) => c.kind === 'human_check').map((c) => c.clause);
   const tests = opts.tests === undefined ? null : [...assertOwned(opts.tests, { label: 'test files', code: 'bad-tests' })];
-  const kind = opts.kind === 'light' ? 'light' : blockKind({ owned, declared: opts.kind });
+  const after = opts.after === undefined ? null : [...new Set(opts.after)];
+  const kind = opts.kind === 'light' ? 'light' : blockKind({ owned: declaredOwned, declared: opts.kind });
   const dispatched = dispatchLevel({ lane: level, kind, cfg: opts.cfg });
   const pointer = opts.brief ? briefPointer(opts.brief.path, opts.brief.content) : null;
 
@@ -420,11 +438,21 @@ export async function openBlock(opts) {
   /** @type {OpenTree | null} */
   let made = null;
   try {
-    const { block, reused } = await mutateRun(runId, null, writeRow, async (record) => {
+    const { block, reused, keptClaims } = await mutateRun(runId, null, writeRow, async (record) => {
       if (record.blocks[id]?.status === 'open') throw new StateError('already-open', `block ${id} is already open`);
       if (record.blocks[id]?.status === 'awaiting_human_check') throw new StateError('already-open', `block ${id} is awaiting a human check`);
+      if (after !== null) {
+        if (after.includes(id)) throw new StateError('bad-after', `block ${id} cannot name itself in --after`);
+        const blocking = after.filter((dependency) => record.blocks[dependency]?.status !== 'closed');
+        if (blocking.length > 0) {
+          const statuses = blocking.map((dependency) => `${dependency} (${record.blocks[dependency]?.status ?? 'not in run'})`);
+          throw new StateError('after-not-done', `block ${id}: --after dependencies not closed: ${statuses.join(', ')}`);
+        }
+      }
       // B57: what each exact owned entry is on disk, under the lock (as `block claim`) — a regular
       // file owns only itself, here and in every later check
+      const claims = attempt > 1 ? await signedClaims(record, id) : [];
+      const owned = [...new Set([...declaredOwned, ...claims])];
       const kinds = ownedKinds(record.workspace, owned);
       refuseConfigOwner(owned, kinds, guarded);
       const prior = previousTree(record);
@@ -433,7 +461,7 @@ export async function openBlock(opts) {
       const branch = await git(['git', 'symbolic-ref', '--quiet', '--short', 'HEAD'], record.workspace, [0, 1]);
       const baseBranch = branch.code === 0 ? branch.stdout.trim() : null;
       // B62a: the tree is planned (read-only checks) before the overlap check, which needs its path
-      const planned = opts.worktree ? await opts.worktree({ baseSha, previous: prior }) : null;
+      const planned = opts.worktree ? await opts.worktree({ baseSha, baseExplicit: opts.base !== undefined, previous: prior }) : null;
       const self = { owned_files: owned, owned_kinds: kinds, worktree: planned ? { path: planned.path } : null };
       for (const [otherId, other] of Object.entries(activeBlocks(record))) {
         const pair = blocksOverlap(self, other);
@@ -443,21 +471,23 @@ export async function openBlock(opts) {
       // passed; a tree made here is rolled back below if the rows or the save then fail
       made = planned ? await planned.make() : null;
       const tree = made;
-      const entry = { block: id, base_sha: baseSha, base_branch: baseBranch, owned_files: [...owned], owned_kinds: { ...kinds }, level: dispatched.level, kind, attempt, opened_at: now.toISOString(), acceptance, lines_forecast: lines, status: 'open', tree_at_open: treeOpen, ...(tests ? { test_files: tests } : {}), ...(tree ? { worktree: tree.worktree } : {}) };
+      const outcomeDependencies = opts.after_outcome === undefined ? {} : { after_outcome: opts.after_outcome };
+      const entry = { block: id, base_sha: baseSha, base_branch: baseBranch, owned_files: [...owned], owned_kinds: { ...kinds }, level: dispatched.level, kind, attempt, opened_at: now.toISOString(), acceptance, lines_forecast: lines, status: 'open', tree_at_open: treeOpen, ...(tests ? { test_files: tests } : {}), ...(after !== null ? { after } : {}), ...outcomeDependencies, ...(tree ? { worktree: tree.worktree } : {}) };
       if (humanChecks.length > 0) Object.assign(entry, { human_checks: humanChecks });
+      if (opts.brief) Object.assign(entry, { brief: { path: opts.brief.path } });
       record.blocks[id] = entry;
       const floor = dispatched.trigger === 'docs_floor' ? { requested_level: level, trigger: 'docs_floor' } : {};
       const created = tree?.created ? [{ event: 'worktree.created', block: id, path: tree.worktree.path, branch: tree.worktree.branch, base: tree.worktree.base_sha }] : [];
       return {
-        result: { block: entry, reused: tree !== null && !tree.created },
+        result: { block: entry, reused: tree !== null && !tree.created, keptClaims: claims.length },
         rows: [
           ...(opts.decision ? [{ ...opts.decision, event: 'decision', decision_id: opts.decisionId ?? randomUUID(), block: id }] : []),
           ...created,
-          { event: 'dispatch', block: id, level: dispatched.level, kind, ...floor, attempt, base_sha: baseSha, base_branch: baseBranch, owned_files: entry.owned_files, lines_forecast: lines, ...(tests ? { test_files: tests } : {}) },
+          { event: 'dispatch', block: id, level: dispatched.level, kind, ...floor, attempt, base_sha: baseSha, base_branch: baseBranch, owned_files: entry.owned_files, lines_forecast: lines, ...(tests ? { test_files: tests } : {}), ...(after !== null ? { after } : {}), ...outcomeDependencies },
         ],
       };
     });
-    return { block, pointer, worktreeReused: reused };
+    return { block, pointer, worktreeReused: reused, keptClaims };
   } catch (err) {
     // B62a: nothing was recorded, so a tree this open made must not outlive it
     if (made?.created && made.rollback) {
@@ -475,9 +505,12 @@ export async function openBlock(opts) {
 
 /** @param {{runId: string, id: string, writeRow: WriteRow}} opts */
 export async function attemptBlock({ runId, id, writeRow }) {
-  return mutateRun(runId, id, writeRow, (_record, block) => {
+  return mutateRun(runId, id, writeRow, async (record, block) => {
+    const claims = await signedClaims(record, id);
+    block.owned_files = [...new Set([...block.owned_files, ...claims])];
+    block.owned_kinds = { ...ownedKinds(record.workspace, claims), ...block.owned_kinds };
     block.attempt += 1;
-    return { result: block.attempt, rows: [{ event: 'block.attempt', block: id, attempt: block.attempt }] };
+    return { result: { attempt: block.attempt, keptClaims: claims.length }, rows: [{ event: 'block.attempt', block: id, attempt: block.attempt }] };
   });
 }
 
@@ -486,18 +519,19 @@ export async function attemptBlock({ runId, id, writeRow }) {
  * in between touched a file this block owns (that is a conflict ⇒ stop). Rename detection is OFF
  * (`--no-renames`): a rename lists both its old and its new path, so moving an owned file away
  * is a conflict too. Never silent. Owned means `ownsFile` (B57: a directory entry owns the files
- * below it). B62a: refused for an open block with its own worktree (`worktree-rebase`).
- * B134: a closed worktree block instead rebases its branch onto its recorded base branch,
- * retaining every changed owned file's blob; a conflict or changed blob restores the old head.
- * @param {{runId: string, id: string, head?: string, writeRow: WriteRow}} opts
- * @returns {Promise<{old_base: string, new_base: string}>}
+ * below it). Worktree blocks rebase their branch onto the recorded base branch. Open blocks
+ * refuse upstream commits touching owned files; closed blocks retain every changed owned blob.
+ * A refusal restores the head at entry. A rebase check keeps the candidate content available
+ * to the worker, with a signed checkpoint; the recorded base moves only after clearance.
+ * @param {{runId: string, id: string, head?: string, writeRow: WriteRow, acceptChanged?: string[], reason?: string, rebaseCheck?: boolean}} opts
+ * @returns {Promise<{old_base: string, new_base: string, files?: ReturnType<typeof reviewQueue.enqueue>[], pending?: boolean}>}
  */
-export async function rebaseBlock({ runId, id, head = 'HEAD', writeRow }) {
-  if (['closed', 'awaiting_human_check'].includes((await readRun(runId)).blocks[id]?.status)) return rebaseClosedBlock({ runId, id, writeRow });
+export async function rebaseBlock({ runId, id, head = 'HEAD', writeRow, acceptChanged = [], reason, rebaseCheck = false }) {
+  if (acceptChanged.length && (typeof reason !== 'string' || !reason.trim())) throw new StateError('usage', '--accept-changed needs a nonblank --reason');
+  const block = (await readRun(runId)).blocks[id];
+  if (block?.worktree || ['closed', 'awaiting_human_check'].includes(block?.status)) return rebaseWorktreeBlock({ runId, id, writeRow, acceptChanged, reason, rebaseCheck });
+  if (rebaseCheck || acceptChanged.length) throw new StateError('usage', 'rebase clearance requires a worktree block');
   return mutateRun(runId, id, writeRow, async (record, block) => {
-    // B62a: a worktree block's base is the commit its tree started from; moving it would leave the
-    // tree on its old base, so the rebase is refused
-    if (block.worktree) throw new StateError('worktree-rebase', `block ${id} has its own worktree ${block.worktree.path} on branch ${block.worktree.branch}; its base is the base of that tree, so block rebase does not apply — work on the branch in the tree instead`);
     const cwd = record.workspace;
     const newBase = await resolveCommit(head, cwd);
     const ancestor = await git(isAncestorArgv(block.base_sha, newBase), cwd, [0, 1]);
@@ -507,7 +541,7 @@ export async function rebaseBlock({ runId, id, head = 'HEAD', writeRow }) {
     if (conflicts.length > 0) throw new StateError('owned-conflict', `block ${id}: commits since its base changed owned files: ${conflicts.join(', ')}`);
     const moved = { old_base: block.base_sha, new_base: newBase };
     block.base_sha = newBase;
-    return { result: moved, rows: [{ event: 'block.rebase', block: id, ...moved }] };
+    return { result: moved, rows: [{ event: 'block.rebase', block: id, ...moved, changed_reviewed: [], cleared: [] }] };
   });
 }
 
@@ -530,44 +564,91 @@ async function committedBlobs(cwd, ref, files) {
 }
 
 /**
- * Closed blocks have a separate mutation path: check their status again under the lock,
- * restore the branch on failure (including a failed signed write), and retain closed/awaiting status.
- * @param {{runId: string, id: string, writeRow: WriteRow}} opts
- * @returns {Promise<{old_base: string, new_base: string}>}
+ * Recheck worktree block status under the lock, restore the branch on failure (including a
+ * failed signed write), and retain its open/closed/awaiting status.
+ * @param {{runId: string, id: string, writeRow: WriteRow, acceptChanged: string[], reason?: string, rebaseCheck: boolean}} opts
+ * @returns {Promise<{old_base: string, new_base: string, files?: ReturnType<typeof reviewQueue.enqueue>[], pending?: boolean}>}
  */
-async function rebaseClosedBlock({ runId, id, writeRow }) {
+async function rebaseWorktreeBlock({ runId, id, writeRow, acceptChanged, reason, rebaseCheck }) {
   return withRunLock(runId, async () => {
     const record = await readRun(runId);
     if (record.status !== 'active') throw new StateError('run-ended', `run ${runId} has ended`);
     const block = record.blocks[id];
-    if (!['closed', 'awaiting_human_check'].includes(block?.status) || !block.worktree) throw new StateError('no-block', `block ${id} is not open in run ${runId}`);
+    if (!['open', 'closed', 'awaiting_human_check'].includes(block?.status) || !block.worktree) throw new StateError('no-block', `block ${id} is not open in run ${runId}`);
+    const closed = block.status !== 'open';
     if (!block.base_branch) throw new StateError('rebase-no-base', `block ${id} has no recorded base branch`);
     const tree = block.worktree.path;
     const branch = await git(['git', 'symbolic-ref', '--quiet', 'HEAD'], tree, [0, 1]);
     if (branch.stdout.trim() !== `refs/heads/${block.worktree.branch}`) throw new StateError('worktree-rebase', `block ${id}: its worktree is not on branch ${block.worktree.branch}`);
     // A reset must never discard edits made after close, or abort an earlier rebase.
     const status = await git(['git', 'status', '--porcelain'], tree);
-    if (status.stdout.length > 0) throw new StateError('rebase-conflict', 'rebase-conflict');
+    if (status.stdout.length > 0) throw new StateError(closed ? 'rebase-conflict' : 'rebase-dirty', closed ? 'rebase-conflict' : `rebase-dirty: block ${id}: commit or clean first`);
     const oldHead = await resolveCommit('HEAD', tree);
+    const key = await loadKey(runId);
+    const pending = block.rebase_check;
+    if (pending && (!verifyRow(pending, key).ok || pending.run !== runId || pending.block !== id || pending.old_base !== block.base_sha)) {
+      throw new StateError('rebase-check-invalid', 'the pending rebase checkpoint is invalid');
+    }
+    if (pending && (await git(isAncestorArgv(pending.head, oldHead), tree, [0, 1])).code !== 0) {
+      throw new StateError('rebase-check-invalid', 'the worktree no longer contains the pending rebase');
+    }
+    const reviewedHead = pending?.old_head ?? oldHead;
     const newBase = await resolveCommit(`refs/heads/${block.base_branch}`, record.workspace);
     const top = await repoTop(record.workspace);
     const prefix = path.relative(top, realpathSync(record.workspace)).split(path.sep).join('/');
-    const diff = await git(['git', 'diff', '--no-renames', '--name-only', '-z', block.base_sha, oldHead, '--'], tree);
-    const files = diff.stdout.split('\0').filter((file) => file.length > 0 && (
+    const owns = (/** @type {string} */ file) => (
       ownsFile(block.owned_files, file, block.owned_kinds) ||
       (prefix !== '' && file.startsWith(`${prefix}/`) && ownsFile(block.owned_files, file.slice(prefix.length + 1), block.owned_kinds))
-    )).sort();
-    const before = await committedBlobs(tree, oldHead, files);
+    );
+    let files = [];
+    if (closed) {
+      const diff = await git(['git', 'diff', '--no-renames', '--name-only', '-z', block.base_sha, reviewedHead, '--'], tree);
+      files = diff.stdout.split('\0').filter((file) => file.length > 0 && owns(file)).sort();
+    } else {
+      // Inspect every upstream commit, including changes later reverted and both rename paths.
+      const upstream = await git(['git', 'log', '--format=', '--no-renames', '--name-only', '-z', '-m', `${block.base_sha}..${newBase}`, '--'], tree);
+      const conflicts = [...new Set(upstream.stdout.split('\0').filter((file) => file.length > 0 && owns(file)))].sort();
+      if (conflicts.length > 0) throw new StateError('owned-conflict', `block ${id}: commits since its base changed owned files: ${conflicts.join(', ')}`);
+    }
+    const before = closed ? await committedBlobs(tree, reviewedHead, files) : null;
     const moved = { old_base: block.base_sha, new_base: newBase };
     try {
       const rebased = await exec(['git', '-C', tree, 'rebase', newBase], { cwd: record.workspace, env: gitEnv(), timeoutMs: 30000 });
       if (rebased.result !== 'ok') throw new StateError('rebase-conflict', 'rebase-conflict');
-      const after = await committedBlobs(tree, 'HEAD', files);
-      const changed = files.filter((file) => before.get(file) !== after.get(file));
-      if (changed.length > 0) throw new StateError('rebase-changed-reviewed', `rebase-changed-reviewed ${changed.join(', ')}`);
+      const after = before === null ? null : await committedBlobs(tree, 'HEAD', files);
+      const changed = after === null ? [] : files.filter((file) => before.get(file) !== after.get(file));
+      const repoRoot = await repoRootOf(record.workspace);
+      if (rebaseCheck) {
+        // The worker reviews the authoritative worktree, so retain this candidate while leaving
+        // both bases untouched. Sign the original head so a later retry cannot forget changes.
+        block.rebase_check = signRow({ event: 'block.rebase_check', run: runId, block: id, ...moved, old_head: reviewedHead, head: await resolveCommit('HEAD', tree), started_at: pending?.started_at ?? new Date().toISOString() }, key);
+        const queued = changed.map((file) => reviewQueue.enqueue({ repoRoot, run: runId, block: id, file, tree, after: block.rebase_check.started_at }));
+        await saveRun(record);
+        return { ...moved, files: queued, pending: true };
+      }
+      const invalidAccepted = acceptChanged.filter((file) => !changed.includes(file));
+      if (invalidAccepted.length) throw new StateError('usage', `--accept-changed names files not changed by this rebase: ${invalidAccepted.join(', ')}`);
+      const rows = pending ? (await readAllRows(record.project)).filter((row) => row.run === runId && row.block === id && verifyRow(row, key).ok && Date.parse(row.ts) >= Date.parse(pending.started_at)) : [];
+      /** @type {Array<{file: string, via: string, ticket?: string, reason?: string}>} */
+      const cleared = [];
+      for (const file of changed) {
+        if (acceptChanged.includes(file)) {
+          cleared.push({ file, via: 'human', reason });
+          continue;
+        }
+        const hash = contentHash(tree, file);
+        const ticket = reviewQueue.resolveTicket({ repoRoot, run: runId, block: id, file, tree, after: pending?.started_at }).ticket;
+        const relevant = rows.filter((row) => row.file === file && row.content_hash === hash);
+        const approval = relevant.reduce((last, row, index) => row.event === 'review.approved' && (row.ticket === undefined || row.ticket === ticket) ? index : last, -1);
+        const denied = relevant.slice(approval + 1).some((row) => row.event === 'review.cap' || (row.event === 'review.result' && row.approved === false) || (row.event === 'review.round' && row.open_after > 0));
+        if (approval >= 0 && !denied) cleared.push({ file, via: 'review', ticket });
+      }
+      const uncleared = changed.filter((file) => !cleared.some((entry) => entry.file === file));
+      if (uncleared.length) throw new StateError('rebase-changed-reviewed', `rebase-changed-reviewed ${uncleared.join(', ')}\nRe-review: code-forge review-file --rebase-check --block ${id} --run ${runId}\nHuman accept (repeat --accept-changed for each file): code-forge block rebase ${id} --run ${runId} --accept-changed <file> --reason <text>`);
       block.base_sha = newBase;
       block.worktree.base_sha = newBase;
-      await writeSigned(runId, writeRow, { event: 'block.rebase', block: id, ...moved, closed: true });
+      delete block.rebase_check;
+      await writeSigned(runId, writeRow, { event: 'block.rebase', block: id, ...moved, changed_reviewed: changed, cleared, ...(closed ? { closed: true } : { worktree: true }) });
       await saveRun(record);
       return moved;
     } catch (err) {
@@ -588,25 +669,33 @@ async function rebaseClosedBlock({ runId, id, writeRow }) {
  * B58: with `review.external.required` set, a path that owns the project's config is refused
  * (`config-owned`), as at `block open`. B62a: two blocks that each have their own worktree may
  * own the same path (`blocksOverlap`).
- * @param {{runId: string, id: string, file: string, writeRow: WriteRow}} opts
+ * @param {{runId: string, id: string, file: string, writeRow: WriteRow, auto?: boolean}} opts
  */
-export async function claimPath({ runId, id, file, writeRow }) {
+export async function claimPath({ runId, id, file, writeRow, auto = false }) {
   assertOwned([file]);
   if (!isExactEntry(file)) throw new StateError('bad-owned', `block claim takes one exact path, not a glob (${JSON.stringify(file)})`);
   const guarded = await guardedConfigPaths(await readRun(runId));
-  await mutateRun(runId, id, writeRow, (record, block) => {
-    const kinds = { [file]: pathKind(record.workspace, file) };
+  await mutateRun(runId, id, writeRow, async (record, block) => {
+    const root = auto ? await repoTop(block.worktree?.path ?? record.workspace) : record.workspace;
+    if (auto) {
+      if (file.split('/').some((part) => ['.git', '.code-forge'].includes(part.toLowerCase()))) throw new StateError('unowned_change', `unowned_change ${file}: cannot auto-claim repository state`);
+      try { assertInsideRoot(root, file); }
+      catch { throw new StateError('unowned_change', `unowned_change ${file}: cannot auto-claim a path outside the repository or a symlink`); }
+    }
+    const kinds = { [file]: pathKind(root, file) };
     refuseConfigOwner([file], kinds, guarded);
+    const prefix = auto ? path.relative(await repoTop(record.workspace), realpathSync(record.workspace)).split(path.sep).join('/') : '';
     for (const [otherId, other] of Object.entries(activeBlocks(record))) {
-      const pair = otherId === id ? null : blocksOverlap({ owned_files: [file], owned_kinds: kinds, worktree: block.worktree ?? null }, other);
-      if (pair) throw new StateError('overlap', `${file} overlaps ${pair[1]} owned by open block ${otherId}`);
+      const pair = otherId === id ? null : blocksOverlap({ owned_files: [file], owned_kinds: kinds, worktree: auto ? null : block.worktree ?? null }, other);
+      const relativeOwner = auto && otherId !== id && prefix !== '' && file.startsWith(`${prefix}/`) && ownsFile(other.owned_files, file.slice(prefix.length + 1), other.owned_kinds);
+      if (pair || relativeOwner) throw new StateError(auto ? 'unowned_change' : 'overlap', `${auto ? 'unowned_change ' : ''}${file} overlaps ${pair?.[1] ?? file} owned by open block ${otherId}`);
     }
     if (!block.owned_files.includes(file)) {
       block.owned_files.push(file);
       block.owned_kinds = { ...block.owned_kinds, ...kinds };
     }
     record.orphans = record.orphans.filter((/** @type {string} */ o) => !ownsFile([file], o, kinds));
-    return { result: undefined, rows: [{ event: 'block.claim', block: id, path: file }] };
+    return { result: undefined, rows: [{ event: 'block.claim', block: id, path: file, ...(auto ? { auto: true, reason: 'auto-claim: changed outside owned files' } : {}) }] };
   });
 }
 
@@ -679,9 +768,10 @@ export async function closeBlock({ runId, id, rows, writeRow, livePid, probe, ex
 
   let pin = await checkWorkerPin(record, { livePid, probe });
   const pins = record.workers ?? (record.worker ? [record.worker] : []);
+  const reviewPins = [...pins, ...(record.worker_history ?? [])];
   const counted = rows.filter((row) => row.block === id && (row.run === undefined || row.run === runId) && row.event === 'review.result' && !['stale', 'unavailable', 'answers'].includes(row.status) && !(row.status === 'refused' && row.reason === 'other-run'));
   // Ledgers written before B107 omit worker identity and use the run's pin check above.
-  if (counted.some((row) => row.worker !== undefined && !pins.some((p) => p.pid === row.worker?.pid && p.started_at === row.worker?.started_at))) {
+  if (counted.some((row) => row.worker !== undefined && !reviewPins.some((p) => p.pid === row.worker?.pid && p.started_at === row.worker?.started_at))) {
     pin = { ok: false, event: 'worker.replaced', reason: 'a counted review result does not name a pinned worker' };
   }
   if (pin.ok) {

package/src/state/config-snapshot.mjs

@@ -45,7 +45,7 @@ export const IMMUTABLE_KEYS = Object.freeze({
   // B64b: the block-end hook runs a command on the owner's machine at every block end, so only
   // the owner sets it, before the run starts
   'hooks.on_block_end': 'it runs a command on the owner\'s machine at every block end; fixed by the owner before the run starts',
-  // B87: the runner argv proves the coder's own work, so only the owner sets it, before the run starts
+  // B171: existing runner entries stay fixed; immutableChanges permits append-only additions.
   'proof.runners': 'the commands that prove a block are fixed by the owner before the run starts',
   // B93: the coder sandbox profile widens what the coder may write, so only the owner sets it,
   // before the run starts (a coder can never own `.code-forge.yml`)
@@ -138,7 +138,17 @@ function valueAt(cfg, dotted) {
  * @returns {string[]}
  */
 export function immutableChanges(before, after) {
-  return Object.keys(IMMUTABLE_KEYS).filter((k) => canonicalJSON(valueAt(before, k) ?? null) !== canonicalJSON(valueAt(after, k) ?? null));
+  return Object.keys(IMMUTABLE_KEYS).filter((k) => {
+    const oldValue = valueAt(before, k);
+    const newValue = valueAt(after, k);
+    // Additions go at the end: prepending could replace the first match of an existing runner.
+    if (k === 'proof.runners' && Array.isArray(newValue)) {
+      const oldRunners = oldValue ?? [];
+      if (Array.isArray(oldRunners) && newValue.length >= oldRunners.length
+        && oldRunners.every((entry, i) => canonicalJSON(entry) === canonicalJSON(newValue[i]))) return false;
+    }
+    return canonicalJSON(oldValue ?? null) !== canonicalJSON(newValue ?? null);
+  });
 }
 
 /**
@@ -243,7 +253,7 @@ export function blockEndHook(record) {
 }
 
 /**
- * B87: `proof.runners` of the run-start config snapshot (never the live config), as a deep copy
+ * B87: `proof.runners` of the snapshot in force (never the live config), as a deep copy
  * (entries and argv arrays), or null when the key is absent or the record is from before
  * snapshots. `proof/runners.mjs` checks each entry again before it runs one (fail closed).
  * @param {Record<string, any>} record