@codedology/code-forge 0.15.2 → 0.15.4

package/src/state/run.mjs

@@ -275,8 +275,7 @@ export async function reloadRun({ runId, config, readPending = () => [], effecti
       if (config.context?.require_coder_tests === true) frozen.push('context.require_coder_tests');
       // B64b: and never had a block-end hook
       if (config.hooks?.on_block_end !== undefined) frozen.push('hooks.on_block_end');
-      // B87: and never had a proof runner
-      if (config.proof?.runners !== undefined) frozen.push('proof.runners');
+      // B171: a legacy run has no existing runners; adding its first list is safe.
       // B93: and never had a coder sandbox profile
       if (config.coder?.sandbox !== undefined) frozen.push('coder.sandbox');
     }
@@ -324,6 +323,8 @@ export async function reattachWorker({ runId, workerPid, writeRow, probe = proce
     if (current.status !== 'active') throw new StateError('run-ended', `run ${runId} has ended`);
     const pin = await pinWorker(workerPid, probe);
     const pins = current.workers ?? (current.worker ? [current.worker] : []);
+    // Retired pins still authorize completed reviews, but never live-worker checks or signals.
+    if (!add) current.worker_history = [...(current.worker_history ?? []), ...pins];
     current.workers = add ? [...pins, pin] : [pin];
     current.worker = current.workers[0];
     await writeSigned(runId, writeRow, { event: add ? 'worker.add' : 'worker.reattach', pid: workerPid });

package/src/util/exec.mjs

@@ -8,9 +8,9 @@
  *    indefinitely (callers that spawn a reviewer/coder CLI are expected to always pass one —
  *    this module does not impose a default, since a default here would silently apply to every
  *    caller, including ones with a legitimately long-running command).
- *  - On timeout the whole process GROUP is sent SIGTERM, then SIGKILL — the SIGKILL goes to the
- *    group as soon as the direct child exits (or after a grace period), so a grandchild that
- *    traps SIGTERM cannot outlive the call. The result is `failed`, never a partial success.
+ *  - On timeout the process group receives SIGTERM, then SIGKILL after a grace period while
+ *    the leader lives. On every leader exit, remaining members are captured and stopped
+ *    individually after checking their start times. Timeout always resolves `failed`.
  *  - stdin is `ignore`d by default, so a child that reads stdin when it isn't a TTY (`claude -p`,
  *    for one) sees an immediate EOF instead of blocking forever. With `input` (a string or bytes),
  *    stdin is a pipe: the content is written verbatim and then the pipe is closed, so the child
@@ -50,7 +50,8 @@
  */
 
 import { spawn } from 'node:child_process';
-import { registerPid, unregisterPid } from './reaper.mjs';
+import path from 'node:path';
+import { groupMembers, readStartTime, registerPid, stopMembers, unregisterPid } from './reaper.mjs';
 import { pidsDir } from './tmp.mjs';
 
 /** Grace period after SIGTERM before escalating to SIGKILL, in milliseconds. */
@@ -170,16 +171,32 @@ export function exec(argv, opts = {}) {
   const { cwd, env, timeoutMs, input, okExitCodes = [0], maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES } = opts;
   const [command, ...args] = argv;
 
+  /** @type {NodeJS.ProcessEnv} */
+  const childEnv = { ...(env ?? process.env), CODE_FORGE_OWNER_PID: String(process.pid) };
+  const ownerStart = readStartTime(process.pid);
+  if (ownerStart) childEnv.CODE_FORGE_OWNER_START_TIME = ownerStart;
+  else delete childEnv.CODE_FORGE_OWNER_START_TIME;
+  let spawnRegistry = null;
+  try {
+    spawnRegistry = pidsDir();
+    const rootId = path.basename(path.dirname(spawnRegistry));
+    const runAt = process.argv.indexOf('--run');
+    const inlineRun = process.argv.find((arg) => arg.startsWith('--run='))?.slice('--run='.length);
+    const runId = childEnv.CODE_FORGE_RUN_ID ?? process.env.CODE_FORGE_RUN_ID
+      ?? (runAt >= 0 ? process.argv[runAt + 1] : inlineRun) ?? (/^r-/.test(rootId) ? rootId : undefined);
+    if (runId) childEnv.CODE_FORGE_RUN_ID = runId;
+  } catch { /* registry hygiene must never prevent a spawn */ }
+
   return new Promise((resolve) => {
     const stdinMode = input === undefined ? 'ignore' : 'pipe';
-    const child = spawn(command, args, { cwd, env, shell: false, detached: true, stdio: [stdinMode, 'pipe', 'pipe'] });
+    const child = spawn(command, args, { cwd, env: childEnv, shell: false, detached: true, stdio: [stdinMode, 'pipe', 'pipe'] });
     const pid = child.pid;
     /** @type {string | null} */
     let registryDir = null;
     if (typeof pid === 'number') {
       trackChild(pid);
       try {
-        registryDir = pidsDir();
+        registryDir = spawnRegistry ?? pidsDir();
         registerPid(registryDir, pid, command);
       } catch {
         registryDir = null;
@@ -200,6 +217,7 @@ export function exec(argv, opts = {}) {
     let timedOut = false;
     let overBuffer = false;
     let settled = false;
+    let remaining = Promise.resolve();
     /** @type {NodeJS.Timeout | undefined} */
     let termTimer;
     /** @type {NodeJS.Timeout | undefined} */
@@ -216,12 +234,24 @@ export function exec(argv, opts = {}) {
     const stdoutText = () => Buffer.concat(stdoutChunks).toString(opts.stdoutEncoding ?? 'utf8');
     const stderrText = () => Buffer.concat(stderrChunks).toString('utf8');
 
-    /** @param {ExecResult} result */
-    const settle = (result) => {
+    /** @param {Pick<ExecResult, 'code'|'signal'|'error'>} outcome */
+    const settle = async (outcome) => {
       if (settled) return;
       settled = true;
       if (termTimer) clearTimeout(termTimer);
       if (killTimer) clearTimeout(killTimer);
+      await remaining;
+      // Pipe data can arrive while the remaining group members are being stopped.
+      // Snapshot the output and buffer-limit state only once that wait is over.
+      /** @type {ExecResult} */
+      const result = {
+        ...outcome,
+        result: !outcome.error && !timedOut && !overBuffer && outcome.code !== null && okExitCodes.includes(outcome.code) ? 'ok' : 'failed',
+        stdout: stdoutText(),
+        stderr: stderrText(),
+        timedOut,
+        ...(overBuffer ? { error: 'exec: maxBufferBytes exceeded' } : {}),
+      };
       if (typeof pid === 'number') {
         untrackChild(pid);
         if (registryDir !== null) {
@@ -277,40 +307,27 @@ export function exec(argv, opts = {}) {
 
     child.on('error', (err) => {
       settle({
-        result: 'failed',
         code: null,
         signal: null,
-        stdout: stdoutText(),
-        stderr: stderrText(),
-        timedOut,
         error: err.message,
       });
     });
 
-    // Once we've decided to kill (timeout or over-buffer), don't wait for 'close' — a
-    // grandchild that inherited the pipes can keep them open indefinitely, and 'close' would
-    // then never fire even though the child we care about is dead. 'exit' fires as soon as the
-    // child process itself has terminated, which is what "killed after timeout_ms" means. Before
-    // settling (which cancels the grace timer), SIGKILL the group: a grandchild that trapped the
-    // SIGTERM must not survive just because its parent died first.
+    // Capture the group before unregistering on EVERY leader exit. Never signal the dead
+    // leader/group again: each remaining member has its own synchronous identity check.
     child.on('exit', (code, signal) => {
-      if (timedOut || overBuffer) {
-        killGroup('SIGKILL');
-        settle({
-          result: 'failed',
-          code,
-          signal,
-          stdout: stdoutText(),
-          stderr: stderrText(),
-          timedOut,
-          ...(overBuffer ? { error: 'exec: maxBufferBytes exceeded' } : {}),
-        });
+      if (termTimer) clearTimeout(termTimer);
+      if (killTimer) clearTimeout(killTimer);
+      const members = typeof pid === 'number' ? groupMembers(pid) : new Map();
+      if (typeof pid === 'number') untrackChild(pid);
+      remaining = stopMembers(members, KILL_GRACE_MS).then(() => {});
+      if (timedOut || overBuffer || members.size > 0) {
+        settle({ code, signal });
       }
     });
 
     child.on('close', (code, signal) => {
-      const result = !timedOut && !overBuffer && code !== null && okExitCodes.includes(code) ? 'ok' : 'failed';
-      settle({ result, code, signal, stdout: stdoutText(), stderr: stderrText(), timedOut });
+      settle({ code, signal });
     });
   });
 }

package/src/util/native.mjs

@@ -0,0 +1,131 @@
+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 === '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/util/reaper.mjs

@@ -27,7 +27,8 @@
  */
 
 import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 
@@ -186,6 +187,220 @@ export function groupMembers(pgid) {
   return members;
 }
 
+/** @typedef {{uid:number,pid:number,ppid:number,state:string,rssMb:number,start_time:string,command:string}} ProcessInfo */
+
+/** Parse C-locale ps output; malformed rows supply no authority to signal.
+ * @param {string} text @returns {ProcessInfo[]}
+ */
+export function parseProcesses(text) {
+  return text.split('\n').flatMap((line) => {
+    const m = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\d+)\s+(\S+\s+\S+\s+\d+\s+\d+:\d+:\d+\s+\d{4})\s+(.+?)\s*$/.exec(line);
+    return m ? [{ uid: +m[1], pid: +m[2], ppid: +m[3], state: m[4], rssMb: +m[5] / 1024,
+      start_time: m[6].replace(/\s+/g, ' '), command: m[7] }] : [];
+  });
+}
+
+/** @returns {ProcessInfo[]} */
+export function readProcesses() {
+  try {
+    return parseProcesses(execFileSync(existsSync('/bin/ps') ? '/bin/ps' : 'ps',
+      ['-A', '-ww', '-o', 'uid=,pid=,ppid=,stat=,rss=,lstart=,command='], {
+        encoding: 'utf8', env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+        timeout: 5000, maxBuffer: 16 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'],
+      }));
+  } catch { return []; }
+}
+
+/** Current process, ancestors and zombies are never signal targets.
+ * @param {ProcessInfo[]} rows @returns {Set<number>}
+ */
+function protectedPids(rows) {
+  const blocked = new Set([1, process.pid, process.ppid]);
+  const byPid = new Map(rows.map((p) => [p.pid, p]));
+  let pid = process.ppid;
+  const visited = new Set();
+  while (pid > 1 && !visited.has(pid)) {
+    visited.add(pid);
+    blocked.add(pid);
+    pid = byPid.get(pid)?.ppid ?? 1;
+  }
+  for (const p of rows) if (p.state.startsWith('Z')) blocked.add(p.pid);
+  return blocked;
+}
+
+/** One synchronous identity/uid/state check immediately followed by a bare-pid signal.
+ * @param {number} pid @param {string} started @param {NodeJS.Signals} signal
+ * @returns {boolean}
+ */
+function signalMember(pid, started, signal) {
+  if (!started || started === UNKNOWN_START_TIME || !process.getuid) return false;
+  const rows = readProcesses();
+  const p = rows.find((r) => r.pid === pid);
+  if (!p || p.uid !== process.getuid() || protectedPids(rows).has(pid) || p.start_time !== started) return false;
+  try { process.kill(pid, signal); return true; } catch { return false; }
+}
+
+/** Stop a captured set, checking every member separately at both signals.
+ * @param {Map<number,string>} members @param {number} [graceMs]
+ * @returns {Promise<Map<number, 'SIGTERM'|'SIGKILL'>>}
+ */
+export async function stopMembers(members, graceMs = DEFAULT_GRACE_MS) {
+  const sent = new Map();
+  for (const [pid, started] of members) if (signalMember(pid, started, 'SIGTERM')) sent.set(pid, 'SIGTERM');
+  const deadline = Date.now() + graceMs;
+  while (sent.size && Date.now() < deadline) {
+    const live = readProcesses();
+    if (![...sent.keys()].some((pid) => live.some((p) => p.pid === pid && !p.state.startsWith('Z') && p.start_time === members.get(pid)))) break;
+    await sleep(POLL_MS);
+  }
+  for (const pid of sent.keys()) if (signalMember(pid, members.get(pid), 'SIGKILL')) sent.set(pid, 'SIGKILL');
+  // Delivery is not exit: wait for SIGKILL to take effect before exec can return to its caller.
+  const killedDeadline = Date.now() + Math.max(graceMs, 1000);
+  while (sent.size && Date.now() < killedDeadline) {
+    await sleep(POLL_MS);
+    const live = readProcesses();
+    if (![...sent.keys()].some((pid) => live.some((p) => p.pid === pid && !p.state.startsWith('Z') && p.start_time === members.get(pid)))) break;
+  }
+  return sent;
+}
+
+/** Read only ownership markers, never retain/print the rest of a child's environment.
+ * @param {ProcessInfo} p @returns {Record<string,string>|null}
+ */
+export function readProcessEnv(p) {
+  try {
+    let text;
+    if (process.platform === 'linux') text = readFileSync(`/proc/${p.pid}/environ`, 'utf8');
+    else if (process.platform === 'darwin') {
+      const out = execFileSync('/bin/ps', ['-E', '-ww', '-o', 'pid=,ppid=,lstart=,command=', '-p', String(p.pid)], {
+        encoding: 'utf8', timeout: 5000, maxBuffer: 8 * 1024 * 1024,
+        env: { ...process.env, LC_ALL: 'C', LANG: 'C' }, stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      const m = /^\s*(\d+)\s+(\d+)\s+(\S+\s+\S+\s+\d+\s+\d+:\d+:\d+\s+\d{4})\s+/.exec(out);
+      if (!m || +m[1] !== p.pid || +m[2] !== p.ppid || m[3].replace(/\s+/g, ' ') !== p.start_time) return null;
+      text = out.slice(m[0].length);
+      // ps appends the environment to argv. An ownership-looking argument is not an env
+      // marker: strip the independently observed command before parsing the environment.
+      if (!text.startsWith(`${p.command} `)) return null;
+      text = text.slice(p.command.length + 1);
+    } else return null;
+    /** @type {Record<string,string>} */
+    const markers = {};
+    for (const name of ['HOME', 'CODE_FORGE_OWNER_PID', 'CODE_FORGE_RUN_ID', 'CODE_FORGE_OWNER_START_TIME']) {
+      const match = process.platform === 'linux'
+        ? text.split('\0').find((entry) => entry.startsWith(`${name}=`))?.slice(name.length + 1)
+        : new RegExp(`(?:^|\\s)${name}=(.*?)(?=\\s+[A-Za-z_][A-Za-z0-9_]*=|$)`).exec(text)?.[1];
+      if (match !== undefined) markers[name] = match;
+    }
+    return markers;
+  } catch { return null; }
+}
+
+/**
+ * Inspect and optionally stop proven code-forge processes. Defaults are read-only.
+ * `psText`/readers are test seams; production always probes the OS and existing record reader.
+ * @param {{apply?:boolean, root?:string, runId?:string, orphansOnly?:boolean, zombies?:boolean,
+ * graceMs?:number, psText?:string, uid?:number,
+ * readEnv?:(p:ProcessInfo)=>Record<string,string>|null,
+ * readRun?:(id:string)=>Promise<Record<string,any>>}} [opts]
+ */
+export async function sweepProcesses(opts = {}) {
+  const rows = opts.psText === undefined ? readProcesses() : parseProcesses(opts.psText);
+  const uid = opts.uid ?? process.getuid?.();
+  const own = rows.filter((p) => p.uid === uid);
+  const blocked = protectedPids(rows);
+  const envFor = opts.readEnv ?? readProcessEnv;
+  const loadRun = opts.readRun ?? (await import('../state/run.mjs')).readRun;
+  const tmp = await import('./tmp.mjs');
+  /** @type {(ProcessInfo & {kind:'worker'|'orphan'|'registry',runId?:string,action?:string})[]} */
+  const items = [];
+  /** @type {{ppid:number,command:string,count:number,pids:number[]}[]} */
+  const zombies = [];
+  if (opts.zombies !== false && !opts.orphansOnly) {
+    for (const p of own.filter((p) => p.state.startsWith('Z'))) {
+      let group = zombies.find((g) => g.ppid === p.ppid);
+      if (!group) { group = { ppid: p.ppid, command: rows.find((r) => r.pid === p.ppid)?.command ?? '(unreadable)', count: 0, pids: [] }; zombies.push(group); }
+      group.count++; group.pids.push(p.pid);
+    }
+  }
+  for (const p of own) {
+    if (p.pid <= 1 || blocked.has(p.pid)) continue;
+    // Exactly node + a code-forge entry point + worker, never an argv substring in a shell/-e.
+    const worker = /^(?:\S*\/)?node(?:js)?\s+(?:\S*\/)?code-forge\.mjs\s+worker\s+--run(?:=|\s+)([a-z0-9][a-z0-9-]{0,63})(?:\s|$)/.exec(p.command);
+    if (worker && !opts.orphansOnly) {
+      // Run records only authorize worker cleanup inside their own code-forge home.
+      // Unreadable environments and workers from another HOME supply no such authority.
+      if (envFor(p)?.HOME !== os.homedir()) continue;
+      try {
+        const record = await loadRun(worker[1]);
+        if (typeof record.status === 'string' && !['open', 'running', 'active'].includes(record.status)) items.push({ ...p, kind: 'worker', runId: worker[1] });
+      } catch (err) {
+        if (err?.code === 'no-run') items.push({ ...p, kind: 'worker', runId: worker[1] });
+      }
+      // The run record is authoritative for workers, including when it cannot be read.
+      continue;
+    }
+    if (p.ppid !== 1 || items.some((item) => item.pid === p.pid)) continue;
+    const env = envFor(p);
+    const owner = env?.CODE_FORGE_OWNER_PID;
+    if (!owner || !/^[1-9]\d*$/.test(owner) || +owner <= 1 || (opts.runId && env.CODE_FORGE_RUN_ID !== opts.runId)) continue;
+    const liveOwner = rows.find((r) => r.pid === +owner);
+    const recorded = env.CODE_FORGE_OWNER_START_TIME;
+    // A missing row alone is not proof of death when ps was incomplete.
+    const dead = !liveOwner ? !isAlive(+owner) : liveOwner.state.startsWith('Z')
+      || !!recorded && recorded !== UNKNOWN_START_TIME && liveOwner.start_time !== recorded;
+    if (dead) items.push({ ...p, kind: 'orphan', ...(env.CODE_FORGE_RUN_ID ? { runId: env.CODE_FORGE_RUN_ID } : {}) });
+  }
+  const root = tmp.tmpBase(opts.root);
+  const registryRoots = [];
+  if (!opts.orphansOnly && tmp.untrustedReason(root) === null) {
+    for (const dir of readdirSync(root, { withFileTypes: true })) {
+      const full = path.join(root, dir.name);
+      if (!dir.isDirectory() || tmp.untrustedReason(full) !== null) continue;
+      const state = tmp.ownerState(full);
+      let reap = state === 'dead';
+      if (state === 'missing') {
+        // Mirror sweepRoots' ten-minute ownerless grace, including every registry mtime.
+        try {
+          const pids = path.join(full, 'pids');
+          const files = existsSync(pids) ? [pids, ...readdirSync(pids).map((name) => path.join(pids, name))] : [];
+          reap = [full, ...files].every((file) => Date.now() - lstatSync(file).mtimeMs > 600_000);
+        } catch { reap = false; }
+      }
+      if (!reap) continue;
+      registryRoots.push(full);
+      for (const entry of listEntries(path.join(full, 'pids'))) {
+        const p = own.find((p) => p.pid === entry.pid && p.start_time === entry.start_time);
+        if (!p || blocked.has(p.pid)) continue;
+        const members = new Map([[p.pid, p.start_time], ...groupMembers(p.pid)]);
+        for (const [pid, started] of members) {
+          const member = own.find((p) => p.pid === pid && p.start_time === started);
+          if (member && !blocked.has(pid) && !items.some((i) => i.pid === pid)) items.push({ ...member, kind: 'registry' });
+        }
+      }
+    }
+  }
+  // Memory across all code-forge trees, deduplicated. Unmarked descendants are children too.
+  const forge = new Set(own.filter((p) => /^(?:\S*\/)?node(?:js)?\s+(?:\S*\/)?code-forge\.mjs(?:\s|$)/.test(p.command) || p.pid === process.pid).map((p) => p.pid));
+  const tree = new Set(forge);
+  let size;
+  do { size = tree.size; for (const p of own) if (tree.has(p.ppid)) tree.add(p.pid); } while (tree.size !== size);
+  const sum = (/** @type {ProcessInfo[]} */ ps) => ps.reduce((n, p) => n + p.rssMb, 0);
+  const memory = { codeForgeMb: sum(own.filter((p) => forge.has(p.pid))), childrenMb: sum(own.filter((p) => tree.has(p.pid) && !forge.has(p.pid))), orphansMb: sum(items.filter((p) => p.kind === 'orphan')) };
+  if (opts.apply) {
+    for (const item of items.filter((p) => p.kind !== 'registry')) {
+      const stopped = await stopMembers(new Map([[item.pid, item.start_time]]), opts.graceMs);
+      item.action = stopped.has(item.pid) ? 'stopped' : 'skipped';
+    }
+    if (!opts.orphansOnly) await tmp.sweepRoots({ root, graceMs: opts.graceMs });
+    for (const item of items.filter((p) => p.kind === 'registry')) {
+      const started = readStartTime(item.pid);
+      item.action = !isAlive(item.pid) || (started !== null && started !== item.start_time) ? 'stopped' : 'skipped';
+    }
+  }
+  return { apply: opts.apply === true, items, registryRoots, zombies, totalRssMb: sum(items), memory };
+}
+
 /**
  * Send `signal` to `pid`'s group — only after a SYNCHRONOUS start-time match, with no await
  * between the check and the kill. Falls back to the bare pid only when the group does not exist
@@ -196,6 +411,19 @@ export function groupMembers(pgid) {
  * @returns {'sent'|'mismatch'|'eperm'|'gone'}
  */
 function signalIfOurs(pid, recorded, signal) {
+  const rows = readProcesses();
+  const blocked = protectedPids(rows);
+  const leader = rows.find((p) => p.pid === pid);
+  if (!process.getuid || !leader || leader.uid !== process.getuid() || blocked.has(pid)) return 'eperm';
+  const members = groupMembers(pid);
+  const safeGroup = [...members].every(([member, started]) => rows.some((p) => p.pid === member
+    && p.uid === process.getuid() && !blocked.has(member) && p.start_time === started));
+  if (!safeGroup) {
+    if (readStartTime(pid) !== recorded) return 'mismatch';
+    const sent = signalMember(pid, recorded, signal);
+    for (const [member, started] of members) signalMember(member, started, signal);
+    return sent ? 'sent' : 'eperm';
+  }
   if (readStartTime(pid) !== recorded) return 'mismatch';
   try {
     process.kill(-pid, signal);
@@ -234,10 +462,16 @@ export async function sweep(dir, opts = {}) {
   const { graceMs = DEFAULT_GRACE_MS } = opts;
   /** @type {SweepResult} */
   const result = { killed: [], mismatched: [], unknown: [], stale: [] };
+  const rows = readProcesses();
+  const blocked = protectedPids(rows);
 
   for (const entry of listEntries(dir)) {
     const { pid } = entry;
-    if (pid === process.pid) continue;
+    if (blocked.has(pid)) continue;
+    if (isAlive(pid) && !rows.some((p) => p.pid === pid && p.uid === process.getuid?.())) {
+      result.unknown.push(pid);
+      continue;
+    }
 
     if (!isAlive(pid)) {
       unregisterPid(dir, pid);
@@ -278,6 +512,7 @@ export async function sweep(dir, opts = {}) {
         continue;
       }
       await waitForDeath(pid, graceMs);
+      for (const [member, started] of members) signalMemberIfOurs(member, started);
       result.killed.push({ pid, signal: 'SIGKILL' });
     }
     unregisterPid(dir, pid);
@@ -291,10 +526,5 @@ export async function sweep(dir, opts = {}) {
  * @param {number} pid @param {string} started
  */
 function signalMemberIfOurs(pid, started) {
-  if (readStartTime(pid) !== started) return;
-  try {
-    process.kill(pid, 'SIGKILL');
-  } catch {
-    // gone between the check and the kill
-  }
+  signalMember(pid, started, 'SIGKILL');
 }

package/src/worker/engine.mjs

@@ -109,7 +109,7 @@ 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 { assertAnswers, enqueueHash, isDone, writeResult } from './queue.mjs';
+import { assertAnswers, enqueueHash, isDone, reviewExclusionFor, writeResult } from './queue.mjs';
 import { assertTicketId, contentHash, readRegularFileNoFollow, WorkerError } from './ticket.mjs';
 
 /**
@@ -345,6 +345,9 @@ export function packetDirFor(runRootDir, id) {
  * @returns {Promise<ReviewOutcome>}
  */
 export async function reviewTicket(ticket, ctx) {
+  const excluded = (/** @type {string} */ file) => reviewExclusionFor(ctx.repoRoot, ctx.runId, file, ctx.cfg);
+  const rule = excluded(ticket.file) ?? (ticket.kind === 'answers' ? excluded(ticket.by_file) : null);
+  if (rule !== null) return { status: 'excluded', reason: `review.exclude ${rule}`, approved: false, engine: 'adaptive', sessions: [] };
   const workDir = packetDirFor(ctx.runRootDir, ticket.ticket);
   if (workDir === null) return { status: 'unavailable', reason: 'ticket-id-invalid', approved: false, engine: 'adaptive', sessions: [] };
   let entry;
@@ -390,7 +393,7 @@ export async function reviewTicket(ticket, ctx) {
     try {
       // Read the listing directly: blockPeers' [] fallback would hide a git failure and
       // still authorize explicit tests. Context and peer diffs must fail soft together.
-      const peers = entry.base === null || entry.owned.length === 0 ? [] : (await computeFileSet({ cwd: contentRoot, base: entry.base })).all.filter((f) => f !== ticket.file && ownsFile(entry.owned, f, entry.ownedKinds));
+      const peers = entry.base === null || entry.owned.length === 0 ? [] : (await computeFileSet({ cwd: contentRoot, base: entry.base })).all.filter((f) => f !== ticket.file && ownsFile(entry.owned, f, entry.ownedKinds) && excluded(f) === null);
       readDiffs = peerDiffReader({ repoRoot: contentRoot, base: entry.base, file: ticket.file, peers });
       const changedFiles = [...peers, ticket.file].filter((f) => ownsFile(entry.owned, f, entry.ownedKinds));
       return { peers, changedFiles, ownedFiles: [...new Set([...changedFiles, ...entry.testFiles])], testFiles: entry.testFiles };
@@ -444,7 +447,7 @@ async function lightRound(ticket, ctx, { entry, workDir, factsExcerpt, rulesDige
   const worker = { pid: process.pid, started_at: await processStartTime(process.pid) };
   return withLock(`light:${ctx.runId}\0${ticket.block}`, async () => {
     const root = ctx.contentRoot ?? ctx.repoRoot;
-    const files = (await computeFileSet({ cwd: root, base: entry.base ?? 'HEAD' })).all.filter((file) => ownsFile(entry.owned, file, entry.ownedKinds)).sort();
+    const files = (await computeFileSet({ cwd: root, base: entry.base ?? 'HEAD' })).all.filter((file) => ownsFile(entry.owned, file, entry.ownedKinds) && reviewExclusionFor(ctx.repoRoot, ctx.runId, file, ctx.cfg) === null).sort();
     const hashes = files.map((file) => ({ file, content_hash: contentHash(root, file) }));
     if (!hashes.some((f) => f.file === ticket.file && f.content_hash === ticket.content_hash)) return { status: 'stale', approved: false, engine: 'adaptive', sessions: [] };
     const signature = JSON.stringify([entry.base, hashes]);
@@ -473,6 +476,7 @@ async function lightRound(ticket, ctx, { entry, workDir, factsExcerpt, rulesDige
         if (approved) await writeRow({ event: 'review.approved', file, content_hash });
       }
       const queued = enqueueHash({ repoRoot: ctx.repoRoot, run: ctx.runId, block: ticket.block, file, content_hash, ...(ticket.tree ? { tree: ticket.tree } : {}) });
+      if (queued.status === 'excluded') continue;
       const open = approved ? [] : own;
       await writeRow({ event: 'review.result', ticket: queued.ticket, file, content_hash, status: outcome.status, approved, open, worker });
       writeResult({ repoRoot: ctx.repoRoot, runId: ctx.runId, ticket: queued.ticket, result: { ...outcome, block: ticket.block, file, content_hash, open, worker }, key });