@codedology/code-forge 0.14.0 → 0.15.0

package/src/state/run.mjs

@@ -12,6 +12,7 @@
  * parameter; the CLI verb does the static import) and are SIGNED with the run key first.
  */
 
+import { existsSync } from 'node:fs';
 import { mkdir, readFile, rename, rmdir, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { exec } from '../util/exec.mjs';
@@ -31,7 +32,7 @@ const LOCK_POLL_MS = 25;
  */
 export async function processStartTime(pid) {
   if (!Number.isInteger(pid) || pid <= 0) return null;
-  const res = await exec(['ps', '-o', 'lstart=', '-p', String(pid)], {
+  const res = await exec([existsSync('/bin/ps') ? '/bin/ps' : 'ps', '-o', 'lstart=', '-p', String(pid)], {
     env: { ...process.env, LC_ALL: 'C' },
     okExitCodes: [0, 1],
     timeoutMs: 10000,
@@ -177,6 +178,7 @@ export async function startRun(opts) {
     orchestrator_pid: opts.orchestratorPid ?? process.pid,
     solo_pid: opts.soloPid ?? null,
     worker,
+    workers: worker ? [worker] : [],
     status: 'active',
     blocks: {},
     orphans: [],
@@ -250,6 +252,10 @@ export async function reloadRun({ runId, config, readPending = () => [], effecti
     if (oldHash === newHash) return { changed: [], oldHash, newHash, pinned: 0, rowError: null };
     const before = state && Object.hasOwn(stored, state.hash) ? stored[state.hash] : undefined;
     if (state && (before === null || typeof before !== 'object')) throw new StateError('config-snapshot', `run ${runId}: the current config snapshot is missing from the run record`);
+    // B138: close authority belongs to the run-start snapshot, including legacy runs.
+    if (before?.close?.require_human !== config.close?.require_human) {
+      throw new StateError('immutable-key', 'close.require_human cannot change mid-run (fixed by the owner before the run starts)');
+    }
     /** @type {string[]} */
     let frozen;
     if (state) {
@@ -309,15 +315,18 @@ export async function reloadRun({ runId, config, readPending = () => [], effecti
 
 /**
  * `run start --reattach`: re-pin a restarted worker (the orchestrator only — §4.8).
- * @param {{runId: string, workerPid: number, writeRow: WriteRow, probe?: StartTimeProbe}} opts
+ * @param {{runId: string, workerPid: number, writeRow: WriteRow, probe?: StartTimeProbe, add?: boolean}} opts
  */
-export async function reattachWorker({ runId, workerPid, writeRow, probe = processStartTime }) {
+export async function reattachWorker({ runId, workerPid, writeRow, probe = processStartTime, add = false }) {
   if (!isSignalablePid(workerPid)) throw new StateError('bad-worker-pid', 'worker pid must be an integer > 1');
   return withRunLock(runId, async () => {
     const current = await readRun(runId);
     if (current.status !== 'active') throw new StateError('run-ended', `run ${runId} has ended`);
-    current.worker = await pinWorker(workerPid, probe);
-    await writeSigned(runId, writeRow, { event: 'worker.reattach', pid: workerPid });
+    const pin = await pinWorker(workerPid, probe);
+    const pins = current.workers ?? (current.worker ? [current.worker] : []);
+    current.workers = add ? [...pins, pin] : [pin];
+    current.worker = current.workers[0];
+    await writeSigned(runId, writeRow, { event: add ? 'worker.add' : 'worker.reattach', pid: workerPid });
     await saveRun(current);
     return current;
   });
@@ -331,7 +340,18 @@ export async function reattachWorker({ runId, workerPid, writeRow, probe = proce
  * @returns {Promise<{ok: boolean, event?: 'worker.replaced' | 'worker.down', reason?: string}>}
  */
 export async function checkWorkerPin(record, { livePid, probe = processStartTime } = {}) {
-  const pin = record.worker;
+  let pin = record.worker;
+  if (record.workers?.length > 1) {
+    const pins = record.workers;
+    if (pins.some((p) => !isSignalablePid(p.pid)) || (livePid !== undefined && !pins.some((p) => p.pid === livePid))) {
+      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));
+      return live.some(Boolean) ? { ok: true } : { ok: false, event: 'worker.down', reason: 'no pinned worker is running' };
+    }
+    pin = pins.find((p) => p.pid === livePid);
+  }
   if (!pin) return { ok: false, event: 'worker.down', reason: 'no worker is pinned for this run' };
   if (!isSignalablePid(pin.pid)) return { ok: false, event: 'worker.replaced', reason: 'the pinned worker pid is not an integer > 1' };
   if (livePid !== undefined && livePid !== pin.pid) {
@@ -380,14 +400,21 @@ export async function endRun({ runId, writeRow, stopWorker = stopPinnedWorker, p
   return withRunLock(runId, async () => {
     const current = await readRun(runId);
     if (current.status !== 'active') throw new StateError('run-ended', `run ${runId} has already ended`);
+    const awaiting = Object.keys(current.blocks).filter((id) => current.blocks[id].status === 'awaiting_human_check');
+    if (awaiting.length > 0) throw new StateError('awaiting-human-check', `run ${runId} has blocks awaiting human check: ${awaiting.join(', ')}; human-pass or stop them first`);
     const open = Object.keys(current.blocks).filter((id) => current.blocks[id].status === 'open');
     if (open.length > 0) throw new StateError('open-blocks', `run ${runId} still has open blocks: ${open.join(', ')}`);
     const pin = await checkWorkerPin(current, { probe });
     if (!pin.ok) await writeSigned(runId, writeRow, { event: pin.event, reason: pin.reason });
-    const stop = pin.ok ? await stopWorker(current.worker, { probe }) : { stopped: false };
+    let stopped = false;
+    for (const worker of current.workers ?? (current.worker ? [current.worker] : [])) {
+      if ((await checkWorkerPin({ worker }, { probe })).ok) {
+        stopped = (await stopWorker(worker, { probe })).stopped || stopped;
+      }
+    }
     current.status = 'ended';
     current.ended_at = new Date().toISOString();
-    await writeSigned(runId, writeRow, { event: 'run.end', worker_check: pin.ok ? 'ok' : pin.event, worker_stopped: stop.stopped });
+    await writeSigned(runId, writeRow, { event: 'run.end', worker_check: pin.ok ? 'ok' : pin.event, worker_stopped: stopped });
     await saveRun(current);
     return current;
   });

package/src/util/forbidden.mjs

@@ -282,6 +282,7 @@ export const FORBIDDEN = Object.freeze(
  *  - `--no-require-reviews` — the human's way out of `block close`'s per-file review check;
  *  - `--remove-worktree` (B62a) — `block close` removing the block's worktree, the orchestrator's
  *    alone. `block close` itself is not on this list, so the flag is listed on its own.
+ *  - `code-forge block human-pass` (B137) — passing a human device check is human-only.
  * @type {ReadonlyArray<ForbiddenEntry>}
  */
 export const CODER_ONLY_FORBIDDEN = Object.freeze(
@@ -346,6 +347,19 @@ export const CODER_ONLY_FORBIDDEN = Object.freeze(
       prefixes: [['code-forge', 'block', 'ack-waivers'], ['forge', 'block', 'ack-waivers']],
       description: 'Acknowledge agent waivers — human-only, confirmed in the human terminal (B124b)',
     },
+    {
+      id: 'code-forge-block-human-pass-from-coder',
+      kind: 'anyPrefix',
+      prefixes: [['code-forge', 'block', 'human-pass'], ['forge', 'block', 'human-pass']],
+      description: 'Pass a human device check — human-only, confirmed in the human terminal (B137)',
+    },
+    {
+      id: 'code-forge-add-worker-from-coder',
+      kind: 'commandFlag',
+      command: ['code-forge', 'run', 'start'],
+      groups: [{ anyOf: ['--add-worker'] }],
+      description: 'Add a review worker to a run — the orchestrator only (B107)',
+    },
   ].map(freezeEntry),
 );
 

package/src/util/reaper.mjs

@@ -27,7 +27,7 @@
  */
 
 import { execFileSync } from 'node:child_process';
-import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 
@@ -85,7 +85,7 @@ export function isAlive(pid) {
 export function readStartTime(pid) {
   if (!isValidPid(pid)) return null;
   try {
-    const out = execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+    const out = execFileSync(existsSync('/bin/ps') ? '/bin/ps' : 'ps', ['-o', 'lstart=', '-p', String(pid)], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
       env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
@@ -165,7 +165,7 @@ export function groupMembers(pgid) {
   const members = new Map();
   let out = '';
   try {
-    out = execFileSync('ps', ['-A', '-o', 'pid=,pgid=,lstart='], {
+    out = execFileSync(existsSync('/bin/ps') ? '/bin/ps' : 'ps', ['-A', '-o', 'pid=,pgid=,lstart='], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
       env: { ...process.env, LC_ALL: 'C', LANG: 'C' },

package/src/worker/engine.mjs

@@ -95,13 +95,13 @@ import { askJev } from '../decide/jev-client.mjs';
 import { planAndRecord, tierOf } from '../review/budget.mjs';
 import { budgetFor } from '../review/packet.mjs';
 import { ContextError, reviewDigest } from '../context/pack.mjs';
-import { reviewFile, rulesRisk } from '../review/engine.mjs';
+import { reviewFile, reviewLightBatch, rulesRisk } from '../review/engine.mjs';
 import { reviewAnswers } from '../review/answers.mjs';
 import { peerDiffReader } from '../review/moved.mjs';
 import { computeFileSet, ownsFile } from '../gates/scope.mjs';
 import { extraRoundsFor, newFileState, reopenForExtraRound, runRound } from '../review/fixloop.mjs';
 import { reopenRowFor } from '../review/reopen.mjs';
-import { readRun } from '../state/run.mjs';
+import { processStartTime, readRun } from '../state/run.mjs';
 import { StateError } from '../state/paths.mjs';
 import { blockTree, worktreeRecord } from '../proof/worktree.mjs';
 import { ledgerSchemaHistory } from '../review/schema-fallback.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 } from './queue.mjs';
+import { assertAnswers, enqueueHash, isDone, writeResult } from './queue.mjs';
 import { assertTicketId, contentHash, readRegularFileNoFollow, WorkerError } from './ticket.mjs';
 
 /**
@@ -127,6 +127,8 @@ import { assertTicketId, contentHash, readRegularFileNoFollow, WorkerError } fro
  *   the worker's and a per-call `cfg` wins).
  * @property {(row: Record<string, any>) => Promise<unknown>} [writeRow] - a signed ledger row
  *   (the worker adds `run`, `block`, `file`, `content_hash`).
+ * @property {(row: Record<string, any>) => Promise<unknown>} [writeBlockRow] - light fanout rows;
+ *   the worker pins run and block, while the batch supplies each file and content hash.
  * @property {Buffer} [key] - the run's HMAC key: signs the fix-loop state. Absent ⇒ engine only.
  * @property {() => Promise<Array<Record<string, any>>>} [readRows] - the run's ledger rows (the
  *   `review.state` anchors the state is checked against); required with `key`.
@@ -197,7 +199,7 @@ export async function blockEntryFor(runId, block) {
       throw new Error('worktree-malformed');
     }
   }
-  return { base: tree ? tree.base_sha : sha, level: typeof entry.level === 'string' && /^L[0-3]$/.test(entry.level) ? entry.level : 'L2', owned, ownedKinds, testFiles, acceptance: entry.acceptance, kind: blockKind({ owned, declared: entry.kind }), tree, workspace: typeof record.workspace === 'string' ? record.workspace : null };
+  return { base: tree ? tree.base_sha : sha, level: typeof entry.level === 'string' && /^L[0-3]$/.test(entry.level) ? entry.level : 'L2', owned, ownedKinds, testFiles, acceptance: entry.acceptance, kind: entry.kind === 'light' ? 'light' : blockKind({ owned, declared: entry.kind }), tree, workspace: typeof record.workspace === 'string' ? record.workspace : null };
 }
 
 /** @typedef {{path: string, branch: string, base_sha: string}} WorktreeEntry */
@@ -411,6 +413,10 @@ export async function reviewTicket(ticket, ctx) {
       return { status: 'unavailable', reason: 'context-unreadable', approved: false, engine: 'adaptive', sessions: [] };
     }
     const digest = rulesDigest === '' ? {} : { rulesDigest };
+    if (entry.kind === 'light' && ctx.key) {
+      const batch = await lightRound(ticket, tctx, { entry, workDir, factsExcerpt, rulesDigest });
+      if (batch) return batch;
+    }
     if (!ctx.key) {
       return await reviewFile(
         { repoRoot: contentRoot, file: ticket.file, base: entry.base, cfg: ctx.cfg, kind: entry.kind, workDir, factsExcerpt, ...digest, peerDiffs, ...(await fileContext()) },
@@ -423,6 +429,56 @@ export async function reviewTicket(ticket, ctx) {
   }
 }
 
+/** Serialize a light block across tickets/workers; durable signed rows enforce the two-batch cap.
+ * A batch completes every file's queue ticket, including files queued after this ticket started.
+ * @param {import('./queue.mjs').Ticket} ticket @param {ReviewContext} ctx
+ * @param {{entry: Awaited<ReturnType<typeof blockEntryFor>>, workDir: string, factsExcerpt: string, rulesDigest: string}} input
+ * @returns {Promise<ReviewOutcome | null>} null enters the ordinary per-file loop.
+ */
+async function lightRound(ticket, ctx, { entry, workDir, factsExcerpt, rulesDigest }) {
+  if (!ctx.key || !ctx.readRows || !ctx.writeBlockRow) return { status: 'unavailable', reason: 'no-ledger', approved: false, engine: 'adaptive', sessions: [] };
+  const key = ctx.key, readRows = ctx.readRows, writeRow = ctx.writeBlockRow;
+  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 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]);
+    const rows = (await readRows()).filter((r) => r.run === ctx.runId && r.block === ticket.block && verifyRow(r, key).ok);
+    const cached = rows.filter((r) => r.event === 'review.light_result' && r.signature === signature).at(-1)?.outcomes?.[ticket.file];
+    if (cached && (cached.status === 'reviewed' || isDone(ctx.repoRoot, ticket.ticket))) return cached;
+    const count = rows.filter((r) => r.event === 'review.light_batch').length;
+    if (count >= 2) return null;
+    const round = count + 1;
+    // Reserve before the session: a crash cannot reset the cap on a worker restart.
+    await writeRow({ event: 'review.light_batch', round, signature });
+    const batch = await reviewLightBatch({ repoRoot: root, files, base: entry.base, cfg: ctx.cfg, workDir, factsExcerpt, rulesDigest }, { spawn: ctx.spawn, writeRow });
+    const moved = hashes.some((f) => contentHash(root, f.file) !== f.content_hash);
+    const findings = batch.findings ?? [];
+    const blocking = findings.some((f) => f.severity === 'critical' || f.severity === 'warning');
+    /** @type {Record<string, ReviewOutcome>} */
+    const outcomes = {};
+    for (const { file, content_hash } of hashes) {
+      const own = findings.filter((f) => f.file === file);
+      const approved = !moved && batch.status === 'reviewed' && (batch.approved || blocking) && own.every((f) => f.severity === 'nit');
+      const outcome = { ...batch, ...(moved ? { status: 'stale' } : {}), approved, findings: own, round, kind: 'full', level: entry.level,
+        next: { action: approved ? 'complete' : 'fix', level: entry.level } };
+      outcomes[file] = outcome;
+      if (batch.status === 'reviewed' && !moved) {
+        await writeRow({ event: 'review.round', file, content_hash, round, kind: 'full', level: entry.level, open_after: own.filter((f) => f.severity !== 'nit').length });
+        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 } : {}) });
+      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 });
+    }
+    await writeRow({ event: 'review.light_result', signature, outcomes });
+    return outcomes[ticket.file];
+  });
+}
+
 /**
  * B56: the block's OTHER changed files — the §4.1 file set since the block base (tracked changes ∪
  * untracked), filtered to the block's owned files (`ownsFile`, as the budget row does), minus the

package/src/worker/loop.mjs

@@ -42,12 +42,13 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { expiryChecks } from '../autopilot/limits.mjs';
 import { loadProjectConfig } from '../config/load.mjs';
+import { reviewWorkers } from '../config/validate.mjs';
 import { cacheHoursFrom, createDefaultKeyStore, resolveKey } from '../keys/store.mjs';
 import { appendRow, readAllRows } from '../ledger/write.mjs';
 import { spawnSession } from '../session/spawn.mjs';
 import { snapshotFor } from '../state/config-snapshot.mjs';
 import { runRecordPath } from '../state/paths.mjs';
-import { readRun, reattachWorker } from '../state/run.mjs';
+import { processStartTime, readRun, reattachWorker } from '../state/run.mjs';
 import { loadKey, signRow } from '../state/signer.mjs';
 import { logWarning } from '../util/error-log.mjs';
 import { withLock, tryLock } from '../util/file-locks.mjs';
@@ -260,6 +261,7 @@ export function recordedVerdict(result) {
  */
 export async function createWorker(opts, deps = {}) {
   const { runId, repoRoot, cfg, runRootDir, slug, key } = opts;
+  const identity = { pid: process.pid, started_at: await processStartTime(process.pid) };
   const env = deps.env ?? process.env;
   const review = deps.review ?? reviewTicket;
   const spawn = deps.spawn ?? spawnSession;
@@ -382,6 +384,7 @@ export async function createWorker(opts, deps = {}) {
           { env: childEnv, ...(deps.bins ? { bins: deps.bins } : {}), ...(deps.stderr ? { stderr: deps.stderr } : {}) },
         ),
       writeRow: (row) => ledger({ ...row, block: ticket.block, file: ticket.file, content_hash: ticket.content_hash }),
+      writeBlockRow: (row) => ledger({ ...row, block: ticket.block }),
     };
     try {
       const outcome = await review(ticket, ctx);
@@ -484,12 +487,14 @@ export async function createWorker(opts, deps = {}) {
    * @param {string} id @param {Record<string, any>} outcome - recorded through {@link recordedVerdict}.
    */
   async function complete(id, outcome) {
-    const result = recordedVerdict(outcome);
+    /** @type {Record<string, any>} */
+    const result = { ...recordedVerdict(outcome), worker: identity };
     const signed = writeResult({ repoRoot, runId, ticket: id, result, key });
     try {
       await ledger({
         event: 'review.result',
         ticket: id,
+        worker: identity,
         block: result.block ?? null,
         file: result.file ?? null,
         content_hash: result.content_hash ?? null,
@@ -793,9 +798,6 @@ export async function createWorker(opts, deps = {}) {
   return { processTicket, drain, run, once, stop, release, announce, watchTick: tickWatch, jevKeyResolved: jevKey !== null, sessionEnv: childEnv };
 }
 
-/** This block permits one registered worker per queue. */
-const WORKER_LIMIT = 1;
-
 /**
  * Start-up for the `worker` verb: run record, repo root, config, run temp root (owned by this
  * process), run key; refuses when another live worker already serves this queue.
@@ -831,7 +833,10 @@ export async function bootWorker(opts, deps = {}) {
     const legacy = liveWorker(repoRoot);
     if (legacy && !entries.some((entry) => entry.worker?.pid === legacy.pid && entry.worker.start_time === legacy.start_time)) count++;
     await deps.hooks?.afterCount?.(count);
-    if (count >= WORKER_LIMIT) throw new WorkerError('worker-running', 'a live or unreadable worker entry already serves this queue');
+    const limit = reviewWorkers(cfg);
+    if (entries.some((entry) => entry.live && !entry.worker) || (legacy && legacy.run !== opts.runId) || entries.some((entry) => entry.live && entry.worker?.run !== opts.runId) || count >= limit) {
+      throw new WorkerError('worker-running', `review.workers limit ${limit}: a live or unreadable worker entry already serves this queue`);
+    }
     worker.announce();
   });
   return { ...worker, repoRoot, runRootDir };
@@ -844,10 +849,10 @@ export async function bootWorker(opts, deps = {}) {
  * `expectPid` (a `run start` that just launched a worker) pins ONLY that pid: an older or stale
  * announcement naming another live pid is refused (`worker_mismatch`) instead of being pinned
  * over the new worker.
- * @param {{runId: string, repoRoot: string, writeRow?: (row: Record<string, any>) => Promise<unknown>, probe?: import('../state/run.mjs').StartTimeProbe, expectPid?: number}} opts
+ * @param {{runId: string, repoRoot: string, writeRow?: (row: Record<string, any>) => Promise<unknown>, probe?: import('../state/run.mjs').StartTimeProbe, expectPid?: number, add?: boolean}} opts
  */
-export async function repinWorker({ runId, repoRoot, writeRow, probe, expectPid }) {
-  const live = liveWorker(repoRoot);
+export async function repinWorker({ runId, repoRoot, writeRow, probe, expectPid, add = false }) {
+  const live = (expectPid === undefined ? null : liveWorker(repoRoot, { pid: expectPid, registeredOnly: true })) ?? liveWorker(repoRoot);
   if (!live) throw new WorkerError('worker_down', 'no live worker serves this queue');
   if (live.run !== runId) throw new WorkerError('other-run', `the live worker serves run ${live.run}`);
   if (expectPid !== undefined && live.pid !== expectPid) {
@@ -855,7 +860,7 @@ export async function repinWorker({ runId, repoRoot, writeRow, probe, expectPid
   }
   const { project } = await readRun(runId);
   const write = writeRow ?? ((/** @type {Record<string, any>} */ row) => appendRow(row, { slug: project }));
-  return reattachWorker({ runId, workerPid: live.pid, writeRow: write, ...(probe ? { probe } : {}) });
+  return reattachWorker({ runId, workerPid: live.pid, writeRow: write, add, ...(probe ? { probe } : {}) });
 }
 
 /** The CLI entry the worker is launched from. */
@@ -887,5 +892,9 @@ export async function launchWorker({ runId, workspace, env = process.env, timeou
       // already gone
     }
   }
+  const other = liveWorker(repoRoot);
+  if (other && other.run !== runId) {
+    throw new WorkerError('worker_down', `the worker did not start: run ${other.run} still has a live worker (pid ${other.pid}); end it with: code-forge run end --run ${other.run}`);
+  }
   throw new WorkerError('worker_down', 'the worker did not start (run `code-forge worker --run <id>` by hand to see why)');
 }

package/src/worker/queue.mjs

@@ -516,11 +516,14 @@ export function readTicket(repoRoot, id) {
  * @returns {Record<string, any>} the signed result
  */
 export function writeResult({ repoRoot, runId, ticket, result, key }) {
-  const signed = signRow({ ...result, run: runId, ticket: assertTicketId(ticket) }, key);
+  const split = result.status === 'split_required' || (result.status === 'stopped' && result.stopped === 'split_required');
+  // The engine's depth identifies the round-1 packet; rechecks always use the recheck lens.
+  const measured = split ? { budget: result.budget ?? null, lens: result.lens ?? (result.status === 'stopped' ? 'recheck' : result.depth === 'quick' ? 'quick' : result.depth === 'dual' ? 'A' : 'full') } : {};
+  const signed = signRow({ ...result, ...measured, run: runId, ticket: assertTicketId(ticket) }, key);
   const file = path.join(reviewsDir(repoRoot, runId), `${ticket}.json`);
   writeAtomic(file, `${JSON.stringify(signed)}\n`);
   const openFindings = signed.status === 'reviewed' && signed.approved !== true && Array.isArray(signed.findings) && signed.findings.length > 0;
-  writeAtomic(path.join(queueDir(repoRoot), `${ticket}.done`), `${JSON.stringify({ ticket, status: signed.status, ...(openFindings ? { open_findings: true } : {}), result: path.relative(repoRoot, file) })}\n`);
+  writeAtomic(path.join(queueDir(repoRoot), `${ticket}.done`), `${JSON.stringify({ ticket, status: signed.status, ...measured, ...(openFindings ? { open_findings: true } : {}), result: path.relative(repoRoot, file) })}\n`);
   return signed;
 }