@codedology/code-forge 0.15.3 → 0.16.0

package/src/session/spawn.mjs

@@ -45,7 +45,8 @@
 
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import { CODEX_CLOSED_BOOK_REFUSAL, closedBookRefused, isNoToolRole, openBookCodexAllowed } from '../config/closed-book.mjs';
@@ -531,22 +532,17 @@ function assertFactsCwd(cwd, runRootDir) {
   if (workTree !== null) throw refuse(`inside a git work tree (${workTree})`);
 }
 
-/**
- * @param {SessionOpts} opts
- * @param {SessionDeps} [deps]
- * @returns {Promise<SessionResult>}
- */
-export async function spawnSession(opts, deps = {}) {
-  const { cfg, level, role, promptPath } = opts;
+/** @param {SessionOpts} opts */
+function validateSessionOpts(opts) {
+  const { level, role, promptPath } = opts;
   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);
-  const writeRow = deps.writeRow ?? (opts.slug ? (/** @type {Record<string, any>} */ row) => appendRow(row, { slug: /** @type {string} */ (opts.slug) }) : null);
+}
+
+/** @param {SessionOpts} opts @param {{write: (s: string) => unknown}} stderr */
+function sessionSteps(opts, stderr) {
+  const { cfg, level, role } = opts;
   const ladder = ladderFor(resolveLevel(cfg, level), role);
   // B32: Codex has no no-tools mode, so it runs no reviewer/judge/S2/author session unless the
   // config opts in (`review.allow_open_book_codex: true`). Without it, step 0 on openai refuses the
@@ -556,6 +552,53 @@ export async function spawnSession(opts, deps = {}) {
   const steps = ladder.filter((step) => !closedBookRefused(step.provider, role, openBook));
   if (steps.length < ladder.length) writeSafe(stderr, `fallback skipped: ${ladder.length - steps.length} openai step(s) — ${CODEX_CLOSED_BOOK_REFUSAL}\n`);
   if (opts.background) steps.length = 1;
+  return { steps, openBook };
+}
+
+/**
+ * Build the first runnable step without entering the budget gate or provider semaphore.
+ * All session artifacts are temporary; argv paths use the stable <session> placeholder.
+ * @param {SessionOpts} opts @param {SessionDeps} [deps]
+ * @returns {Promise<{argv: string[], cwd: string, provider: string, model: string, effort: string | null, fallback_step: number}>}
+ */
+export async function previewArgv(opts, deps = {}) {
+  validateSessionOpts(opts);
+  if (opts.role === 'facts' && opts.cwd !== undefined) assertFactsCwd(opts.cwd, opts.runRoot ?? currentRunRoot());
+  const { steps, openBook } = sessionSteps(opts, deps.stderr ?? process.stderr);
+  const step = steps[0];
+  const sessionDir = mkdtempSync(path.join(os.tmpdir(), 'code-forge-preview-'));
+  try {
+    const coderPrompt = opts.role === 'coder' && opts.block ? await coderPromptFor(opts) : null;
+    const built = buildStep({ ...opts, runRoot: sessionDir }, step, sessionDir, openBook, coderPrompt);
+    checkBuiltArgv(built, opts, deps);
+    return {
+      argv: built.argv.map((arg) => arg.replaceAll(sessionDir, '<session>')),
+      cwd: built.cwd.replaceAll(sessionDir, '<session>'),
+      provider: step.provider,
+      model: step.model,
+      effort: step.effort ?? null,
+      fallback_step: step.fallback_step,
+    };
+  } finally {
+    rmSync(sessionDir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * @param {SessionOpts} opts
+ * @param {SessionDeps} [deps]
+ * @returns {Promise<SessionResult>}
+ */
+export async function spawnSession(opts, deps = {}) {
+  const { cfg, level, role } = opts;
+  validateSessionOpts(opts);
+  /** @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);
+  const writeRow = deps.writeRow ?? (opts.slug ? (/** @type {Record<string, any>} */ row) => appendRow(row, { slug: /** @type {string} */ (opts.slug) }) : null);
+  const { steps, openBook } = sessionSteps(opts, stderr);
 
   const attempts = [];
   const sleep = deps.sleep ?? realSleep;
@@ -612,11 +655,7 @@ export async function spawnSession(opts, deps = {}) {
     try {
       const built = buildStep(opts, step, sessionDir, openBook, coderPrompt);
       const cli = built.cli;
-      built.argv[0] = deps.bins?.[cli] ?? built.argv[0];
-      if (role === 'coder') {
-        const hit = isForbidden(built.argv, opts.forbidden ?? mergeForbidden());
-        if (hit) throw new SessionError('forbidden', `coder argv refused before spawn: forbidden entry ${hit.id}`);
-      }
+      checkBuiltArgv(built, opts, deps);
       writeSafe(stderr, `level=${level} provider=${step.provider} model=${step.model} effort=${step.effort ?? 'none'} fallback_step=${step.fallback_step}\n`);
       const base = { role, level, provider: step.provider, model: step.model, effort: step.effort ?? null, fallback_step: step.fallback_step, run: opts.run ?? null, block: opts.block ?? null, ...(role === 's2' ? { source: step.fallback_step > 0 ? 's2-fallback' : 's2' } : {}), ...sandboxRowField(opts, cli), ...(opts.rowExtra ?? {}) };
 
@@ -910,6 +949,18 @@ function buildStep(opts, step, sessionDir, openBook, coderPrompt = null) {
   return { ...built, argv: [...built.argv], compiled, strict };
 }
 
+/**
+ * Apply the binary override before the coder's forbidden-argv check, in both launch modes.
+ * @param {{cli: string, argv: string[]}} built @param {SessionOpts} opts @param {SessionDeps} deps
+ */
+function checkBuiltArgv(built, opts, deps) {
+  built.argv[0] = deps.bins?.[built.cli] ?? built.argv[0];
+  if (opts.role === 'coder') {
+    const hit = isForbidden(built.argv, opts.forbidden ?? mergeForbidden());
+    if (hit) throw new SessionError('forbidden', `coder argv refused before spawn: forbidden entry ${hit.id}`);
+  }
+}
+
 /**
  * B93: `{sandbox: <profile>}` for a Codex coder session row when `coder.sandbox` is set; `{}`
  * otherwise, so a row without the key is byte-equal to the row before B93.

package/src/state/block-end.mjs

@@ -25,6 +25,7 @@ import path from 'node:path';
 import { runSpend } from '../ledger/spend.mjs';
 import { readAllRows } from '../ledger/write.mjs';
 import { exec } from '../util/exec.mjs';
+import { daemonRequest } from '../util/native.mjs';
 import { assertRunId, runsDir } from './paths.mjs';
 import { withRunLock, writeSigned } from './run.mjs';
 
@@ -113,7 +114,8 @@ export async function writeDoneFile({ record, id, status, event, reason = null,
     /** @type {Record<string, any>[] | null} */
     let rows = null;
     try {
-      rows = await readAllRows(record.project);
+      const reply = await daemonRequest(runId, { method: 'rows', block: id }, { config: record.config?.snapshots?.[record.config?.hash] });
+      rows = reply?.rows ?? await readAllRows(record.project);
     } catch {
       rows = null;
     }

package/src/state/block.mjs

@@ -27,7 +27,7 @@ import { checkWorkerPin, readRun, saveRun, withRunLock, writeSigned } from './ru
 import { canonicalJSON, verifyRow, loadKey, signRow } from './signer.mjs';
 import { readAllRows } from '../ledger/write.mjs';
 import * as reviewQueue from '../worker/queue.mjs';
-import { contentHash, repoRootOf } from '../worker/ticket.mjs';
+import { assertInsideRoot, contentHash, repoRootOf } from '../worker/ticket.mjs';
 
 /** @typedef {import('./run.mjs').WriteRow} WriteRow */
 
@@ -293,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
@@ -387,7 +397,7 @@ function refuseConfigOwner(owned, kinds, guarded) {
  *   decision?: {question: 'lane', answer: string, source: 'rules', facts: Record<string, unknown>}, decisionId?: string,
  *   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) {
@@ -398,12 +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 after = opts.after === undefined ? null : [...new Set(opts.after)];
-  const kind = opts.kind === 'light' ? 'light' : blockKind({ owned, declared: opts.kind });
+  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;
 
@@ -428,7 +438,7 @@ 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) {
@@ -441,6 +451,8 @@ export async function openBlock(opts) {
       }
       // 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);
@@ -467,7 +479,7 @@ export async function openBlock(opts) {
       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,
@@ -475,7 +487,7 @@ export async function openBlock(opts) {
         ],
       };
     });
-    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) {
@@ -493,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 }] };
   });
 }
 
@@ -598,8 +613,20 @@ async function rebaseWorktreeBlock({ runId, id, writeRow, acceptChanged, reason,
     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');
+      try {
+        // Read every original identity once. Exclude commits already in the new base, including
+        // upstream commits retained by a pending rebase check. Global config and GIT_* stay scrubbed.
+        const commits = await git(['git', 'log', '--format=%H%x00%cn%x00%ce', '--reverse', `${block.base_sha}..${oldHead}`, '--not', newBase], tree);
+        await git(['git', 'reset', '--hard', newBase], tree);
+        for (const commit of commits.stdout.trimEnd().split('\n').filter(Boolean)) {
+          const [sha, committerName, committerEmail] = commit.split('\0');
+          // No -m: cherry-pick refuses merge commits. An original empty commit is still a commit.
+          const replayed = await exec(['git', '-C', tree, 'cherry-pick', '--allow-empty', sha], { cwd: record.workspace, env: { ...gitEnv(), GIT_COMMITTER_NAME: committerName, GIT_COMMITTER_EMAIL: committerEmail }, timeoutMs: 30000 });
+          if (replayed.result !== 'ok') throw new StateError('rebase-conflict', 'rebase-conflict');
+        }
+      } catch {
+        throw new StateError('rebase-conflict', 'rebase-conflict');
+      }
       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);
@@ -637,9 +664,9 @@ async function rebaseWorktreeBlock({ runId, id, writeRow, acceptChanged, reason,
       await saveRun(record);
       return moved;
     } catch (err) {
-      // --abort restores a conflicted rebase; after a completed rebase there is nothing to
-      // abort, and reset restores the old branch head. The tree was clean before either.
-      await exec(['git', '-C', tree, 'rebase', '--abort'], { cwd: record.workspace, env: gitEnv(), timeoutMs: 30000 });
+      // Abort a conflicted replay; after a completed replay there is nothing to abort.
+      // Reset restores the exact old branch head. The tree was clean before either.
+      await exec(['git', '-C', tree, 'cherry-pick', '--abort'], { cwd: record.workspace, env: gitEnv(), timeoutMs: 30000 });
       await git(['git', 'reset', '--hard', oldHead], tree);
       throw err;
     }
@@ -654,25 +681,33 @@ async function rebaseWorktreeBlock({ runId, id, writeRow, acceptChanged, reason,
  * 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' } : {}) }] };
   });
 }
 

package/src/state/run.mjs

@@ -26,6 +26,11 @@ import { generateKey, loadKey, signRow } from './signer.mjs';
 const LOCK_TIMEOUT_MS = 5000;
 const LOCK_POLL_MS = 25;
 
+/** @param {string} text @returns {string | null} */
+export function normalizeStartTime(text) {
+  return text.trim().replace(/\s+/g, ' ') || null;
+}
+
 /**
  * The process start time of `pid` (`ps -o lstart=`), or null when no such process exists.
  * @type {StartTimeProbe}
@@ -37,8 +42,7 @@ export async function processStartTime(pid) {
     okExitCodes: [0, 1],
     timeoutMs: 10000,
   });
-  const text = res.stdout.trim();
-  return res.result === 'ok' && res.code === 0 && text.length > 0 ? text : null;
+  return res.result === 'ok' && res.code === 0 ? normalizeStartTime(res.stdout) : null;
 }
 
 /** @param {unknown} value @returns {string} */
@@ -348,7 +352,10 @@ export async function checkWorkerPin(record, { livePid, probe = processStartTime
       return { ok: false, event: 'worker.replaced', reason: 'the live worker does not match a pinned worker' };
     }
     if (livePid === undefined) {
-      const live = await Promise.all(pins.map(async (p) => (await probe(p.pid)) === p.started_at));
+      const live = await Promise.all(pins.map(async (p) => {
+        const startedAt = await probe(p.pid);
+        return startedAt !== null && startedAt === normalizeStartTime(p.started_at);
+      }));
       return live.some(Boolean) ? { ok: true } : { ok: false, event: 'worker.down', reason: 'no pinned worker is running' };
     }
     pin = pins.find((p) => p.pid === livePid);
@@ -360,7 +367,7 @@ export async function checkWorkerPin(record, { livePid, probe = processStartTime
   }
   const startedAt = await probe(pin.pid);
   if (startedAt === null) return { ok: false, event: 'worker.down', reason: `pinned worker pid ${pin.pid} is not running` };
-  if (startedAt !== pin.started_at) {
+  if (startedAt !== normalizeStartTime(pin.started_at)) {
     return { ok: false, event: 'worker.replaced', reason: `pid ${pin.pid} was restarted (start time differs from the pin)` };
   }
   return { ok: true };
@@ -378,7 +385,7 @@ export async function stopPinnedWorker(pin, { probe = processStartTime, kill = (
   if (!pin || !isSignalablePid(pin.pid)) return { stopped: false, reason: 'invalid pid' };
   const startedAt = await probe(pin.pid);
   if (startedAt === null) return { stopped: false, reason: 'not running' };
-  if (startedAt !== pin.started_at) return { stopped: false, reason: 'pid reused' };
+  if (startedAt !== normalizeStartTime(pin.started_at)) return { stopped: false, reason: 'pid reused' };
   try {
     kill(pin.pid, 'SIGTERM');
   } catch (err) {

package/src/util/native.mjs

@@ -0,0 +1,133 @@
+import { spawn } from 'node:child_process';
+import { accessSync, constants, statSync } from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pkg from '../../package.json' with { type: 'json' };
+import { exec } from './exec.mjs';
+
+/** @returns {string | null} the optional executable shipped for this host. */
+export function nativePath() {
+  if (process.env.CODE_FORGE_NATIVE === '0') return null;
+  const binary = fileURLToPath(new URL(`../../native/bin/${process.platform}-${process.arch}/code-forge-native`, import.meta.url));
+  try {
+    if (!statSync(binary).isFile()) return null;
+    accessSync(binary, constants.X_OK);
+    return binary;
+  } catch { return null; }
+}
+
+/**
+ * @param {string[]} args
+ * @returns {Promise<import('./exec.mjs').ExecResult | null>} null requests the Node fallback.
+ */
+export async function runNative(args) {
+  const binary = nativePath();
+  return binary ? exec([binary, ...args], { timeoutMs: 30_000 }) : null;
+}
+
+/** @param {Record<string, any> | null} [config] @param {NodeJS.ProcessEnv} [env] */
+export function daemonEnabled(config, env = process.env) {
+  return env.CODE_FORGE_NATIVE !== '0' && config?.native?.daemon !== false;
+}
+
+/**
+ * One connection per call. Ping negotiates the package version before sending the method;
+ * no socket is opened when disabled. Protocol and transport failures request Node fallback.
+ * @param {string} run
+ * @param {{method: string, block?: string, max_ms?: number}} request
+ * @param {{config?: Record<string, any> | null, timeoutMs?: number}} [opts]
+ * @returns {Promise<Record<string, any> | null>}
+ */
+export async function daemonRequest(run, request, { config, timeoutMs = request.method === 'wait-block' ? (request.max_ms ?? 0) + 2500 : 6500 } = {}) {
+  if (!daemonEnabled(config) || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(run)) return null;
+  return new Promise((resolve) => {
+    let settled = false;
+    let negotiated = false;
+    let buffer = '';
+    const socket = net.createConnection(path.join(os.homedir(), '.code-forge', 'runs', run, 'native.sock'));
+    socket.setEncoding('utf8');
+    const finish = (/** @type {Record<string, any> | null} */ value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(value);
+    };
+    let timer = setTimeout(() => finish(null), Math.min(2000, timeoutMs));
+    const deadline = (/** @type {number} */ ms) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => finish(null), ms);
+    };
+    socket.on('error', () => finish(null));
+    socket.on('close', () => finish(null));
+    socket.on('connect', () => {
+      deadline(Math.min(2000, timeoutMs));
+      socket.write('{"method":"ping"}\n');
+    });
+    socket.on('data', (chunk) => {
+      buffer += chunk;
+      if (buffer.length > 8 * 1024 * 1024) return finish(null);
+      const end = buffer.indexOf('\n');
+      if (end < 0) return;
+      let answer;
+      try { answer = JSON.parse(buffer.slice(0, end)); } catch { return finish(null); }
+      buffer = buffer.slice(end + 1);
+      if (!answer || typeof answer !== 'object' || Array.isArray(answer) || answer.ok === false) return finish(null);
+      if (!negotiated) {
+        if (answer.ok !== true || answer.version !== pkg.version || answer.run !== run) return finish(null);
+        if (request.method === 'ping') return finish(answer);
+        negotiated = true;
+        deadline(timeoutMs);
+        socket.write(`${JSON.stringify(request)}\n`);
+      } else {
+        const { stats, ...result } = answer;
+        if (request.method === 'rows' && (!Array.isArray(result.rows)
+          || !result.rows.every((row) => row !== null && typeof row === 'object' && !Array.isArray(row)))) return finish(null);
+        if (request.method === 'wait-block' && (result.block !== request.block || !Array.isArray(result.files) || typeof result.done !== 'boolean'
+          || !result.files.every((/** @type {any} */ file) => file && typeof file.file === 'string' && typeof file.status === 'string'))) return finish(null);
+        if (request.method === 'status' && (!Array.isArray(result.runs) || result.runs.length !== 1 || result.runs[0]?.run_id !== run || !Array.isArray(result.runs[0]?.blocks))) return finish(null);
+        finish(result);
+      }
+    });
+  }).catch(() => null);
+}
+
+/**
+ * The daemon serializes startup with its own OS lock. A loser exits harmlessly;
+ * only this child is stopped, never a daemon another worker already owns.
+ * @param {string} run @param {Record<string, any> | null} config
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {Promise<() => Promise<void>>}
+ */
+export async function startNativeDaemon(run, config, env = process.env) {
+  const noop = async () => {};
+  if (!daemonEnabled(config, env)) return noop;
+  const binary = nativePath();
+  if (!binary || await daemonRequest(run, { method: 'ping' }, { config })) return noop;
+  let child;
+  try { child = spawn(binary, ['serve', '--home', os.homedir(), '--run', run], { stdio: 'ignore', env }); }
+  catch { return noop; }
+  let ended = false;
+  const exited = new Promise((resolve) => {
+    child.once('error', () => { ended = true; resolve(undefined); });
+    child.once('exit', () => { ended = true; resolve(undefined); });
+  });
+  for (let i = 0; i < 100 && !ended; i++) {
+    if (await daemonRequest(run, { method: 'ping' }, { config, timeoutMs: 100 })) break;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  /** @type {Promise<void> | undefined} */
+  let stopping;
+  return () => {
+    stopping ??= (async () => {
+      if (ended) return;
+      child.kill('SIGTERM');
+      const timer = setTimeout(() => child.kill('SIGKILL'), 2000);
+      timer.unref();
+      try { await exited; } finally { clearTimeout(timer); }
+    })();
+    return stopping;
+  };
+}

package/src/worker/engine.mjs

@@ -108,7 +108,7 @@ import { ledgerSchemaHistory } from '../review/schema-fallback.mjs';
 import { verifyRow } from '../state/signer.mjs';
 import { redact } from '../util/redact.mjs';
 import { withLock } from '../util/file-locks.mjs';
-import { blockAnchors, blockRungUsed, loadState, RESTORED_EVENT, saveState } from './review-state.mjs';
+import { fileRungUsed, loadState, RESTORED_EVENT, saveState } from './review-state.mjs';
 import { assertAnswers, enqueueHash, isDone, reviewExclusionFor, writeResult } from './queue.mjs';
 import { assertTicketId, contentHash, readRegularFileNoFollow, WorkerError } from './ticket.mjs';
 
@@ -527,7 +527,7 @@ export function blockPeerDiffs(repoRoot, { base, owned, ownedKinds, file }) {
 }
 
 /**
- * The key of a block's lock (B42): the block's budget row and its L3 rung are taken under it.
+ * The key of a block's lock (B42): the budget row and each file's L3 rung are taken under it.
  * It carries the run, so two runs in one process never share a lock.
  * @param {string} runId @param {string} block @returns {string}
  */
@@ -537,33 +537,18 @@ export const blockLockKey = (runId, block) => `block:${runId}\0${block}`;
 export const LOST_MESSAGE = 'the review state file is gone and the ledger cannot rebuild it (its anchor carries no state_body); the file is not reviewed again from round 1 — the owner can run `code-forge block reopen`';
 
 /**
- * Whether the block's one L3 rung is taken: a verified anchor says so (`blockRungUsed`), OR another
- * file of the block has a saved state whose round decided `next: patch` — that round took the rung,
- * but its anchor records `l3_rung_used` only once the patch_check ticket saves. A sibling state that
- * does not load is counted as taken (fail closed; its own ticket refuses it).
+ * Whether this file's L3 rung is taken, derived from its verified anchors (`fileRungUsed`).
+ * A pending `next: patch` on this file is handled by its patch_check ticket; sibling files
+ * have their own rungs.
  * @param {import('./review-state.mjs').Where} where
  * @returns {{status: 'ok' | 'tampered', used: boolean}}
  */
 export function rungTaken(where) {
-  const rung = blockRungUsed(where);
-  if (rung.status === 'tampered' || rung.used) return rung;
-  const anchors = blockAnchors(where) ?? [];
-  const siblings = new Set(anchors.map((a) => a.file).filter((f) => typeof f === 'string' && f !== where.file));
-  for (const file of siblings) {
-    let other;
-    try {
-      other = loadState({ ...where, file, migrate: false }); // B69: a sibling's old file is read, never moved here
-    } catch {
-      return { status: 'ok', used: true };
-    }
-    // a sibling that would be restored (B68) counts by its rebuilt state; lost or tampered fails closed
-    if ((other.status !== 'ok' && other.status !== 'restored') || other.state?.next?.action === 'patch') return { status: 'ok', used: true };
-  }
-  return rung;
+  return fileRungUsed(where);
 }
 
 /**
- * Whether this round could take the block's L3 rung (so it must run under the block lock): never
+ * Whether this round could take the file's L3 rung (so it must run under the block lock): never
  * when the rung is taken or the round is the patch_check (the rung is already this file's); never
  * for a file's first full round while the cap and the per-level ladder are both above 1 (round 1
  * cannot stall, reach the cap or exhaust the ladder); else conservatively yes.
@@ -586,9 +571,9 @@ export function mayTakeRung(state, kind, cfg, rungUsed) {
  * Concurrency (B42): the worker runs several tickets at once but never two for the same
  * (block, file) (its file lock, `loop.mjs`), so this file's state `seq` is read and saved by one
  * ticket at a time. What the files of a BLOCK share is taken under the block lock
- * (`blockLockKey`): the budget row's check-then-write (written once per block) and the L3 rung —
+ * (`blockLockKey`): the budget row's check-then-write (written once per block) and each file's L3 rung —
  * the rung read and, for a round that could take the rung (`mayTakeRung`), the whole round and its
- * state save, so two files of one block never both take it. A round that cannot take the rung (a
+ * state save, so workers cannot take the same file's rung twice. A round that cannot take the rung (a
  * first full round, or any round once the rung is gone) runs outside the block lock, in parallel
  * with the block's other files.
  * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
@@ -636,7 +621,7 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, ownedKinds, block
       if (row.event === 'review.state' && row.file === ticket.file) anchoredAt = i;
     });
     // A changed review input starts a full round, including previously stopped files. Keep
-    // the anchor sequence and the block's spent L3 rung; tampered state still refuses above.
+    // the anchor sequence and the file's spent L3 rung; tampered state still refuses above.
     const reopened = amendedAt > anchoredAt || reopenRowFor(rows, reopenAt) !== null;
     if (loaded.status === 'lost' && !reopened) return { outcome: /** @type {ReviewOutcome} */ ({ status: 'refused', reason: 'review-state-lost', message: LOST_MESSAGE, approved: false, engine: 'adaptive', sessions: [] }) };
     let seq = loaded.seq;
@@ -664,7 +649,7 @@ async function fixLoopRound(ticket, ctx, { base, level, owned, ownedKinds, block
     if (state.next?.action === 'retry') kind = state.pending_kind ?? kind;
     else if (state.next?.action === 'patch') {
       kind = 'patch_check';
-      state.l3_rung_used = true; // the orchestrator ran the block's one L3 patch before this ticket
+      state.l3_rung_used = true; // the orchestrator ran this file's one L3 patch before this ticket
     }
     const fixed = state;
     const round = () => playRound(ticket, ctx, { state: fixed, kind, where, seq, base, blockKindOf, workDir, factsExcerpt, rulesDigest, extraRounds, peerDiffs, fileContext });