faberun 0.21.0 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberun",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Faberun is a development orchestration system that turns intent into verified software: harness- and model-agnostic, it keeps the intent, coordinates the work, verifies the result and decides what happens next.",
   "type": "module",
   "bin": {

package/skills/faberun/references/operations.md

@@ -45,22 +45,22 @@ attempt's sealed sha, the same continuation rule as any other retry.
 One controller drives a run, holding `<run-dir>/controller.lock`: `{pid,
 processStartToken, startedAt, hostname}`. Acquisition is an exclusive create
 with no TTL. A contender treats the lock as stale only once it can prove the
-holder dead — the pid is gone, or its process start token no longer matches
-(pid recycled); anything less is `controller_active` and it exits untouched.
-Takeover renames the lock aside, re-checks the captured record is stale, then
-installs its own; a capture that turns out live is handed back. Worker/judge/
+holder dead — pid gone, or its start token no longer matches (pid recycled);
+otherwise it exits `controller_active`, untouched. Takeover renames the lock
+aside and re-checks it is stale before installing its own. Worker/judge/
 verification children run detached in their own process group, so before
 dispatching new work `resume`'s recovery pass terminates (`SIGTERM` then
 `SIGKILL`, same as `cancel`) every invocation recorded for a `running` node —
 unless it is still inside its deadline, when it is adopted and its result read.
-`cancel <run-dir>` signals a live controller first, so its own takeover never
-waits on an expiry.
+`cancel` signals a live controller first, so its takeover never waits.
 
 `supervise <run-dir> [--detach] [--interval <sec>]` is the watchdog above that.
 It holds no lock and writes no state: every interval (default 30s) it launches
 `resume --detach` when a node is unfinished and no controller is live, exits 0
 once all are terminal, and stops after three failed launches. An empty run
-directory is never resumed — it has not proved it needs to be.
+directory is never resumed. A detached controller outlives its launcher,
+not the session scope (cgroup) holding it: run long work under `tmux`,
+`systemd-run` or the seat.
 
 ## Runtime discovery
 

package/src/campaign/chain.mjs

@@ -42,6 +42,7 @@ import { pidAlive, processStartToken } from "../run/lock.mjs";
 import { delay, errorCode, errorMessage } from "../util.mjs";
 import { writeJsonAtomic } from "../run/store.mjs";
 import { runDirectory } from "../run/paths.mjs";
+import { listNodeSnapshots, readNodeSnapshot } from "../run/node-store.mjs";
 import { gitArguments, killTarget } from "../host/platform.mjs";
 
 /** @typedef {import("../contract/index.mjs").ControllerIdentity} ControllerIdentity */
@@ -561,12 +562,14 @@ export async function driveCampaignChain(campaignPath, options = {}) {
       try {
         await launch(entry.path, { baseRef, controllerIdentity, runDir, contract });
       } catch (error) {
+        const stranded = strandedRunNote(runDir);
         return park({
           code: errorCode(error) ?? "launch_failed",
-          message: errorMessage(error),
+          message: stranded ? `${errorMessage(error)}; ${stranded}` : errorMessage(error),
           contractPath: entry.path,
           contractId: id,
           runId: id,
+          ...(stranded ? { resume: `resume ${runDir}` } : {}),
         });
       }
       heartbeat.progress();
@@ -578,3 +581,29 @@ export async function driveCampaignChain(campaignPath, options = {}) {
     if (acquired) releaseCoordinatorLock(campaignPath, acquired.lock);
   }
 }
+
+/**
+ * What a launch that died before readiness left on disk. RM-053, measured on
+ * `rec-audit-remediation`: the controller died with the launcher's cgroup,
+ * the park said only `detached bootstrap did not become ready`, and the run
+ * directory it left, every node pending, finished under a durable `resume`.
+ *
+ * @param {string} runDir
+ * @returns {string|null}
+ */
+function strandedRunNote(runDir) {
+  if (!runDir || !existsSync(runDir)) return null;
+  /** @type {Map<string, number>} */
+  const counts = new Map();
+  for (const name of listNodeSnapshots(runDir)) {
+    let status = "unreadable";
+    try {
+      status = String(/** @type {{status?: unknown}} */ (readNodeSnapshot(runDir, name.replace(/\.json$/u, ""))).status ?? "unknown");
+    } catch {
+      // A snapshot caught mid-write is counted as unreadable, not dropped.
+    }
+    counts.set(status, (counts.get(status) ?? 0) + 1);
+  }
+  const nodes = [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([status, count]) => `${count} ${status}`).join(" · ");
+  return `run directory ${runDir} exists (nodes: ${nodes || "none written yet"}); \`faberun resume ${runDir}\` completes it, under tmux, systemd-run or faberun seat so it outlives this shell`;
+}

package/src/contract/index.mjs

@@ -13,9 +13,9 @@ import { DISCOVERY_RUNTIME_DEFINITIONS } from "../engine/runtime-discovery.mjs";
 import { stableJson } from "../util.mjs";
 import { assertObject, boundedString, nonNegativeInteger, nonNegativeNumber, positiveInteger, positiveNumber, rejectUnknown, requireId, requireString } from "./assert.mjs";
 import { validateMetadata } from "./schema-version.mjs";
-import { assertRuntimeExecutesCommands, requireRuntime, validateRuntime } from "./runtime.mjs";
+import { assertRuntimeExecutesCommands, judgeWriteWarnings, requireRuntime, validateRuntime } from "./runtime.mjs";
 import { validateSourceIdentity } from "../repo/source-identity.mjs";
-import { commandCoverageWarnings, mirrorCoverageWarnings, unsnapshottedWriteWarnings } from "../repo/declared-paths.mjs";
+import { commandCoverageWarnings, ignoreSourceWriteWarnings, mirrorCoverageWarnings, unsnapshottedWriteWarnings } from "../repo/declared-paths.mjs";
 import { crossNodeScopeFindings, scopeClosureFindings } from "../repo/scope-closure.mjs";
 
 export { CONTRACT_VERSION, PROTOCOL_SCHEMA_VERSION } from "../harnesses/index.mjs";
@@ -98,7 +98,7 @@ const GATE_REVIEWS = new Set(["none", "advisory", "blocking"]);
 /** @typedef {{history: RoutingHistoryEntry[], currentOverride: RoutingOverride|null, assignments?: RuntimeAssignments, availability?: Record<string, RuntimeAvailability>, tierExhaustion?: TierExhaustion, tierExhaustionCycle?: number}} RoutingState */
 /** @typedef {{revision?: number, heartbeatCount: number, dryHeartbeatCount: number, progressSignature?: string|null, lastHeartbeatAt: string|null, lastProgressAt: string|null, nextCheckAt?: string|null}} ProgressState */
 /** @typedef {{status: "unassigned"|"provisioning"|"ready"|"failed"|"removed", path: string|null, branch: string|null, commit: string|null, baseSha?: string|null, sealedSha?: string|null, sealError?: string|null, previousAttempt?: number|null}} WorktreeState */
-/** @typedef {{schemaVersion: number, contractVersion: string, id: string, type: string, sourceIdentity: SourceIdentity, packetHash: string, requirementIds?: string[], status: NodeStatus, phase: NodePhase, attempt: number, revisions: number, judgeFailures?: number, review?: ("none"|"advisory"|"blocking"), runtime: RuntimeSnapshot|null, blockedBy: string[], startedAt: string|null, updatedAt: string, result: unknown, gate: GateResult|null, error: SnapshotError|null, usage?: Usage, costUsd?: number, routing?: RoutingState|null, progress?: ProgressState|null, worktree?: WorktreeState|null, integratedHead?: string|null, invocations?: Invocation[], executionOverrides?: ExecutionOverride[], verification?: VerificationState|null, scope?: BoundedScope|null, scopeFindings?: ScopeFindings|null, previousAttempt?: string, sessionPolicy?: {forceFresh?: boolean}|null, declaredReadBytes?: number|null}} NodeSnapshot */
+/** @typedef {{schemaVersion: number, contractVersion: string, id: string, type: string, sourceIdentity: SourceIdentity, packetHash: string, requirementIds?: string[], status: NodeStatus, phase: NodePhase, attempt: number, revisions: number, judgeFailures?: number, review?: ("none"|"advisory"|"blocking"), runtime: RuntimeSnapshot|null, blockedBy: string[], startedAt: string|null, updatedAt: string, result: unknown, gate: GateResult|null, error: SnapshotError|null, usage?: Usage, costUsd?: number, routing?: RoutingState|null, progress?: ProgressState|null, worktree?: WorktreeState|null, integratedHead?: string|null, invocations?: Invocation[], executionOverrides?: ExecutionOverride[], verification?: VerificationState|null, scope?: BoundedScope|null, scopeFindings?: ScopeFindings|null, verificationArtifacts?: string[], previousAttempt?: string, sessionPolicy?: {forceFresh?: boolean}|null, declaredReadBytes?: number|null}} NodeSnapshot */
 /** @typedef {{path: string, sha: string}} ControllerIdentity */
 /** @typedef {{schemaVersion: number, contractVersion: string, pid: number, processStartToken: string|null, startedAt: string, sourceIdentity: SourceIdentity, controllerIdentity?: ControllerIdentity, integrationRef?: string, identityWarnings?: string[], relaunchCount?: number, lastRelaunchProgressAt?: string|null, attention?: {code: string, message: string, at: string}|null, contractDigest?: string, scopeDecision?: ScopeDecision, autoRetries?: Record<string, {code: string, at: string}>}} RunMetadata */
 /** @typedef {{at: string, base: string|null, dirtyTreeFingerprint: string|null}} ScopeDecision */
@@ -380,8 +380,10 @@ export function validateContract(raw, contractPath, options = {}) {
       ...unquotedFilterValueWarnings(node.definitionOfDone ?? [], index),
       ...(persisted ? [] : mirrorCoverageWarnings(node, index, cwd, contractCommands, contractWrites)),
       ...(persisted ? [] : unsnapshottedWriteWarnings(node, index, cwd)),
+      ...(persisted ? [] : ignoreSourceWriteWarnings(node, index)),
       ...(persisted ? [] : writeFileLineBudgetWarnings(node, index, cwd)),
     ]),
+    ...judgeWriteWarnings(runtimes, defaults, nodes),
     // Cross-node by construction: a requirement proven in two nodes is only
     // visible when every node's commands are read together, which is the
     // whole point -- one copy repaired and six left behind is what a per-node

package/src/contract/runtime.mjs

@@ -11,7 +11,7 @@
  */
 import { assertObject, nonNegativeNumber, positiveInteger, positiveNumber, rejectUnknown, requireId, requireString, requireStringArray, requireTimestamp } from "./assert.mjs";
 import { composeAssignments } from "../engine/runtime-discovery.mjs";
-import { harnessCapabilities, resolvePermissionExecution, resolveVendor, validateCapabilityRequirements } from "../harnesses/index.mjs";
+import { harnessCapabilities, resolvePermissionExecution, resolveVendor, validateCapabilityRequirements, writesWorkspace } from "../harnesses/index.mjs";
 import { stableJson } from "../util.mjs";
 /** @typedef {import("./index.mjs").NodeStatus} NodeStatus */
 /** @typedef {import("../engine/runtime-discovery.mjs").RuntimeAvailability} RuntimeAvailability */
@@ -212,6 +212,27 @@ export function assertRuntimeExecutesCommands(runtimes, runtimeId, index, nodeId
     `nodes[${index}] (${nodeId}) has verification but ${label} ${runtimeId} uses ${execution.field}=${execution.mode}; ${runtime.harness} executes commands only in ${execution.executingModes.join(", ")}`,
   );
 }
+/**
+ * A judge runtime that declares a writing mode its harness offers a read-only
+ * alternative to. The verdict reaches the gate without a write (RM-058), and
+ * `judge_protocol` blocks a judge that writes anyway, so the grant buys
+ * nothing but the chance to write where the judge should not.
+ *
+ * @param {Record<string, ValidatedRuntime>} runtimes
+ * @param {{judge?: string}} defaults
+ * @param {{gate?: {runtime?: string}|false|null}[]} nodes
+ * @returns {string[]}
+ */
+export function judgeWriteWarnings(runtimes, defaults, nodes) {
+  const judges = new Set([defaults.judge, ...nodes.map((node) => (node.gate ? node.gate.runtime : undefined))].filter((id) => typeof id === "string"));
+  return [...judges].flatMap((id) => {
+    const runtime = runtimes[/** @type {string} */ (id)];
+    const execution = resolvePermissionExecution(runtime);
+    if (!execution.field || runtime[execution.field] === undefined || !writesWorkspace(runtime)) return [];
+    if (writesWorkspace({ ...runtime, [execution.field]: "read-only" })) return [];
+    return [`judge runtime ${id} declares ${execution.field} ${execution.mode}; a judge's verdict reaches the gate without writing, so declare ${execution.field} read-only`];
+  });
+}
 /**
  * @param {unknown} value
  * @param {string} label

package/src/contract/scope-findings.mjs

@@ -35,6 +35,18 @@ export function scopeFindingsNote(scopeFindings) {
   return `scope: ${count} unexpected path${count === 1 ? "" : "s"}`;
 }
 
+/**
+ * The `verification_artifact` finding: paths the controller's verification
+ * left untracked, which the seal kept out of the integration.
+ *
+ * @param {string[]|null|undefined} paths
+ * @returns {string|null}
+ */
+export function verificationArtifactsNote(paths) {
+  if (!paths?.length) return null;
+  return `verification_artifact: ${paths.length} path${paths.length === 1 ? "" : "s"} left unsealed (${paths.slice(0, 3).join(", ")})`;
+}
+
 /**
  * @param {{unexpectedPaths: string[]}|null|undefined} scopeFindings
  * @returns {string}

package/src/contract/snapshot.mjs

@@ -129,7 +129,7 @@ export function validateNodeSnapshot(value, expectedNode = null) {
     "schemaVersion", "contractVersion", "id", "type", "sourceIdentity", "packetHash", "status", "phase",
     "attempt", "revisions", "judgeFailures", "requirementIds", "runtime", "blockedBy", "startedAt", "updatedAt", "result", "gate", "error", "usage",
     "costUsd", "routing", "progress", "worktree", "invocations", "executionOverrides", "verification", "scope",
-    "scopeFindings", "review", "previousAttempt", "sessionPolicy", "integratedHead", "declaredReadBytes",
+    "scopeFindings", "verificationArtifacts", "review", "previousAttempt", "sessionPolicy", "integratedHead", "declaredReadBytes",
   ]), "node snapshot");
   validateMetadata(value, "node snapshot");
   requireId(value.id, "node snapshot.id");
@@ -184,6 +184,7 @@ export function validateNodeSnapshot(value, expectedNode = null) {
   if (value.verification !== undefined && value.verification !== null) validateVerificationSnapshot(value.verification);
   if (value.scope !== undefined && value.scope !== null) validateScopeSnapshot(value.scope);
   if (value.scopeFindings !== undefined && value.scopeFindings !== null) validateScopeFindings(value.scopeFindings);
+  if (value.verificationArtifacts !== undefined) validatePathList(value.verificationArtifacts, "node snapshot.verificationArtifacts");
   // The session policy a rejection decision leaves for the dispatch that will
   // run the retry. It is persisted because the decision can hand the node back
   // to the scheduler, whose own `startWorker` call carries no argument; without
@@ -611,12 +612,22 @@ function validateScopeSnapshot(value) {
 function validateScopeFindings(value) {
   assertObject(value, "node snapshot.scopeFindings");
   rejectUnknown(value, new Set(["unexpectedPaths"]), "node snapshot.scopeFindings");
-  const paths = /** @type {unknown[]} */ (value.unexpectedPaths);
-  if (!Array.isArray(value.unexpectedPaths) || paths.length > MAX_SCOPE_FINDING_PATHS || paths.some((path) => typeof path !== "string")) {
-    throw new TypeError("node snapshot.scopeFindings.unexpectedPaths is invalid");
+  validatePathList(value.unexpectedPaths, "node snapshot.scopeFindings.unexpectedPaths");
+}
+/**
+ * A bounded list of workspace paths: the shape of a scope finding and of the
+ * paths a verification left behind (`verificationArtifacts`).
+ *
+ * @param {unknown} value
+ * @param {string} label
+ */
+function validatePathList(value, label) {
+  const paths = /** @type {unknown[]} */ (value);
+  if (!Array.isArray(value) || paths.length > MAX_SCOPE_FINDING_PATHS || paths.some((path) => typeof path !== "string")) {
+    throw new TypeError(`${label} is invalid`);
   }
   if (paths.some((path) => Buffer.byteLength(/** @type {string} */ (path), "utf8") > 1024)) {
-    throw new TypeError("node snapshot.scopeFindings.unexpectedPaths contains an oversized path");
+    throw new TypeError(`${label} contains an oversized path`);
   }
 }
 /**

package/src/engine/dispatch.mjs

@@ -34,7 +34,7 @@ import { invocationCost, invocationUsage } from "../run/usage.mjs";
 import { logPaths, startProcess } from "./process.mjs";
 import { readBoundedTail } from "./transcript.mjs";
 import { mkdirSync, statSync } from "node:fs";
-import { READ_BYTE_LIMIT, READ_LINE_LIMIT, harnessCapabilities, normalizeProviderResult } from "../harnesses/index.mjs";
+import { READ_BYTE_LIMIT, READ_LINE_LIMIT, harnessCapabilities, normalizeProviderResult, writesWorkspace } from "../harnesses/index.mjs";
 import { writeJsonAtomic } from "../run/store.mjs";
 import { judgeReaskInstruction, reviewMode } from "../contract/review-modes.mjs";
 import { routeRuntimeForState, runtimeSnapshot } from "./failover.mjs";
@@ -194,6 +194,7 @@ function sealPreviousAttempt(contract, node, state) {
     runId: contract.id,
     nodeId: node.id,
     attempt,
+    exclude: state.verificationArtifacts,
   });
   return sealed.empty ? null : { sha: sealed.sha, attempt };
 }
@@ -269,7 +270,7 @@ export function startWorker(contract, node, state, runDir, running, prompt, lock
   // make sure the directory exists before the provider is asked to.
   const resultPath = attemptWorkerResultPath(runDir, node.id, workspace);
   mkdirSync(dirname(resultPath), { recursive: true });
-  const effectivePrompt = workerProtocolPrompt(phasePlan.prompt, resultPath);
+  const effectivePrompt = workerProtocolPrompt(phasePlan.prompt, resultPath, writesWorkspace(runtime));
   const paths = logPaths(runDir, node.id, "worker", state.attempt);
   if (Buffer.byteLength(effectivePrompt, "utf8") > 64 * 1024) {
     transition(runDir, state, "failed", { phase: "worker", error: { code: "worker_prompt_too_large", message: "worker prompt exceeds 65536 bytes" } }, lock);
@@ -390,8 +391,9 @@ export function startResultMaterialization(contract, node, state, runDir, runnin
   const resultPath = attemptWorkerResultPath(runDir, node.id, workspace);
   const prompt = appendSandboxNotice([
     `${RESULT_MATERIALIZATION_PROMPT_HEADER} Do not inspect, implement, verify, or invoke tools.`,
-    `Your only job in this single bounded turn is to write the required worker-result JSON object to: ${resultPath}`,
-    "Then return that same JSON object as the final message.",
+    ...(writesWorkspace(materializationRuntime)
+      ? [`Your only job in this single bounded turn is to write the required worker-result JSON object to: ${resultPath}`, "Then return that same JSON object as the final message."]
+      : ["Your sandbox is read-only, so write no file: your only job in this single bounded turn is to return the required worker-result JSON object as the final message."]),
   ].join("\n\n"), materializationRuntime);
   let baseline;
   try {

package/src/engine/process.mjs

@@ -396,6 +396,7 @@ export async function sealBeforeTerminate(job, timeout) {
       runId: job.contract.id,
       nodeId: job.node.id,
       attempt: job.state.attempt,
+      exclude: job.state.verificationArtifacts,
     });
     job.state.worktree = {
       ...job.state.worktree,

package/src/engine/result-file.mjs

@@ -143,11 +143,23 @@ export function resolveWorkerResult(runDir, node, providerResult) {
   return result;
 }
 /**
+ * A runtime that cannot write (`writable` false) is told its final message is
+ * the result, and `resolveWorkerResult` persists it: asking it to write the
+ * file is what stalled a read-only reviewer (RM-058).
+ *
  * @param {string} prompt
  * @param {string} resultPath
+ * @param {boolean} [writable]
  * @returns {string}
  */
-export function workerProtocolPrompt(prompt, resultPath) {
+export function workerProtocolPrompt(prompt, resultPath, writable = true) {
+  if (!writable) {
+    return [
+      prompt,
+      "Controller worker protocol:",
+      "Your sandbox is read-only, so write no file: your final response is the result, exactly the required worker-result JSON object, and the controller persists it.",
+    ].join("\n\n");
+  }
   return [
     prompt,
     "Controller worker protocol:",

package/src/engine/settle.mjs

@@ -166,6 +166,7 @@ export async function settleDone(contract, node, state, runDir, lock, states, ca
       runId: contract.id,
       nodeId: node.id,
       attempt: state.attempt,
+      exclude: state.verificationArtifacts,
     });
     state.worktree = { ...state.worktree, commit: sealed.sha, status: "ready" };
     writeNode(runDir, state, lock);

package/src/engine/verify.mjs

@@ -8,9 +8,10 @@
  * catch. `recoverVerificationAttempts` reads back what a crashed controller had
  * already proved, so a resume does not pay for the same suite twice.
  */
-import { attemptWorkspace } from "../repo/worktree.mjs";
+import { attemptWorkspace, untrackedPaths } from "../repo/worktree.mjs";
 import { boundedUtf8, errorMessage } from "../util.mjs";
 import { compactVerification } from "../contract/verification.mjs";
+import { MAX_SCOPE_FINDING_PATHS } from "../contract/scope-findings.mjs";
 import { finalVerificationCommands, phaseTerminalNode, sharedVerificationCommands } from "../contract/final-verification.mjs";
 import { join } from "node:path";
 import { listNodeSnapshots, readNodeSnapshot } from "../run/node-store.mjs";
@@ -137,7 +138,11 @@ export async function executeControllerVerification(contract, runDir, node, stat
     attempts: [...(state.verification?.attempts ?? [])],
   };
   writeNode(runDir, state, lock);
-  const workspace = attemptWorkspace(state) ?? contract.cwd;
+  const attempt = attemptWorkspace(state);
+  const workspace = attempt ?? contract.cwd;
+  // The mark between "worker finished" and "verification ran": what was
+  // already untracked is the worker's, what appears after is the suite's.
+  const untrackedBefore = attempt ? new Set(untrackedPaths(attempt)) : null;
   const commands = [...node.taskPacket.verification, ...sharedVerificationCommands(contract), ...finalVerificationCommands(contract, node, settledSiblingIds(runDir, contract, node))];
   /** @param {VerificationAttempt} attempt @returns {VerificationProgress} */
   const progressFor = (attempt) => verificationProgress(attempt.commandIndex + 1, commands.length, /** @type {VerificationCommand|undefined} */ (commands[attempt.commandIndex])?.argv);
@@ -169,9 +174,39 @@ export async function executeControllerVerification(contract, runDir, node, stat
       attempts: verificationAttemptRecords(state),
     };
   }
+  if (attempt && untrackedBefore) {
+    const artifacts = verificationArtifacts(node, state, untrackedBefore, untrackedPaths(attempt));
+    if (artifacts.length) state.verificationArtifacts = artifacts;
+    else delete state.verificationArtifacts;
+  }
   writeNode(runDir, state, lock);
   return state.verification;
 }
+
+/**
+ * RM-052, measured on `rec-audit-remediation`: the target's suite wrote
+ * `rec-wav-test-<pid>.*` into its working directory, and 14 of them crossed
+ * the seal into the remediation branch. A path the verification leaves
+ * untracked, outside the packet's declared writes, is recorded here and kept
+ * out of the seal. An earlier pass's artifact stays recorded while it is
+ * still on disk, since the next pass sees it as already there. Bounded like
+ * scope findings; an artifact past the bound would still be sealed.
+ *
+ * @param {ValidatedNode} node
+ * @param {NodeSnapshot} state
+ * @param {Set<string>} before
+ * @param {string[]} after
+ * @returns {string[]}
+ */
+function verificationArtifacts(node, state, before, after) {
+  const files = new Set(node.taskPacket.writeFiles ?? []);
+  const roots = (node.taskPacket.writeRoots ?? []).map((root) => root.replace(/\/+$/u, ""));
+  const previous = new Set(state.verificationArtifacts ?? []);
+  return after
+    .filter((path) => !before.has(path) || previous.has(path))
+    .filter((path) => !files.has(path) && !roots.some((root) => path === root || path.startsWith(`${root}/`)))
+    .slice(0, MAX_SCOPE_FINDING_PATHS);
+}
 /**
  * @param {string} runDir
  * @param {NodeSnapshot} state

package/src/harnesses/codex/index.mjs

@@ -51,6 +51,7 @@ export const codexHarness = {
     field: "sandbox",
     executingModes: ["read-only", "workspace-write", "danger-full-access"],
     defaultMode: "workspace-write",
+    readOnlyModes: ["read-only"],
   },
 
   /** @param {import("../index.mjs").HarnessRuntime} runtime @returns {string} */

package/src/harnesses/index.mjs

@@ -55,7 +55,10 @@ const CAPABILITY_NAMES = new Set([
  * the value used when the contract omits that field. `null` means the harness
  * has no permission mode that can deny command execution.
  *
- * @typedef {{field: "permissionMode"|"sandbox", executingModes: string[], defaultMode: string}|null} PermissionExecutionPolicy
+ * `readOnlyModes` names the modes in which the provider cannot write its
+ * workspace, so the controller must not ask it to.
+ *
+ * @typedef {{field: "permissionMode"|"sandbox", executingModes: string[], defaultMode: string, readOnlyModes?: string[]}|null} PermissionExecutionPolicy
  */
 
 /** @typedef {{status: "done"|"no-op"|"blocked"|"failed"|"exhausted"|"stalled"|"canceled", result: string|null, continuationId: string|null, usage: {inputTokens: number|null, outputTokens: number|null, cacheReadInputTokens: number|null}, costUsd: number|null, error: {code: string, message: string, resetAt?: string|null}|null, exhaustedUntil?: string|null, judgeCandidates?: number}} ProviderEnvelope */
@@ -154,6 +157,20 @@ export function resolvePermissionExecution(runtime) {
   return { executes: policy.executingModes.includes(mode), field: policy.field, mode, executingModes: policy.executingModes };
 }
 
+/**
+ * Whether a runtime can write its workspace. False only in a mode its adapter
+ * declares read-only; RM-058 measured a codex reviewer under `read-only`
+ * whose result-file write was rejected and which then stalled for 300s.
+ *
+ * @param {{harness: string, permissionMode?: string, sandbox?: string}} runtime
+ * @returns {boolean}
+ */
+export function writesWorkspace(runtime) {
+  const policy = getHarness(runtime.harness).permissionExecution;
+  if (!policy?.readOnlyModes) return true;
+  return !policy.readOnlyModes.includes(/** @type {string} */ (runtime[policy.field] ?? policy.defaultMode));
+}
+
 /**
  * The vendor a harness talks to when no provider configuration says
  * otherwise. `replay` and `exec-jsonl` stand in for whatever the recording or

package/src/plan/freeze.mjs

@@ -19,6 +19,7 @@ import { fileURLToPath } from "node:url";
 import { CONTRACT_VERSION, PROTOCOL_SCHEMA_VERSION, contractDigest, validateContract } from "../contract/index.mjs";
 import { assertObject, rejectUnknown, requirePacketHash, requireString } from "../contract/assert.mjs";
 import { writeJsonAtomic, writeTextAtomic } from "../run/store.mjs";
+import { VERIFICATION_LIMITS } from "../contract/verification.mjs";
 import { validatePlanPhases } from "./template.mjs";
 
 /** @typedef {import("../contract/index.mjs").JsonObject} JsonObject */
@@ -31,9 +32,108 @@ import { validatePlanPhases } from "./template.mjs";
 /** @typedef {{path: string, digest: string}} PlanSpecIdentity */
 /** @typedef {{formatVersion: number, contractDigest: string, spec?: PlanSpecIdentity, phases?: PlanPhase[], provenance: PlanProvenance}} FrozenPlan */
 /** @typedef {{ok: boolean, digest: string, expectedDigest: string}} FrozenPlanVerdict */
+/** @typedef {{scripts?: Record<string, string>, verificationCandidates: {argv: string[], measuredMs: number}[]}} MeasuredFacts */
 
 const PLAN_FORMAT_VERSION = 1;
 
+/**
+ * The margin a frozen verification timeout keeps over its measured duration.
+ * No measurement behind the number itself: it is the spec's (RM-057), and a
+ * timeout only bounds a failure, so a passing command never waits for it.
+ */
+const MEASURED_TIMEOUT_MARGIN = 1.5;
+
+/** `node --test` options that run a subset of the files they name. */
+const FILTER_OPTIONS = ["--test-name-pattern", "--test-skip-pattern", "--test-only", "--test-shard"];
+
+/** `node` options whose value is the next argument, so it is not a path. */
+const NODE_VALUE_OPTIONS = new Set(["--import", "--require", "-r", "--loader", "--experimental-loader", "--env-file", "--test-reporter", "--test-reporter-destination", "--test-name-pattern", "--test-skip-pattern", "--test-concurrency", "--test-timeout"]);
+
+/**
+ * The `node --test <dir>` candidates one path argument includes: a directory
+ * includes itself and everything below it, and a glob includes the
+ * directories below its literal prefix only when it descends (`test/*` +
+ * `/…`); `test/*.test.mjs` names top-level files no candidate measured.
+ *
+ * @param {string} arg
+ * @param {string[]} directories
+ * @returns {string[]}
+ */
+function includedDirectories(arg, directories) {
+  const path = arg.replace(/^\.\//u, "").replace(/\/+$/u, "");
+  const wildcard = path.search(/[*?[]/u);
+  if (wildcard < 0) return directories.filter((directory) => directory === path || directory.startsWith(`${path}/`));
+  const base = path.slice(0, path.lastIndexOf("/", wildcard));
+  if (!path.slice(wildcard).includes("/")) return [];
+  return directories.filter((directory) => base === "" || directory.startsWith(`${base}/`));
+}
+
+/**
+ * What repo facts measured for a verification command: its own candidate, or
+ * the sum of the `node --test <dir>` candidates it includes, `npm test`
+ * resolved through the `test` script. A lower bound when the command also
+ * runs files no candidate measured; null when it includes nothing measured.
+ *
+ * @param {string[]} argv
+ * @param {MeasuredFacts} facts
+ * @returns {number|null}
+ */
+function measuredMsFor(argv, facts) {
+  const candidates = facts.verificationCandidates;
+  const exact = candidates.find((candidate) => candidate.argv.join(" ") === argv.join(" "));
+  if (exact) return exact.measuredMs;
+  const npmTest = argv[0] === "npm" && ["test", "run test"].includes(argv.slice(1).join(" "));
+  if (npmTest && typeof facts.scripts?.test === "string") return measuredMsFor(facts.scripts.test.trim().split(/\s+/u), facts);
+  if (argv[0] !== "node" || argv[1] !== "--test") return null;
+  // A filtered run measures nothing a directory candidate measured.
+  if (argv.some((arg) => FILTER_OPTIONS.some((option) => arg === option || arg.startsWith(`${option}=`)))) return null;
+  const measured = new Map(candidates
+    .filter((candidate) => candidate.argv.length === 3 && candidate.argv[0] === "node" && candidate.argv[1] === "--test")
+    .map((candidate) => [candidate.argv[2].replace(/\/+$/u, ""), candidate.measuredMs]));
+  /** @type {string[]} */
+  const paths = [];
+  for (let index = 2; index < argv.length; index += 1) {
+    if (NODE_VALUE_OPTIONS.has(argv[index])) index += 1;
+    else if (!argv[index].startsWith("-")) paths.push(argv[index]);
+  }
+  const included = new Set((paths.length ? paths : ["test"]).flatMap((path) => includedDirectories(path, [...measured.keys()])));
+  if (!included.size) return null;
+  return [...included].reduce((sum, directory) => sum + /** @type {number} */ (measured.get(directory)), 0);
+}
+
+/**
+ * Refuse a contract whose verification timeout sits under
+ * `MEASURED_TIMEOUT_MARGIN` times what repo facts measured for the command,
+ * and name a command no legal timeout can cover, so the plan is contested
+ * with the advice to split it. RM-057, measured on the Campaign Brief run:
+ * a gate frozen at 120s against parts measured at 178,904 ms and 246,955 ms.
+ *
+ * @param {import("../contract/index.mjs").ValidatedContract} contract
+ * @param {MeasuredFacts} facts
+ * @returns {void}
+ */
+export function assertTimeoutsCoverMeasured(contract, facts) {
+  const commands = [
+    ...contract.nodes.flatMap((node) => node.taskPacket.verification ?? []),
+    ...contract.sharedVerification ?? [],
+    ...contract.finalVerification ?? [],
+  ];
+  const problems = new Set();
+  for (const command of commands) {
+    const measuredMs = measuredMsFor(command.argv, facts);
+    if (measuredMs === null) continue;
+    const timeoutSec = command.timeoutSec ?? 120;
+    const requiredSec = Math.ceil((measuredMs * MEASURED_TIMEOUT_MARGIN) / 1_000);
+    const shown = `${command.argv.join(" ")} measured ${(measuredMs / 1_000).toFixed(1)}s`;
+    if (requiredSec > VERIFICATION_LIMITS.maxTimeoutSec) {
+      problems.add(`${shown}, and ${MEASURED_TIMEOUT_MARGIN} times that passes the ${VERIFICATION_LIMITS.maxTimeoutSec}s maxTimeoutSec: split it into commands that each fit`);
+    } else if (timeoutSec < requiredSec) {
+      problems.add(`verification ${command.argv.join(" ")} has timeoutSec ${timeoutSec}s, under ${MEASURED_TIMEOUT_MARGIN} times its measured ${(measuredMs / 1_000).toFixed(1)}s: raise it to at least ${requiredSec}s`);
+    }
+  }
+  if (problems.size) throw new TypeError(`verification timeouts do not cover their measured durations: ${[...problems].join("; ")}`);
+}
+
 /** @returns {string} the installed package's own version, read once per call so a freeze always names the toolchain that produced it */
 function packageVersion() {
   const packageJsonPath = fileURLToPath(new URL("../../package.json", import.meta.url));
@@ -175,10 +275,13 @@ export function writeFrozenPlanRecord(outDir, record) {
  * was planned from.
  *
  * @param {JsonObject} plan
- * @param {{outDir: string, provenance: PlanProvenanceInput, phases?: import("./template.mjs").PlanPhase[], spec?: PlanSpecIdentity}} options
+ * `options.facts` carries repo facts' measured durations; given, a
+ * verification timeout that does not cover one is refused.
+ *
+ * @param {{outDir: string, provenance: PlanProvenanceInput, phases?: import("./template.mjs").PlanPhase[], spec?: PlanSpecIdentity, facts?: MeasuredFacts}} options
  * @returns {FrozenPlan}
  */
-export function freezePlan(plan, { outDir, provenance, phases, spec }) {
+export function freezePlan(plan, { outDir, provenance, phases, spec, facts }) {
   // Shape-checked before anything is written, so a malformed declaration
   // leaves the outDir exactly as it was — the same failure discipline as the
   // validateContract rollback below. A declaration in the nodeIds shape must
@@ -199,7 +302,8 @@ export function freezePlan(plan, { outDir, provenance, phases, spec }) {
   });
   writeJsonAtomic(contractPath, raw);
   try {
-    validateContract(raw, contractPath);
+    const validated = validateContract(raw, contractPath);
+    if (facts) assertTimeoutsCoverMeasured(validated, facts);
   } catch (error) {
     rmSync(contractPath, { force: true });
     throw error;

package/src/plan/pipeline.mjs

@@ -30,7 +30,7 @@ import { collectRepoFacts } from "./repo-facts.mjs";
 import { RISK_TIERS, TASK_KIND_CATALOGUE_FILE, buildPlanningContract, renderTaskKindCatalogue, validateFindings, validatePlanOutput } from "./template.mjs";
 import { MIN_WRITE_FILES, applySizingRules, provenParallelism } from "./sizing.mjs";
 import { resolveRuntimes } from "./routing.mjs";
-import { contentDigest, freezePlan, writeFrozenPlanRecord } from "./freeze.mjs";
+import { assertTimeoutsCoverMeasured, contentDigest, freezePlan, writeFrozenPlanRecord } from "./freeze.mjs";
 import { availabilityOf, fileLineCount, highestOf, modelOf, toContractNode, toSizingNode } from "./pipeline-shape.mjs";
 import { campaignTree, runDirectory } from "../run/paths.mjs";
 
@@ -364,7 +364,7 @@ export async function runPlanningPipeline(options) {
       /** @type {PlanFindingOutput|null} */
       let freezeFailure = null;
       try {
-        validateContract(frozenContractRaw(assembleFrozenNodes(plan)), join(plansDir, "contract.json"));
+        assertTimeoutsCoverMeasured(validateContract(frozenContractRaw(assembleFrozenNodes(plan)), join(plansDir, "contract.json")), repoFacts);
       } catch (error) {
         freezeFailure = invalidPlanFinding(`freeze-r${round}`, error);
         findings = [...findings, freezeFailure];
@@ -457,6 +457,7 @@ export async function runPlanningPipeline(options) {
       // The pipeline's own pinned spec bytes: a wrong or missing digest is the
       // first thing the Campaign Brief refuses on, never a summary.
       spec: { path: relativeSpecPath, digest: specDigest },
+      facts: repoFacts,
       provenance: {
         targetGitHead: repoFacts.gitHead,
         planner: { runtimeId: runtimeDefaults.worker ?? "", model: modelOf(runtimes, runtimeDefaults.worker) },

package/src/repo/declared-paths.mjs

@@ -17,6 +17,7 @@ import { join, resolve } from "node:path";
 import { lstatSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { RUNS_DIR_NAME } from "../run/paths.mjs";
+import { isIgnoreSource } from "./workspace.mjs";
 
 /** @typedef {import("../contract/index.mjs").ValidatedNode} ValidatedNode */
 
@@ -49,6 +50,21 @@ export function unsnapshottedWriteWarnings(node, index, cwd) {
     `nodes[${index}] (${node.id}): ${path.includes("/") ? `${kind} under ${root}/` : `${kind} ${path}`} are outside the workspace snapshot, so the closed-scope gate cannot observe them`,
   );
 }
+/**
+ * `writes_ignore_source`: a declared write the workspace snapshot fingerprints
+ * as an ignore source. The node fails with `snapshot_ignore_changed` the
+ * moment the worker changes it, and two campaigns each lost a node learning
+ * that (RM-051), so the author hears it before dispatch.
+ *
+ * @param {ValidatedNode} node
+ * @param {number} index
+ * @returns {string[]}
+ */
+export function ignoreSourceWriteWarnings(node, index) {
+  const sources = (node.taskPacket.writeFiles ?? []).filter(isIgnoreSource);
+  if (!sources.length) return [];
+  return [`nodes[${index}] (${node.id}): writes_ignore_source: writeFiles ${sources.join(", ")} ${sources.length === 1 ? "is an ignore source" : "are ignore sources"} the workspace snapshot fingerprints; a worker that changes one fails the node with snapshot_ignore_changed, so make that edit outside the run`];
+}
 /**
  * @param {string|undefined} cwd
  * @param {string} declaredPath

package/src/repo/workspace.mjs

@@ -53,7 +53,7 @@ export function captureWorkspaceSnapshot(cwd, expectedIgnoreSources) {
   const root = realpathSync(cwd);
   const ignoreSources = captureIgnoreSources(root);
   if (expectedIgnoreSources !== undefined && !sameSnapshotEntries(expectedIgnoreSources, ignoreSources)) {
-    throw fail("snapshot_ignore_changed", "workspace ignore sources changed during worker execution");
+    throw ignoreSourcesChanged(expectedIgnoreSources, ignoreSources);
   }
   /** @type {SnapshotEntry[]} */
   const entries = [];
@@ -123,7 +123,7 @@ export function compareWorkspaceSnapshot(before, cwd, scope = {}) {
     });
   const after = captureWorkspaceSnapshot(cwd, before.ignoreSources);
   if (!sameSnapshotEntries(before.ignoreSources, after.ignoreSources)) {
-    throw fail("snapshot_ignore_changed", "workspace ignore sources changed during worker execution");
+    throw ignoreSourcesChanged(before.ignoreSources, after.ignoreSources);
   }
   const prior = new Map(before.entries.map((/** @type {SnapshotEntry} */ entry) => [entry.path, JSON.stringify(entry)]));
   const current = new Map(after.entries.map((/** @type {SnapshotEntry} */ entry) => [entry.path, JSON.stringify(entry)]));
@@ -262,6 +262,45 @@ export function validateWorkspaceScopeBoundary(cwd, boundary, declared = {}) {
     rootOrigins,
   };
 }
+/** Directories `captureIgnoreSources` skips at any depth. */
+const SKIPPED_SOURCE_DIRS = new Set([".git", RUNS_DIR_NAME, "node_modules", ".venv", "venv"]);
+
+/** The ignore sources `captureIgnoreSources` always fingerprints at the root. */
+const ROOT_IGNORE_SOURCES = [".faberunignore", ".gitignore", ".git/config"];
+
+/**
+ * Whether a workspace-relative path is one `captureIgnoreSources` fingerprints,
+ * so a worker that changes it fails its node with `snapshot_ignore_changed`.
+ * A `.gitignore` counts at any depth outside the directories the walk skips.
+ *
+ * @param {string} path
+ * @returns {boolean}
+ */
+export function isIgnoreSource(path) {
+  const normalized = path.replaceAll("\\", "/").replace(/^\.\//u, "");
+  if (ROOT_IGNORE_SOURCES.includes(normalized) || normalized === ".git/info/exclude" || normalized === ".git") return true;
+  const segments = normalized.split("/");
+  // The same directories `captureIgnoreSources` never walks.
+  if (segments.some((segment) => SKIPPED_SOURCE_DIRS.has(segment)) || [".claude", ".codex"].includes(segments[0])) return false;
+  return basename(normalized) === ".gitignore";
+}
+
+/**
+ * The `snapshot_ignore_changed` failure, naming every source that moved.
+ * Measured on `rec-audit-remediation`: the message named none, and the
+ * operator had to diff the worktree to learn it was one `.gitignore` line.
+ *
+ * @param {SnapshotEntry[]} before
+ * @param {SnapshotEntry[]} after
+ * @returns {Error}
+ */
+function ignoreSourcesChanged(before, after) {
+  const prior = new Map(before.map((entry) => [entry.path, JSON.stringify(entry)]));
+  const current = new Map(after.map((entry) => [entry.path, JSON.stringify(entry)]));
+  const changed = [...new Set([...prior.keys(), ...current.keys()])].filter((path) => prior.get(path) !== current.get(path)).sort();
+  return fail("snapshot_ignore_changed", `workspace ignore sources changed during worker execution: ${changed.join(", ")}`);
+}
+
 /**
  * Snapshot the files Git can use to hide workspace changes. These entries are
  * kept separate from the relevant-file entry cap. A worker cannot replace
@@ -273,7 +312,7 @@ export function validateWorkspaceScopeBoundary(cwd, boundary, declared = {}) {
  */
 function captureIgnoreSources(root) {
   /** @type {Set<string>} */
-  const paths = new Set([".faberunignore", ".gitignore", ".git/config"]);
+  const paths = new Set(ROOT_IGNORE_SOURCES);
   /** @type {Map<string, string>} */
   const gitPaths = new Map();
   /** @param {string} name @param {string} logical @returns {string|null} */

package/src/repo/worktree.mjs

@@ -322,10 +322,27 @@ function gitTracks(repo, read) {
 }
 
 /**
- * @param {{repo: string, path: string, baseSha: string|null, runId: string, nodeId: string, attempt: number}} args
+ * Every untracked, unignored path in a worktree, outside the runner's own
+ * `.runs` tree and the linked `node_modules`: the same exclusions the seal
+ * applies, so the two agree on what "left in the worktree" means.
+ *
+ * @param {string} path
+ * @returns {string[]}
+ */
+export function untrackedPaths(path) {
+  const listed = git(path, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ".", `:(exclude)${RUNS_DIR_NAME}`, ":(exclude)node_modules"]);
+  return listed.split("\0").filter((entry) => entry.startsWith("?? ")).map((entry) => entry.slice(3)).sort();
+}
+
+/**
+ * `exclude` names paths the attempt holds but must not seal: what the
+ * controller's own verification left behind (`verificationArtifacts`). They
+ * stay on disk and out of the commit.
+ *
+ * @param {{repo: string, path: string, baseSha: string|null, runId: string, nodeId: string, attempt: number, exclude?: string[]}} args
  * @returns {SealedAttempt}
  */
-export function sealAttempt({ repo, path, baseSha, runId, nodeId, attempt }) {
+export function sealAttempt({ repo, path, baseSha, runId, nodeId, attempt, exclude = [] }) {
   // The attempt-local `.runs` result sidecar must never enter the attempt
   // commit. Naming it through an exclude pathspec makes `git add` exit 1 with
   // advice.addIgnoredFile as soon as the sidecar exists in a repository that
@@ -345,6 +362,11 @@ export function sealAttempt({ repo, path, baseSha, runId, nodeId, attempt }) {
     // node_modules is linked into the worktree as a symlink, which `node_modules/`
     // in .gitignore does not match; never let the link into the attempt commit.
     runGit(["-C", path, "rm", "-r", "-q", "--cached", "--ignore-unmatch", "--", RUNS_DIR_NAME, "node_modules"]);
+    if (exclude.length) runGit(["-C", path, "rm", "-q", "--cached", "--ignore-unmatch", "--", ...exclude.map((item) => `:(literal)${item}`)]);
+  }
+  // A worktree whose only change was an excluded artifact stages nothing, and
+  // an empty commit exits 1; the attempt's head is then its seal.
+  if (dirty && !stagedNothing(path)) {
     runGit([
       "-C", path,
       "-c", "user.email=runner@example.test",
@@ -371,6 +393,16 @@ export function sealAttempt({ repo, path, baseSha, runId, nodeId, attempt }) {
   return { sha, empty };
 }
 
+/** @param {string} path @returns {boolean} */
+function stagedNothing(path) {
+  try {
+    runGit(["-C", path, "diff", "--cached", "--quiet"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /** @param {string} repo @param {string} base @param {string} head @returns {boolean} */
 export function gitDiffEmpty(repo, base, head) {
   try {

package/src/report/final.mjs

@@ -9,7 +9,7 @@
 import { compactCost, compactTokens, errorCode } from "../util.mjs";
 import { basename, join } from "node:path";
 import { readJson, writeJsonAtomic, writeTextAtomic } from "../run/store.mjs";
-import { scopeFindingsNote } from "../contract/scope-findings.mjs";
+import { scopeFindingsNote, verificationArtifactsNote } from "../contract/scope-findings.mjs";
 import { MARK, advisoryFindingCount, fit, judgeRuntimeLabel, roleCosts, roleUsage, statusNote, workerRuntimeLabel, writeStatusArtifacts } from "./render.mjs";
 import { packetRepetitionByNode, packetRepetitionNote } from "./packet-repetition.mjs";
 import { unlinkSync } from "node:fs";
@@ -131,9 +131,10 @@ export function renderFinalReport(runDir, contract, states) {
     const judge = judgeRuntimeLabel(node) ?? "-";
     const planNode = contract.nodes.find((candidate) => candidate.id === node.id);
     const detail = node.gate?.summary ?? node.error?.message ?? (node.blockedBy?.length ? node.blockedBy.join(", ") : null) ?? (typeof node.result === "string" && node.result.trim() ? node.result.trim() : node.phase ?? "-");
-    // The advisory scope finding leads the note, as it does in STATUS.md.
-    const note = scopeFindingsNote(node.scopeFindings)
-      ? `${scopeFindingsNote(node.scopeFindings)} · ${detail}`
+    // The advisory findings lead the note, as they do in STATUS.md.
+    const findings = [scopeFindingsNote(node.scopeFindings), verificationArtifactsNote(node.verificationArtifacts)].filter(Boolean).join(" · ");
+    const note = findings
+      ? `${findings} · ${detail}`
       : `${detail} · phase ${planNode?.phase ?? "-"} · ${node.invocations?.at(-1)?.continuationMode ?? "fresh"}`;
     lines.push(row([
       MARK[node.status] ?? "[?]",

package/src/report/render.mjs

@@ -3,7 +3,7 @@ import { basename, join } from "node:path";
 import { validateContract } from "../contract/index.mjs";
 import { readJson, writeJsonAtomic } from "../run/store.mjs";
 import { lockStale, pidAlive, readLock } from "../run/lock.mjs";
-import { scopeFindingsNote } from "../contract/scope-findings.mjs";
+import { scopeFindingsNote, verificationArtifactsNote } from "../contract/scope-findings.mjs";
 import { reviewNote } from "../contract/review-modes.mjs";
 import { validateNodeSnapshot, validateRunMetadata } from "../contract/snapshot.mjs";
 import { compactCost, compactTokens, truncateChars } from "../util.mjs";
@@ -32,7 +32,7 @@ const POINTER_ATTENTION_CHARS = 80;
 /** @typedef {{inputTokens: number|null, outputTokens: number|null, cacheReadInputTokens: number|null}} StatusPayloadUsage */
 /** @typedef {{index: number, total: number, argv: string}} VerificationProgress */
 /** @typedef {{verdict: string, maxSeverity: string, findingCount: number, summary: string|null}} StatusPayloadGate */
-/** @typedef {{id: string, status: NodeStatus, phase: string|null, executionPhase: string|null, runtime: string|null, workerRuntime: string|null, judgeRuntime: string|null, continuation: string, attempt: number, revisions: number, startedAt: string|null, updatedAt: string|null, usage: StatusPayloadUsage|null, costUsd: number|null, roleCostUsd: {worker: number|null, judge: number|null}, costProvenance: {worker: string, judge: string}, verdict: string|null, gate: StatusPayloadGate|null, gateOutcome: "passed"|"rejected"|null, pendingHandoff: {runtime: string, reason: string}|null, note: string|null, scopeFindings: string[]|null, errorCode: string|null, blockedBy: string[], verificationProgress: VerificationProgress|null, declaredReadBytes: number|null}} StatusPayloadNode */
+/** @typedef {{id: string, status: NodeStatus, phase: string|null, executionPhase: string|null, runtime: string|null, workerRuntime: string|null, judgeRuntime: string|null, continuation: string, attempt: number, revisions: number, startedAt: string|null, updatedAt: string|null, usage: StatusPayloadUsage|null, costUsd: number|null, roleCostUsd: {worker: number|null, judge: number|null}, costProvenance: {worker: string, judge: string}, verdict: string|null, gate: StatusPayloadGate|null, gateOutcome: "passed"|"rejected"|null, pendingHandoff: {runtime: string, reason: string}|null, note: string|null, scopeFindings: string[]|null, verificationArtifacts: string[]|null, errorCode: string|null, blockedBy: string[], verificationProgress: VerificationProgress|null, declaredReadBytes: number|null}} StatusPayloadNode */
 /** @typedef {{schemaVersion: 1, run: string, contractId: string, campaignId: string, goal: string, usage: {inputTokens: number, outputTokens: number, cacheReadInputTokens: number, costUsd: number|null}, roles: {worker: RoleUsage, judge: RoleUsage}, controller: JsonObject, identityWarnings: string[], summary: string, nodes: StatusPayloadNode[]}} StatusPayload */
 
 /** The glyph each terminal state prints in a status table. */
@@ -296,6 +296,7 @@ function buildStatusPayload(runDir, contract, nodes, identityWarnings, usage) {
         pendingHandoff: pendingHandoff(node),
         note: statusNote(node),
         scopeFindings: node.scopeFindings?.unexpectedPaths ?? null,
+        verificationArtifacts: node.verificationArtifacts ?? null,
         errorCode: node.error?.code ?? null,
         blockedBy: node.blockedBy ?? [],
         verificationProgress: progress,
@@ -723,7 +724,7 @@ function boundedNote(segments, maxLength = MAX_NOTE_LENGTH) {
  * @returns {string|null}
  */
 export function statusNote(node) {
-  const scope = scopeFindingsNote(node.scopeFindings);
+  const scope = boundedNote([scopeFindingsNote(node.scopeFindings), verificationArtifactsNote(node.verificationArtifacts)]);
   const review = reviewNote(node);
   const detail = node.gate?.summary ?? node.error?.message ?? node.blockedBy?.join(", ") ?? (candidateVerificationActive(node) ? "candidate" : node.phase);
   const note = boundedNote([review, detail]);