@deksden-com/dd-flow-cli 0.9.0-beta.140 → 0.9.0-beta.141

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.141
+
+### Patch Changes
+
+- 49dbfa3: Retain precise check and startup failures, validate bound browser inactivity proof,
+  and observe test progress without losing diagnostics or rollback guarantees.
+
 ## 0.9.0-beta.140
 
 - Compare observable birth after EPERM so a foreign reused PID is not mistaken for the retained owner; unknown identity remains conservative.

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.140",
-  "cli_commit": "995243962934773092d9d2a127b0e1224baa622d",
-  "built_at": "2026-10-17T10:10:08.823Z",
+  "cli_version": "0.9.0-beta.141",
+  "cli_commit": "c370c6e9beaefba2216bbf5bbadac02e4827768f",
+  "built_at": "2026-10-17T22:37:48.634Z",
   "built_with_canon": {
     "version": "4.1.2",
     "commit": "1ddedf9d3f086e046f8e7b194c739ec386e7c8b9",

package/dist/harness-runtime/lib/dd-agy-daemon.mjs

@@ -21,7 +21,7 @@ import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
 import { AGY_VERSION_TIMEOUT_MS, AgyError, agyTerminalFailure, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
 import { settledNativeTree } from "./native-children.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 import { readNativeLines, streamNativeDiagnostics, nativeObservationError, admitNativeRequestBuffer } from "./native-streams.mjs";
 
 const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
@@ -677,8 +677,12 @@ export async function serveDaemon(stateDir) {
   await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600);
   try { await runtime.start(state.config.resumeSessionId); runtime.requireSessionIdentity(state.config.resumeSessionId); }
   catch (error) {
-    await runtime.abortProvider("daemon_start_failed");
-    await runtime.persist({ shutdown_state: "failed", startup_error: errorPayload(error), active_tree: false }); await runtime.finishResource("failed", "daemon_start_failed");
+    try { await runtime.abortProvider("daemon_start_failed"); }
+    catch (cleanup) { error.details = { ...error.details, cleanup_failed: errorRecord(cleanup) }; }
+    try { if (!error.details?.cleanup_failed) await runtime.finishResource("failed", "daemon_start_failed"); }
+    catch (cleanup) { error.details = { ...error.details, resource_cleanup_failed: errorRecord(cleanup) }; }
+    Object.assign(state, { shutdown_state: error.details?.cleanup_failed || error.details?.resource_cleanup_failed ? "cleanup_failed" : "failed", active_tree: Boolean(error.details?.cleanup_failed) });
+    await retainStartupFailure({ state, publish: snapshot => runtime.persist(snapshot), log: paths.log, error });
     await new Promise(resolve => server.close(resolve));
     throw error;
   }

package/dist/harness-runtime/lib/dd-codex-daemon.mjs

@@ -15,7 +15,7 @@ import { spawn } from "node:child_process";
 import { waitForSettlement } from "./session-settlement.mjs";
 import { errorRecord } from "./operation-errors.mjs";
 import { CODEX_REQUEST_TIMEOUT_MS, LATE_RESPONSE_GRACE_MS, CodexBridge, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
-import { assertDaemonOwnership, prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { assertDaemonOwnership, assertStartupChild, prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 export function codexBridgeEnv(config, daemonId) { return { ...config.env, ...managedFlowEnv(config, daemonId) }; }
 
@@ -94,14 +94,14 @@ export async function startDaemon(options) {
   if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
   await removeSocket(paths.socket); const resourceProcess = await registerDaemonProcess(config, { kind: "codex-daemon", owner: `codex:${path.basename(paths.dir)}`, operation: `codex-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log }); const state = { schema_id: stateSchema, daemon_id: randomUUID(), pid: null, cwd: config.cwd, journal: config.journal, config, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", sessions: previous?.sessions ?? [], resource_process: resourceProcess }; await writeState(paths.state, state);
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [options.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
-  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed", details: observationDetails(startupClock, "daemon-start", child.pid) }); }
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) { assertStartupChild(child, state, await readState(paths.state), paths.log); await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed", details: observationDetails(startupClock, "daemon-start", child.pid) }); }
   catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.state), state.daemon_id); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(locations(options.stateDir).state) }); }
 
 export async function serveDaemon(stateDir) {
   const paths = locations(stateDir); const state = await readState(paths.state); if (!state || state.schema_id !== stateSchema) throw Object.assign(new Error("daemon state missing"), { code: "daemon_state_missing" });
-  const bridge = new CodexBridge({ ...state.config, env: { ...codexBridgeEnv(state.config, state.daemon_id), CODEX_HOME: process.env.CODEX_HOME, DD_FLOW_CODEX_STATE_DIR: paths.dir } }); await startManagedBridge({ config: state.config, state, bridge, kind: "codex-provider", publish: snapshot => writeState(paths.state, snapshot) }); const sessions = new Set(state.sessions ?? []); let active = null; let server; let persist = Promise.resolve();
+  const bridge = new CodexBridge({ ...state.config, env: { ...codexBridgeEnv(state.config, state.daemon_id), CODEX_HOME: process.env.CODEX_HOME, DD_FLOW_CODEX_STATE_DIR: paths.dir } }); await startManagedBridge({ config: state.config, state, bridge, kind: "codex-provider", publish: snapshot => writeState(paths.state, snapshot), log: paths.log }); const sessions = new Set(state.sessions ?? []); let active = null; let server; let persist = Promise.resolve();
   scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
   const save = (patch = {}) => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString(), sessions: [...sessions] }); const snapshot = structuredClone(state); persist = persist.catch(() => {}).then(() => writeState(paths.state, snapshot)); return persist; };
   const dispatch = async (operation, params, operationId) => {

package/dist/harness-runtime/lib/dd-droid-daemon.mjs

@@ -12,7 +12,7 @@ import { durableDaemonDispatch, inspectDaemonOperation, settleDaemonOperation, c
 import { ObservationClock, validateObservationDuration } from "./observation-clock.mjs";
 import { writeJsonAtomic } from "./runner-events.mjs";
 import { errorRecord } from "./operation-errors.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess } from "./managed-daemon.mjs";
+import { retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess } from "./managed-daemon.mjs";
 
 const REQUEST = "dd-droid/daemon-request@1", RESPONSE = "dd-droid/daemon-response@1";
 async function removeSocket(file) { try { if (!(await lstat(file)).isSocket()) throw new DroidError("unsafe_socket", "Refusing to replace non-socket daemon path"); await unlink(file); } catch (error) { if (error.code !== "ENOENT") throw error; } }
@@ -123,7 +123,18 @@ export async function serveDaemon(stateDir) {
   }); });
   trackDaemonConnections(server);
   try { await runtime.start(); scheduleDaemonProcessHeartbeat(state.config, state.resource_process); await save({ shutdown_state: "running" }); await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); }
-  catch (error) { let cleanup; try { cleanup = await runtime.closeTree(true); await removeDroidAuth(state.config); } catch (failure) { await save({ shutdown_state: "cleanup_failed", startup_error: errorRecord(error), cleanup_error: errorRecord(failure) }); throw error; } await save({ shutdown_state: "failed", startup_error: errorRecord(error), cleanup }); await finishDaemonProcess(state.config, state.resource_process, "failed", "startup_failed"); throw error; }
+  catch (error) {
+    let cleanup, cleanupError;
+    try { cleanup = await runtime.closeTree(true); }
+    catch (failure) { cleanupError = errorRecord(failure); error.details = { ...error.details, cleanup_failed: cleanupError }; }
+    try { await removeDroidAuth(state.config); }
+    catch (failure) { error.details = { ...error.details, auth_cleanup_failed: errorRecord(failure) }; }
+    if (!cleanupError) try { await finishDaemonProcess(state.config, state.resource_process, "failed", "startup_failed"); }
+    catch (failure) { error.details = { ...error.details, resource_cleanup_failed: errorRecord(failure) }; }
+    Object.assign(state, { shutdown_state: cleanupError || error.details?.resource_cleanup_failed || error.details?.auth_cleanup_failed ? "cleanup_failed" : "failed", ...(cleanupError ? { cleanup_error: cleanupError } : { cleanup }) });
+    await retainStartupFailure({ state, publish: save, log: paths.log, error });
+    throw error;
+  }
   await new Promise(resolve => server.once("close", resolve));
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";

package/dist/harness-runtime/lib/dd-grok-daemon.mjs

@@ -161,7 +161,7 @@ export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 3
 
 function sameConfig(state, config) { return ["cwd", "journal", "bin", "authSource", "model", "reasoning", "mode", "ddFlowBin", "ddFlowHome", "projectRoot", "sessionArchive", "resourceHome", "noFlow"].every((key) => (state.config?.[key] ?? null) === (config[key] ?? null)); }
 export function grokStartupFailure(state) {
-  if (state?.shutdown_state !== "failed" || !state.startup_error) return null;
+  if (!["failed", "cleanup_failed"].includes(state?.shutdown_state) || !state.startup_error) return null;
   const failure = state.startup_error;
   return new DaemonError(failure.code ?? "daemon_start_failed", failure.message ?? "Grok daemon failed before becoming ready", failure.retryable === true, failure.details);
 }
@@ -462,7 +462,7 @@ export async function serveDaemon(stateDir) {
     const session = runtime.sessions.get(sessionId);
     const rootProviderSessionId = session?.root_provider_session_id ?? sessionId;
     await observeAcpToolCall(state.config, { daemonId: state.daemon_id, rootProviderSessionId, parentProviderSessionId: session?.parent_provider_session_id ?? null, observedProfile: bridge.modelProfiles?.get(sessionId) ?? {} }, message);
-  } }); let initialized; try { initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "grok-provider", publish: snapshot => writeState(paths.state, snapshot) }); } catch (error) { await writeState(paths.state, { ...state, shutdown_state: "failed", startup_error: errorPayload(error) }); throw error; } runtime = new Runtime(paths, state, bridge, initialized);
+  } }); const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "grok-provider", publish: snapshot => writeState(paths.state, snapshot), log: paths.log }); runtime = new Runtime(paths, state, bridge, initialized);
   for (const fact of await readModelObservations(state.config.journal)) {
     if (fact.harness === "grok-acp" && fact.source?.channel === "x.ai/subagent_spawned" && runtime.sessions.has(fact.session_id)
       && (runtime.descendants.get(fact.session_id)?.attempt_id ?? null) === (fact.source.attempt_id ?? null) && fact.observed?.model) {

package/dist/harness-runtime/lib/dd-opencode-daemon.mjs

@@ -21,7 +21,7 @@ import { writeJsonAtomic } from "./runner-events.mjs";
 import { OpenCodeClient, OpenCodeError, historyDigest, usageSnapshot, nativeModel } from "./dd-opencode.mjs";
 import { safeProviderError } from "./provider-overload-policy.mjs";
 import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { assertStartupChild, retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-opencode/daemon-request@1", RESPONSE_SCHEMA = "dd-opencode/daemon-response@1", STATE_SCHEMA = "dd-opencode/daemon-state@2", ARCHIVE_SCHEMA = "dd-opencode/session-archive@2";
 class DaemonError extends Error { constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; } }
@@ -114,7 +114,7 @@ async function bootstrapCredentials(config, client) {
   if ((entry || legacy) && !selected) throw new DaemonError("opencode_credentials_unproven", "Selected portable credential is not active in the private server");
   return selected ? "active_private" : "absent";
 }
-async function importArchive(config, client) {
+async function importArchive(config, client, onProgress = async () => {}) {
   if (!config.sessionArchive) return null;
   const manifest = JSON.parse(await readFile(config.sessionArchive, "utf8"));
   if (manifest.schema_id !== ARCHIVE_SCHEMA || !manifest.payload || !/^2\./.test(manifest.opencode_version)) throw new DaemonError("invalid_session_archive", "Use the archived v1 engine for legacy OpenCode archives");
@@ -133,6 +133,7 @@ async function importArchive(config, client) {
     if (info?.id !== transfer.info.id || info.location?.directory !== config.cwd || (info.parentID ?? null) !== (transfer.info.parentID ?? null))
       throw new DaemonError("session_import_unproven", "OpenCode import did not preserve native identity/location");
     records.push({ provider_session_id: info.id, parent_provider_session_id: info.id === root ? null : info.parentID, root_provider_session_id: root, cwd: config.cwd });
+    await onProgress(info.id);
   }
   return records;
 }
@@ -169,10 +170,10 @@ export async function startDaemon(options) {
   const state = { schema_id: STATE_SCHEMA, native_protocol: 2, daemon_id: daemonId, shutdown_state: "starting", active_tree: false, auth_status: config.authStatus, versions: { opencode: config.version }, config, sessions: previous?.sessions ?? [], operations: previous?.operations ?? {}, resource_process: resourceProcess }; await writeJson(paths.state, state);
   const log = await open(paths.log, "a", 0o600), entry = absolute(options.entryPath, "dd-opencode entry"); const child = spawn(process.execPath, [entry, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) {
-    if (child.exitCode !== null || child.signalCode !== null) { const failed = await readState(paths.dir); throw Object.assign(new DaemonError("daemon_start_failed", "OpenCode daemon exited before readiness"), { cause: failed?.startup_error }); }
+    assertStartupChild(child, state, await readState(paths.dir), paths.log);
     await new Promise(resolve => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; }
   } throw Object.assign(new DaemonError("daemon_start_failed", "daemon did not become ready", true), { details: observationDetails(startupClock, 'daemon-start', child.pid) }); }
-  catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), daemonId); throw error; }
 }
 export const stopDaemon = async options => { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(options.stateDir) }); };
 
@@ -358,9 +359,9 @@ export class Runtime {
     }
     if (operation === "daemon.doctor") {
       const info = await this.client.health();
+      if (info.pid !== this.child?.pid || info.version !== this.state.versions.opencode) throw new DaemonError("foreign_server", "OpenCode endpoint is not the owned process");
       await this.client.call("model.list", { location: { directory: this.state.config.cwd } });
       const plugins = await this.client.call("plugin.list", { location: { directory: this.state.config.cwd } });
-      if (info.pid !== this.child?.pid || info.version !== this.state.versions.opencode) throw new DaemonError("foreign_server", "OpenCode endpoint is not the owned process");
       const pluginID = this.state.config.noFlow ? "dd-flow-security" : "dd-flow";
       if (!plugins.data.some(plugin => plugin.id === pluginID && plugin.state?.status === "active")) throw new DaemonError("opencode_plugin_missing", "Owned v2 plugin is not active");
       return { compatible: true, native_protocol: 2, observed_runtime: this.state.versions, productive_hooks: !this.state.config.noFlow, versions: this.state.versions, plugin_sha256: this.state.config.pluginSha256, auth_status: this.state.auth_status };
@@ -459,6 +460,54 @@ export class Runtime {
     throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
   }
 }
+
+/** Read-only readiness probes share the startup quiet window. A repeated
+ * ServiceUnavailable response is not activation progress. */
+export async function awaitOpenCodeStartup(client, state, child, { timeoutMs = SETUP_STARTUP_MS, publish = async () => {} } = {}) {
+  const clock = new ObservationClock({ timeoutMs });
+  let phase = "server", attempt = 0; const observedPhases = new Set();
+  const mark = async value => {
+    if (state.startup_phase === value) return;
+    state.startup_phase = value; await publish(state);
+    if (!observedPhases.has(value)) { observedPhases.add(value); clock.sample(value); }
+  };
+  const remaining = () => {
+    if (clock.sample()) throw new DaemonError("daemon_start_failed", "OpenCode startup made no further progress", false, observationDetails(clock, "native-readiness", child?.pid));
+    if (child && (child.exitCode !== null || child.signalCode !== null)) throw new DaemonError("opencode_unavailable", "Owned OpenCode process exited during startup", false, { exit_code: child.exitCode, signal: child.signalCode });
+    return Math.max(1, Math.ceil(clock.timeoutMs - clock.elapsed));
+  };
+  client.readObservation = () => ({ timeoutMs: remaining() });
+  try {
+    while (true) {
+      remaining();
+      try {
+        if (phase === "server") {
+          const identity = await client.health({ timeoutMs: remaining() });
+          if (identity.pid !== child?.pid || identity.version !== state.versions.opencode) throw new DaemonError("foreign_server", "OpenCode startup returned another server");
+          await mark("owned_server_ready"); phase = "location";
+        }
+        if (phase === "location") {
+          await client.call("model.list", { location: { directory: state.config.cwd } });
+          await mark("location_models_ready"); phase = "plugin";
+        }
+        const plugins = await client.call("plugin.list", { location: { directory: state.config.cwd } });
+        if (!Array.isArray(plugins?.data)) throw new DaemonError("opencode_configuration_invalid", "OpenCode returned invalid plugin readiness");
+        const id = state.config.noFlow ? "dd-flow-security" : "dd-flow", plugin = plugins.data.find(value => value.id === id);
+        if (["failed", "error", "missing", "disabled"].includes(plugin?.state?.status)) throw new DaemonError("opencode_plugin_failed", "Required owned plugin failed activation", false, { plugin_id: id, status: plugin.state.status });
+        if (plugin?.state?.status === "active") { await mark("required_plugin_active"); return { remaining, clock }; }
+        // A status transition of this required plugin is real new evidence.
+        if (["loading", "activating", "registered"].includes(plugin?.state?.status)) await mark(`required_plugin_${plugin.state.status}`);
+      } catch (error) {
+        const transient = error.code === "opencode_unavailable" && error.retryable === true
+          && (error.details?.native_type === "ServiceUnavailableError" || phase === "server" && ["TypeError", "ConnectionError", "Error"].includes(error.details?.native_type));
+        if (!transient) throw error;
+      }
+      const pause = Math.min([250, 500, 1000, 2000][Math.min(attempt++, 3)], remaining());
+      await new Promise(resolve => setTimeout(resolve, pause));
+    }
+  } catch (error) { delete client.readObservation; throw error; }
+}
+
 export async function serveDaemon(stateDir) {
   const paths = locations(stateDir), state = await readState(paths.dir); if (state?.schema_id !== STATE_SCHEMA) throw new DaemonError("daemon_state_missing", "daemon state is missing");
   let child, providerProcess;
@@ -470,13 +519,14 @@ export async function serveDaemon(stateDir) {
     scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
     scheduleDaemonProcessHeartbeat(state.config, providerProcess);
     state.provider_process = providerProcess; state.provider_pid = child.pid; await writeJson(paths.state, state);
-    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd }); const startupProgress = startupObserver(paths.dir, state.daemon_id); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); while (!startupClock.sample(await startupProgress())) { try { await client.health(); break; } catch { await new Promise(resolve => setTimeout(resolve, 100)); } }
-    const identity = await client.health();
-    if (identity.pid !== child.pid || identity.version !== state.versions.opencode) throw new DaemonError("foreign_server", "OpenCode startup returned another server");
+    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd });
+    const startup = await awaitOpenCodeStartup(client, state, child, { publish: snapshot => writeJson(paths.state, snapshot) });
     state.auth_status = await bootstrapCredentials(state.config, client);
-    const imported = await importArchive(state.config, client); if (imported) state.sessions.push(...imported);
+    state.startup_phase = "credentials_ready"; await writeJson(paths.state, state); startup.clock.sample(state.startup_phase);
+    const imported = await importArchive(state.config, client, async id => { state.startup_phase = `session_imported:${id}`; await writeJson(paths.state, state); startup.clock.sample(state.startup_phase); }); if (imported) state.sessions.push(...imported);
+    startup.remaining(); delete client.readObservation;
     await chmod(state.config.database, 0o600);
-    const runtime = new Runtime(paths, state, client, child, providerProcess); await runtime.dispatch("daemon.doctor", {}); await removeSocket(paths);
+    const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths);
     const server = net.createServer(connection => {
       connection.setEncoding("utf8"); let buffer = "", consumed = false;
       connection.on("data", chunk => {
@@ -499,8 +549,8 @@ export async function serveDaemon(stateDir) {
     trackDaemonConnections(server); runtime.server = server;
     await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await runtime.persist({ shutdown_state: "running", active_tree: false, server_port: port }); return await new Promise(() => {});
   } catch (error) {
-    await writeJson(paths.state, { ...state, startup_error: errorPayload(error) });
-    await cleanupFailedStart(state.config, providerProcess, child, error); throw error;
+    await cleanupFailedStart(state.config, providerProcess, child, error);
+    await retainStartupFailure({ state, publish: snapshot => writeJson(paths.state, snapshot), log: paths.log, error }); throw error;
   }
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";

package/dist/harness-runtime/lib/dd-opencode.mjs

@@ -51,7 +51,7 @@ export class OpenCodeClient {
   async call(method, input, { timeoutMs, progress, onDispatched, productive = false, signal } = {}) {
     const observation = this.readObservation?.();
     timeoutMs ??= observation?.timeoutMs ?? this.timeoutMs; progress ??= observation?.progress;
-    const api = await this.ready, controller = new AbortController();
+    const controller = new AbortController();
     let timer;
     const abort = () => { controller.abort(); clearInterval(timer); };
     signal?.addEventListener("abort", abort, { once: true });
@@ -59,6 +59,13 @@ export class OpenCodeClient {
     timer = observedTimeout(() => controller.abort(), timeoutMs, { progress });
     if (signal?.aborted) clearInterval(timer);
     try {
+      // Cover initialization as well as RPC. Abort still reaches the owned
+      // request; an unresolved module import cannot start a late RPC.
+      let rejectAbort;
+      const aborted = new Promise((_, reject) => { rejectAbort = () => reject(Object.assign(new Error("OpenCode probe aborted"), { name: "AbortError" })); controller.signal.addEventListener("abort", rejectAbort, { once: true }); });
+      let api;
+      try { if (controller.signal.aborted) rejectAbort(); api = await Promise.race([this.ready, aborted]); }
+      finally { controller.signal.removeEventListener("abort", rejectAbort); }
       const keys = method.split("."), name = keys.pop(), domain = keys.reduce((value, key) => value?.[key], api);
       if (typeof domain?.[name] !== "function") throw new OpenCodeError("opencode_capability_missing", `OpenCode v2 does not expose ${method}`);
       const options = { signal: controller.signal };
@@ -70,13 +77,15 @@ export class OpenCodeClient {
       if (cause._tag === "SessionNotFoundError" || cause._tag === "NotFoundError") throw new OpenCodeError("session_not_found", "OpenCode native Session is unavailable");
       if (productive && ["InvalidRequestError", "ConflictError", "UnauthorizedError", "ForbiddenError"].includes(cause._tag))
         throw new OpenCodeError("opencode_admission_rejected", "OpenCode rejected native admission", false, { effect: "no_effect", native_type: cause._tag });
+      if (!productive && ["UnauthorizedError", "ForbiddenError"].includes(cause._tag)) throw new OpenCodeError("opencode_auth_rejected", "OpenCode rejected authentication", false, { method, native_type: cause._tag });
+      if (!productive && ["InvalidRequestError", "ConflictError"].includes(cause._tag)) throw new OpenCodeError("opencode_configuration_invalid", "OpenCode rejected the diagnostic request", false, { method, native_type: cause._tag });
       if (productive || controller.signal.aborted) throw Object.assign(lost(`OpenCode observer lost during ${method}`, { method }), { cause });
       throw Object.assign(new OpenCodeError("opencode_unavailable", `OpenCode ${method} observation failed`, true,
         { method, native_type: cause._tag ?? cause.name ?? null, native_reason: cause.reason ?? null }), { cause });
     } finally { clearInterval(timer); signal?.removeEventListener("abort", abort); }
   }
-  async health() {
-    const info = await this.call("server.info", undefined, { timeoutMs: 5_000 });
+  async health(options = {}) {
+    const info = await this.call("server.info", undefined, { timeoutMs: 5_000, ...options });
     if (!/^2\./.test(info?.version) || !Number.isInteger(info.pid)) throw new OpenCodeError("unsupported_version", "OpenCode v2 server identity is unavailable");
     return info;
   }

package/dist/harness-runtime/lib/dd-zcode-daemon.mjs

@@ -10,7 +10,7 @@ import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "
 import net from "node:net";
 import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
 import path from "node:path";
-import { prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { assertStartupChild, prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
 import { parseLifecycleCommand, continuationCommand } from "./lifecycle-command.mjs";
 import { errorRecord, isProvenShellCorrection } from "./operation-errors.mjs";
@@ -186,6 +186,7 @@ export async function startDaemon(options) {
     await confirmDaemonProcess(config, resourceProcess, child);
     const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id);
     while (!startupClock.sample(await startupProgress())) {
+      assertStartupChild(child, state, await readState(paths.dir), paths.log);
       await new Promise((resolve) => setTimeout(resolve, 100));
       try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); }
       catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; }
@@ -704,7 +705,7 @@ export async function serveDaemon(stateDir) {
   const state = await readState(paths.dir);
   if (!state || state.schema_id !== STATE_SCHEMA) throw new DaemonError("daemon_state_missing", "daemon state is missing or incompatible");
   const bridge = new AcpBridge({ ...state.config, env: zcodeBridgeEnv(state.config, state.daemon_id) });
-  const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "zcode-provider", publish: snapshot => writeState(paths.state, snapshot) });
+  const initialized = await startManagedBridge({ config: state.config, state, bridge, kind: "zcode-provider", publish: snapshot => writeState(paths.state, snapshot), log: paths.log });
   const runtime = new DaemonRuntime(paths, state, bridge, initialized);
   scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
   await removeSocket(paths.socket, paths.dir);

package/dist/harness-runtime/lib/managed-daemon.d.mts

@@ -11,3 +11,6 @@ export function finishDaemonProcess(config: RuntimeConfig, record: ProcessBindin
 export function cleanupFailedDaemonStart(config: RuntimeConfig, record: ProcessBinding | null, child: ChildProcess | null, original: Error & { details?: Record<string, unknown> }, readState: () => Promise<Record<string, unknown>>, daemonId: string): Promise<void>;
 export function completeBudgetOperation(stateDir: string, request: { id: string; operation: string; params?: { sessionId?: string } }, result: unknown, observe?: () => Promise<Record<string, unknown>>): Promise<Record<string, unknown>>;
 export function stopProcessGroup(child: ChildProcess | null | undefined, graceMs?: number, options?: { detached?: boolean; settlementMs?: number }): Promise<void>;
+export function assertStartupChild(child: Pick<ChildProcess, "pid" | "exitCode" | "signalCode">, expected: Record<string, unknown>, observed: Record<string, unknown> | null, log: string): void;
+export function retainStartupFailure(input: { state: Record<string, unknown>; publish: (state: Record<string, unknown>) => Promise<unknown>; log: string; error: Error & { code?: string; details?: Record<string, unknown> } }): Promise<void>;
+export function startManagedBridge(input: { config: RuntimeConfig; state: Record<string, unknown>; bridge: { child: ChildProcess | null; options: { onSpawn?: (child: ChildProcess) => Promise<void> }; start: () => Promise<unknown> }; kind: string; publish: (state: Record<string, unknown>) => Promise<unknown>; log?: string }): Promise<unknown>;

package/dist/harness-runtime/lib/managed-daemon.mjs

@@ -1,8 +1,8 @@
-import { lstat, readFile, readdir, mkdir } from "node:fs/promises";
+import { lstat, readFile, readdir, mkdir, appendFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import { commandJson } from "./process-json.mjs";
-import { errorRecord } from "./operation-errors.mjs";
+import { errorRecord, reportedError, diagnosticJson } from "./operation-errors.mjs";
 import { writeJsonAtomic } from "./runner-events.mjs";
 import { runBoundedCommand } from "./native-hook-command.mjs";
 import { createRenewalState, maintenanceRetryable, renewalConfirmed, renewalDelay, renewalFailure, renewalRemaining, RENEWAL_POLICY } from "./lease-renewal.mjs";
@@ -352,11 +352,12 @@ export async function confirmDaemonProcess(config, record, child) {
 
 /** Provider bridges use a different process group from their daemon. Publish
  * the exact binding before initialize can start productive provider traffic. */
-export async function startManagedBridge({ config, state, bridge, kind, publish }) {
-  state.pid = process.pid;
-  await publish(state);
-  const provider = config.runtime_owner ? await registerDaemonProcess(config, { kind, owner: config.runtime_owner.owner_id, operation: kind }) : null;
+export async function startManagedBridge({ config, state, bridge, kind, publish, log }) {
+  let provider;
   try {
+    state.pid = process.pid;
+    await publish(state);
+    provider = config.runtime_owner ? await registerDaemonProcess(config, { kind, owner: config.runtime_owner.owner_id, operation: kind }) : null;
     state.provider_process = provider;
     state.startup_phase = "owner_registered";
     await publish(state);
@@ -372,7 +373,35 @@ export async function startManagedBridge({ config, state, bridge, kind, publish
     await publish(state);
     return initialized;
   }
-  catch (error) { await cleanupFailedStart(config, provider, bridge.child, error); throw error; }
+  catch (error) {
+    await cleanupFailedStart(config, provider, bridge.child, error);
+    state.shutdown_state = error.details?.cleanup_failed ? "cleanup_failed" : "failed";
+    await retainStartupFailure({ state, publish, log, error });
+    throw error;
+  }
+}
+
+/** A retained cause belongs to this startup generation, never a previous PID. */
+export function assertStartupChild(child, expected, observed, log) {
+  const sameGeneration = observed?.daemon_id === expected.daemon_id && (observed?.generation ?? null) === (expected.generation ?? null)
+    && (observed?.config?.runtime_owner?.owner_id ?? null) === (expected.config?.runtime_owner?.owner_id ?? null)
+    && (observed?.config?.runtime_owner?.operation_id ?? null) === (expected.config?.runtime_owner?.operation_id ?? null);
+  if (sameGeneration && observed?.startup_error) throw reportedError(observed.startup_error, "Native startup failed");
+  if (child.exitCode !== null || child.signalCode !== null) throw Object.assign(new Error("Native daemon exited before readiness"), {
+    code: "daemon_start_failed", retryable: false, details: { daemon_id: expected.daemon_id,
+      pid: child.pid ?? null, exit_code: child.exitCode, signal: child.signalCode, daemon_log: log }
+  });
+}
+
+export async function retainStartupFailure({ state, publish, log, error }) {
+  state.startup_error = JSON.parse(diagnosticJson(errorRecord(error)));
+  try { await publish(state); }
+  catch (publication) {
+    error.details = { ...error.details, startup_publication_error: errorRecord(publication), daemon_log: log };
+    // No credentials/config/argv: the log is only a bounded error record fallback.
+    try { if (log) await appendFile(log, `${diagnosticJson({ daemon_id: state.daemon_id, startup_error: errorRecord(error) })}\n`, { mode: 0o600 }); }
+    catch (logging) { error.details.startup_log_error = errorRecord(logging); }
+  }
 }
 
 export async function closeManagedBridge(config, state, bridge) {

package/dist/harness-runtime/lib/operation-errors.d.mts

@@ -9,6 +9,8 @@ export interface ErrorRecord {
   cleanup_error?: ErrorRecord;
 }
 export function errorRecord(error: unknown, depth?: number): ErrorRecord;
+export function redactDiagnostic(value: string): string;
+export function diagnosticJson(value: unknown): string;
 export function isObservationLoss(error: unknown): boolean;
 export function isProvenShellCorrection(error: unknown): boolean;
 export function reportedError(value: Record<string, unknown>, fallback: string): Error & ErrorRecord;

package/dist/harness-runtime/lib/operation-errors.mjs

@@ -1,5 +1,16 @@
 // An observer losing its response does not establish that a provider Turn failed.
 export const OPERATION_ERROR_CONTRACT_VERSION = "operation-errors@2";
+export function redactDiagnostic(value) {
+  return value.replace(/\b(Bearer|Basic)\s+[^\s"']+/gi, "$1 <redacted>")
+    .replace(/(^|[^\w-])([\w-]+)(["']?\s*[=:]\s*["']?)([^\s"',;&}]+)/g,
+      (whole, prefix, key, separator) => /token|secret|password|api[_-]?key|authorization/i.test(key)
+        ? `${prefix}${key}${separator}<redacted>` : whole)
+    .replace(/(\b[A-Za-z][A-Za-z0-9+.-]{0,31}:\/\/)[^\s/:@]+:[^\s/@]+@/g, "$1<redacted>@");
+}
+export function diagnosticJson(value) {
+  return JSON.stringify(value, (key, item) => /token|secret|password|api[_-]?key|authorization/i.test(key)
+    ? "<redacted>" : typeof item === "string" ? redactDiagnostic(item) : item, 2);
+}
 // Only use after the native delivery/operation owner has been verified.
 export function isProvenShellCorrection(error) {
   const details = error?.details;

package/dist/services/check-runner-evidence.js

@@ -1,13 +1,27 @@
 import fs from "node:fs";
+import crypto from "node:crypto";
+import { stripVTControlCharacters } from "node:util";
 import path from "node:path";
 import { parse } from "shell-quote";
 import { AppError } from "../shared/errors.js";
 import { validateObservationDuration } from "../harness-runtime/lib/observation-clock.mjs";
 function object(value) { return Boolean(value) && typeof value === "object" && !Array.isArray(value); }
 function boundedString(value, bytes) { return typeof value === "string" && Buffer.byteLength(value) <= bytes; }
+const validatedBrowserProofs = new WeakSet();
+function relativeProofPath(value) { return typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 4096 && !path.isAbsolute(value) && !value.includes("\\") && value.split("/").every(part => part !== "" && part !== "." && part !== ".."); }
+function proofArtifact(value) { return object(value) && relativeProofPath(value.relative_path) && typeof value.sha256 === "string" && /^[a-f0-9]{64}$/.test(value.sha256); }
+function browserProofShape(proof) {
+    const attempt = proof.attempt, step = proof.step;
+    return proof.native_code === "PLAYWRIGHT_ACTION_INACTIVITY" && object(attempt) && boundedString(attempt.invocation_id, 4096) && boundedString(attempt.test_id, 4096) && Boolean(attempt.test_id)
+        && [attempt.retry, attempt.repeat_each_index, attempt.worker_index].every(value => Number.isSafeInteger(value) && value >= 0)
+        && object(step) && boundedString(step.id, 4096) && Boolean(step.id) && ["pw:api", "expect"].includes(String(step.category)) && step.file === proof.file && Number.isSafeInteger(step.line) && step.line > 0
+        && proofArtifact(proof.worker_snapshot) && proofArtifact(proof.native_result);
+}
 export function runnerFailureValid(value) {
     if (!object(value) || typeof value.category !== "string" || !["assertion", "tooling", "unclassified"].includes(value.category))
         return false;
+    if (value.diagnostic_artifact !== undefined && !proofArtifact(value.diagnostic_artifact))
+        return false;
     for (const key of ["code", "message", "file", "test_id", "native_code", "classification_reason"])
         if (value[key] !== undefined && !boundedString(value[key], 4096))
             return false;
@@ -20,6 +34,10 @@ export function runnerFailureValid(value) {
         const world = proof.world;
         if (world.schema_id !== "dd-tasks/test-world-ready@1" || !boundedString(world.invocation_id, 4096) || typeof world.world_id !== "string" || !/^[a-f0-9]{32}$/.test(world.world_id) || typeof world.migrations_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(world.migrations_sha256) || world.ready !== true || world.setup_completed !== true || !boundedString(world.role, 128) || !world.role)
             return false;
+        if (proof.rule === "candidate_browser_action_inactivity" && !browserProofShape(proof))
+            return false;
+        if (!["candidate_sql_integrity", "candidate_browser_action_inactivity"].includes(String(proof.rule)))
+            return false;
     }
     return true;
 }
@@ -44,12 +62,14 @@ function candidateFailure(failure, evidence, root, capturedFiles) {
     if (failure.category === "assertion")
         return failure.origin === undefined || failure.origin === "candidate" && failure.file !== undefined && owned(failure.file);
     const proof = failure.repair_evidence;
+    if (proof?.rule === "candidate_browser_action_inactivity")
+        return validatedBrowserProofs.has(proof) && failure.category === "unclassified" && failure.phase === "test" && failure.origin === "candidate" && failure.native_code === proof.native_code && failure.file === proof.file && failure.test_id === proof.attempt.test_id && proof.attempt.invocation_id === evidence.binding.invocation_id && owned(proof.file);
     return failure.category === "unclassified" && failure.origin === "candidate" && ["test", "setup"].includes(failure.phase ?? "") && proof?.rule === "candidate_sql_integrity" && ["23502", "23503", "23505", "23514"].includes(proof.native_code) && failure.native_code === proof.native_code && failure.file === proof.file && proof.world.invocation_id === evidence.binding.invocation_id && owned(proof.file);
 }
 export function runnerObservationDurations(environment) {
     // Both observers leave the launcher its bounded physical cleanup tail.
     return { startupMs: validateObservationDuration(validateObservationDuration(Number(environment.DD_FLOW_TEST_STARTUP_SILENCE_MS ?? 120_000)) + 10_000),
-        executionMs: validateObservationDuration(validateObservationDuration(Number(environment.DD_FLOW_TEST_EXECUTION_SILENCE_MS ?? 600_000)) + 10_000) };
+        executionMs: validateObservationDuration(validateObservationDuration(Number(environment.DD_FLOW_TEST_EXECUTION_SILENCE_MS ?? 600_000)) + 15_000) };
 }
 /** Baseline uses argv rather than a shell alias. Recognize only a literal,
  * unique execution contract; never guess shell expansion or compound syntax. */
@@ -72,35 +92,90 @@ export function runnerContractForArgv(profile, command, args) {
         throw new AppError("runner_evidence_ambiguous", "Baseline argv matches conflicting runner evidence contracts", 2, { aliases: matches.map(match => match.alias) });
     return matches[0] ?? null;
 }
-/** Shared by CODE and EVAL baseline. Logs, repeated cursors and foreign records
- * are diagnostic bytes, not runner progress. Partial final lines await append. */
+/** Shared by CODE and EVAL baseline. The sole publisher owns this structured
+ * journal; logs belong on stdout/stderr. Partial final lines await append. */
 export function readRunnerProgress(file, invocationId, lastSequence = 0, now = Date.now()) {
     try {
-        const stat = fs.lstatSync(file);
-        if (!stat.isFile() || stat.size > 1024 * 1024)
-            return [];
+        const text = readBoundedProofFile(file, 4 * 1024 * 1024).toString("utf8");
         const accepted = [];
-        for (const line of fs.readFileSync(file, "utf8").split("\n").slice(0, -1)) {
-            let value;
-            try {
-                value = JSON.parse(line);
-            }
-            catch {
+        for (const line of text.split("\n").slice(0, -1)) {
+            if (Buffer.byteLength(line) > 16 * 1024)
+                throw new Error("Progress record exceeds 16 KiB");
+            const value = JSON.parse(line);
+            if (value && typeof value === "object" && !Array.isArray(value) && typeof value.invocation_id === "string" && value.invocation_id !== invocationId)
                 continue;
-            }
             if (!value || typeof value !== "object" || Array.isArray(value) || value.schema_id !== "dd-flow/check-runner-progress@1" || value.invocation_id !== invocationId
-                || !Number.isSafeInteger(value.sequence) || value.sequence <= lastSequence || typeof value.at !== "string" || !Number.isFinite(Date.parse(value.at)) || Date.parse(value.at) > now
+                || !Number.isSafeInteger(value.sequence) || value.sequence <= 0 || typeof value.at !== "string" || !Number.isFinite(Date.parse(value.at))
                 || !["startup", "execution"].includes(value.phase)
                 || !["setup_step_completed", "run_started", "module_collected", "test_started", "test_completed", "step_completed", "run_completed"].includes(value.event))
+                throw new Error("Malformed official progress record");
+            if (value.sequence <= lastSequence || Date.parse(value.at) > now)
                 continue;
             accepted.push(value);
             lastSequence = value.sequence;
         }
         return accepted;
     }
-    catch {
-        return [];
+    catch (cause) {
+        if (cause.code === "ENOENT")
+            return [];
+        throw new AppError("runner_progress_invalid", "Runner progress cannot be safely observed", 1, { cause: cause.code ?? cause.message });
+    }
+}
+function readBoundedProofFile(file, limit) {
+    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    try {
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size > limit)
+            throw new Error("Evidence is not a bounded regular file");
+        const buffer = Buffer.alloc(Math.min(limit + 1, stat.size + 1));
+        let length = 0;
+        while (length < buffer.length) {
+            const read = fs.readSync(fd, buffer, length, buffer.length - length, null);
+            if (!read)
+                break;
+            length += read;
+        }
+        if (length > limit || length > stat.size)
+            throw new Error("Evidence grew during observation");
+        return buffer.subarray(0, length);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function readProofArtifact(root, ref, limit = 256 * 1024) {
+    let current = root;
+    if (fs.lstatSync(current).isSymbolicLink())
+        throw new Error("Symlink evidence root");
+    for (const part of ref.relative_path.split("/")) {
+        current = path.join(current, part);
+        if (fs.lstatSync(current).isSymbolicLink())
+            throw new Error("Symlink proof artifact");
     }
+    const bytes = readBoundedProofFile(current, limit);
+    if (crypto.createHash("sha256").update(bytes).digest("hex") !== ref.sha256)
+        throw new Error("Browser proof hash differs");
+    const value = JSON.parse(bytes.toString("utf8"));
+    if (!object(value))
+        throw new Error("Invalid proof object");
+    return value;
+}
+function matches(actual, expected) { return object(actual) && Object.entries(expected).every(([key, value]) => actual[key] === value); }
+function validateBrowserArtifacts(root, proof, binding) {
+    const snapshot = readProofArtifact(root, proof.worker_snapshot), native = readProofArtifact(root, proof.native_result);
+    if (!Array.isArray(native.errors) || native.errors.length < 1 || native.errors.length > 64 || native.errors.some(error => !boundedString(error, 4096) || !/^(?:Error: )?(?:[A-Za-z][\w.]*: )?Test timeout of [1-9]\d*ms exceeded\.(?:\nCall log:[\s\S]*)?$/.test(stripVTControlCharacters(String(error)))))
+        return false;
+    if (!matches(snapshot.binding, binding) || !matches(native.binding, binding) || !matches(snapshot.attempt, proof.attempt) || !matches(native.attempt, proof.attempt)
+        || !matches(snapshot.step, proof.step) || !matches(native.step, proof.step) || !matches(snapshot.world, proof.world) || proof.world.invocation_id !== binding.invocation_id
+        || native.status !== "timedOut" || native.phase !== "test" || native.file !== proof.file || snapshot.phase !== "body" || snapshot.observation_gap !== false || !matches(snapshot.browser, { connected: true, page_closed: false, crashed: false })
+        || !matches(snapshot.world_health, { api: true, web: true, db: true }))
+        return false;
+    const quiet = snapshot.quiet_ms, last = Date.parse(String(snapshot.last_progress_at)), deadline = Date.parse(String(snapshot.deadline_at)), observed = Date.parse(String(snapshot.observed_at)), health = Date.parse(String(snapshot.health_observed_at)), ended = Date.parse(String(native.ended_at));
+    return Number.isSafeInteger(quiet) && quiet > 0 && [last, deadline, observed, health, ended].every(Number.isFinite) && Math.abs(deadline - last - quiet) <= 2 && observed >= last && observed <= deadline && health <= observed && health >= last && deadline - health <= Math.min(1000, quiet / 4) && ended >= deadline && ended <= Date.now() && ended - deadline <= 5000;
+}
+export function runnerProofArtifacts(evidence) {
+    return [...new Set((evidence?.failures ?? []).flatMap(failure => { const proof = failure.repair_evidence; return [...(failure.diagnostic_artifact ? [failure.diagnostic_artifact.relative_path] : []), ...(proof?.rule === "candidate_browser_action_inactivity" ? [proof.worker_snapshot.relative_path, proof.native_result.relative_path] : [])]; }))];
 }
 export function runnerContractsValid(value) {
     if (value === undefined)
@@ -124,16 +199,23 @@ export function readRunnerEvidence(root, contract, binding) {
             if (fs.lstatSync(current).isSymbolicLink())
                 return null;
         }
-        const stat = fs.statSync(current);
-        if (!stat.isFile() || stat.size > 1024 * 1024)
-            return null;
-        const evidence = JSON.parse(fs.readFileSync(current, "utf8"));
+        const evidence = JSON.parse(readBoundedProofFile(current, 1024 * 1024).toString("utf8"));
         if (evidence.schema_id !== contract.schema_id || !evidence.binding || Object.entries(binding).some(([key, value]) => evidence.binding[key] !== value)
             || typeof evidence.runner?.name !== "string" || !evidence.runner.name || typeof evidence.runner.version !== "string" || !evidence.runner.version || typeof evidence.completed !== "boolean" || !evidence.counts
             || ![evidence.counts.passed, evidence.counts.failed, evidence.counts.skipped].every(n => Number.isSafeInteger(n) && n >= 0)
             || !Array.isArray(evidence.failures) || evidence.failures.length > 64 || evidence.failures.some(f => !runnerFailureValid(f))
             || evidence.counts.failed > evidence.failures.length || evidence.observation_unknown !== undefined && typeof evidence.observation_unknown !== "boolean")
             return null;
+        for (const failure of evidence.failures) {
+            if (failure.diagnostic_artifact && !matches(readProofArtifact(root, failure.diagnostic_artifact, 2 * 1024 * 1024).binding, binding))
+                return null;
+            const proof = failure.repair_evidence;
+            if (proof?.rule === "candidate_browser_action_inactivity") {
+                if (!validateBrowserArtifacts(root, proof, binding))
+                    return null;
+                validatedBrowserProofs.add(proof);
+            }
+        }
         return evidence;
     }
     catch {

package/dist/services/code-checks.js

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { candidateFailureFiles, checkRepairDisposition, readRunnerEvidence, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations } from "./check-runner-evidence.js";
+import { candidateFailureFiles, checkRepairDisposition, readRunnerEvidence, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations, runnerProofArtifacts } from "./check-runner-evidence.js";
 export { assertSourceRepairEligible, checkRepairDisposition } from "./check-runner-evidence.js";
 import { isGitlessWorkspace, ownedWorkspaceHookPath, projectServicePathFilter, workspaceGitFiles } from "./workspace-files.js";
 import { spawn, spawnSync } from "node:child_process";
@@ -622,10 +622,12 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
         }
         const runnerEvidence = group.runnerEvidence ? readRunnerEvidence(evidenceDir, group.runnerEvidence, { invocation_id: id, check_id: id, command: group.command, input_hash: inputHash, verification_epoch: epoch }) : undefined;
         const physicalFailures = executionFailures({ exitCode: result.exitCode, launcherError: result.error ?? undefined, cleanupUnconfirmed: result.cleanupUnconfirmed, missing: artifacts.missing, mutations: mutationPaths, invalidRunner: Boolean(group.runnerEvidence && !runnerEvidence) });
+        if (result.failure)
+            physicalFailures.push(result.failure);
         const candidateFiles = candidateFailureFiles(runnerEvidence, input.workspaceRoot);
         if (group.runnerEvidence)
             retainExecutionOutcome(evidenceDir, { id, command: group.command, input_hash: inputHash, verification_epoch: epoch }, input.workspaceRoot, physicalFailures, candidateFiles);
-        const requiredArtifacts = [...new Set([...group.requiredArtifacts, ...(group.runnerEvidence ? ["engine-outcome.json"] : [])])];
+        const requiredArtifacts = [...new Set([...group.requiredArtifacts, ...runnerProofArtifacts(runnerEvidence), ...(group.runnerEvidence ? ["engine-outcome.json"] : [])])];
         artifacts = collectCheckArtifacts(evidenceDir, requiredArtifacts);
         const status = result.aborted ? "aborted" : result.exitCode === 0 && !result.error && artifacts.complete && mutationPaths.length === 0 && (!group.runnerEvidence || runnerEvidencePass(runnerEvidence)) ? "passed" : "failed";
         const receipt = receiptFor({ ...reserved, resources, result, status, after, mutationPaths, artifacts: artifacts.items });
@@ -714,7 +716,7 @@ export function reconcileUnfinishedChecks(context, input) {
                 }
             }
             retainExecutionOutcome(evidenceDir, receipt, input.workspaceRoot, physicalFailures, candidateFiles);
-            receipt.required_artifacts = [...new Set([...(receipt.required_artifacts ?? []), "engine-outcome.json"])];
+            receipt.required_artifacts = [...new Set([...(receipt.required_artifacts ?? []), ...runnerProofArtifacts(runnerEvidence), "engine-outcome.json"])];
             artifacts = collectCheckArtifacts(evidenceDir, receipt.required_artifacts);
         }
         const status = completion === null ? "aborted" : completion.exit_code === 0 && workspaceUnchanged && artifacts.complete && physicalFailures.length === 0 && (!receipt?.runner_evidence_required || runnerEvidencePass(runnerEvidence)) ? "passed" : "failed";
@@ -796,7 +798,7 @@ function reserveOrReuseReceipt(context, input) {
 }
 function sourceRepairContractMatches(receipt, group, profileHash) {
     return checkRepairDisposition(receipt) === "source_repair" && group.command === receipt.command && profileHash === receipt.profile_hash && isDeepStrictEqual(group.inputs, receipt.inputs)
-        && isDeepStrictEqual([...group.requiredArtifacts].sort(), receipt.required_artifacts.filter(file => file !== "engine-outcome.json").sort()) && isDeepStrictEqual([...group.ports].sort(), Object.keys(receipt.resources.ports).sort());
+        && isDeepStrictEqual(derivedReceiptArtifacts(group, receipt).sort(), [...receipt.required_artifacts].sort()) && isDeepStrictEqual([...group.ports].sort(), Object.keys(receipt.resources.ports).sort());
 }
 function receiptFor(input) { return { id: input.id, local_id: input.localId, declaration_id: input.group.declarations[0].id, check_refs: input.group.declarations.map(checkRef), gate: input.group.gate, scope: input.scope, work_id: input.workId ?? null, command: input.group.command, input_hash: input.inputHash, verification_epoch: input.epoch, retry_of_receipt_id: input.retryOf ?? null, retry_reason: input.retryReason ?? null, status: input.status, ...(input.status === "aborted" ? { abort_reason: input.result.error } : {}), exit_code: input.status === "running" ? null : input.result.exitCode, stdout_path: input.stdoutPath, stderr_path: input.stderrPath, receipt_path: input.receiptPath, completion_path: input.completionPath, required_artifacts: input.group.requiredArtifacts, inputs: input.group.inputs, workspace_fingerprint: input.before.fingerprint, before_fingerprint: input.before.fingerprint, after_fingerprint: input.after.fingerprint, profile_hash: input.profileHash, mutation_paths: input.mutationPaths, artifacts: input.artifacts, resources: { ports: input.resources }, started_at: input.startedAt, finished_at: input.status === "running" ? input.startedAt : new Date().toISOString() }; }
 function writeReceipt(file, receipt) { const temporary = `${file}.tmp-${process.pid}-${crypto.randomUUID()}`; fs.writeFileSync(temporary, `${JSON.stringify(receipt, null, 2)}\n`); fs.renameSync(temporary, file); }
@@ -1136,7 +1138,8 @@ function explicitInputFiles(root, inputs, ignoredRoots) {
     return [...result.entries()];
 }
 function checkInputHash(workspaceRoot, group, profileHash, inputFingerprint, evidenceContext, checkEnvironment) { return crypto.createHash("sha256").update(JSON.stringify({ workspace_root: path.resolve(workspaceRoot), gate: group.reusable ? null : group.gate, command: group.command, required_artifacts: group.requiredArtifacts, ports: group.ports, inputs: group.inputs, ...(group.runnerEvidence ? { runner_evidence: group.runnerEvidence } : {}), profile_hash: profileHash, environment: environmentFingerprint(workspaceRoot, group.environmentInputs, checkEnvironment), input_fingerprint: inputFingerprint, ...(group.environmentInputs === undefined ? {} : { environment_inputs: group.environmentInputs }), ...(evidenceContext === undefined ? {} : { evidence_context: evidenceContext }) })).digest("hex"); }
-function bindReceipt(receipt, group) { return { ...receipt, gate: group.gate, declaration_id: group.declarations[0].id, check_refs: group.declarations.map(checkRef), required_artifacts: [...new Set([...group.requiredArtifacts, ...(receipt.required_artifacts.includes("engine-outcome.json") ? ["engine-outcome.json"] : [])])], inputs: group.inputs }; }
+function derivedReceiptArtifacts(group, receipt) { return [...new Set([...group.requiredArtifacts, ...runnerProofArtifacts(receipt.runner_evidence), ...(receipt.required_artifacts.includes("engine-outcome.json") ? ["engine-outcome.json"] : [])])]; }
+function bindReceipt(receipt, group) { return { ...receipt, gate: group.gate, declaration_id: group.declarations[0].id, check_refs: group.declarations.map(checkRef), required_artifacts: derivedReceiptArtifacts(group, receipt), inputs: group.inputs }; }
 export function checkReceiptEvidenceValid(receipt) { return checkReceiptEvidenceValidForMode(receipt); }
 function checkReceiptEvidenceValidForMode(receipt, mode) {
     try {
@@ -1239,6 +1242,7 @@ export function runCheck(command, cwd, environment, stdout, stderr, heartbeat, o
         const started = Date.now();
         const child = spawn("/bin/sh", ["-c", checkShellScript()], { cwd, env: { ...environment, DD_FLOW_CHECK_COMMAND: command }, stdio: ["pipe", "pipe", "pipe"], detached: process.platform !== "win32" });
         let error = null;
+        let failure;
         let stopping = false;
         let closed = false;
         let progress;
@@ -1259,6 +1263,8 @@ export function runCheck(command, cwd, environment, stdout, stderr, heartbeat, o
                 return;
             stopping = true;
             error = cause instanceof Error ? cause.message : String(cause);
+            if (cause instanceof AppError)
+                failure = { code: cause.code, message: cause.message };
             if (progress) {
                 clearInterval(progress);
                 progress = undefined;
@@ -1270,22 +1276,28 @@ export function runCheck(command, cwd, environment, stdout, stderr, heartbeat, o
             cleanup = stopProcessGroup(child, 5_000).catch(cause => {
                 cleanupUnconfirmed = true;
                 error = `${error}; cleanup: ${JSON.stringify(errorRecord(cause))}`;
-                resolve({ exitCode: null, error, aborted: true, cleanupUnconfirmed });
+                resolve({ exitCode: null, error, aborted: true, cleanupUnconfirmed, ...(failure ? { failure } : {}) });
             });
         };
         const observationTimer = setInterval(() => {
             if (stopping || closed || observation.phase?.() === "serving")
                 return;
             if (runnerClock && runnerProgress) {
-                for (const event of readRunnerProgress(runnerProgress, environment.DD_FLOW_CHECK_INVOCATION_ID ?? "", runnerSequence)) {
-                    runnerSequence = event.sequence;
-                    runnerPhase = event.phase;
-                    runnerClock.sample(runnerSequence, Date.parse(event.at));
+                try {
+                    for (const event of readRunnerProgress(runnerProgress, environment.DD_FLOW_CHECK_INVOCATION_ID ?? "", runnerSequence)) {
+                        runnerSequence = event.sequence;
+                        if (runnerPhase !== "execution")
+                            runnerPhase = event.phase;
+                        runnerClock.sample(runnerSequence, Date.parse(event.at));
+                    }
+                    // The outer guard includes the runner's bounded cleanup tail.
+                    runnerClock.timeoutMs = runnerPhase === "execution" ? runnerExecutionMs : runnerStartupMs;
+                    if (runnerClock.sample(runnerSequence))
+                        stop(new AppError("operation_observation_lost", "Structured test runner stopped making progress", 1, { phase: runnerPhase, sequence: runnerSequence }));
+                }
+                catch (cause) {
+                    stop(cause);
                 }
-                // The outer guard includes the runner's bounded cleanup tail.
-                runnerClock.timeoutMs = runnerPhase === "execution" ? runnerExecutionMs : runnerStartupMs;
-                if (runnerClock.sample(runnerSequence))
-                    stop(new AppError("operation_observation_lost", "Structured test runner stopped making progress", 1, { phase: runnerPhase, sequence: runnerSequence }));
                 return;
             }
             if (clock.sample(outputCursor))
@@ -1313,7 +1325,7 @@ export function runCheck(command, cwd, environment, stdout, stderr, heartbeat, o
                 clearInterval(observationTimer);
             await cleanup;
             await Promise.all(flushed);
-            resolve({ exitCode, error: error ?? (signal ? `terminated by ${signal}` : null), aborted: stopping || Boolean(signal) || Boolean(error), ...(cleanupUnconfirmed ? { cleanupUnconfirmed } : {}) });
+            resolve({ exitCode, error: error ?? (signal ? `terminated by ${signal}` : null), aborted: stopping || Boolean(signal) || Boolean(error), ...(cleanupUnconfirmed ? { cleanupUnconfirmed } : {}), ...(failure ? { failure } : {}) });
         });
         if (!child.pid) {
             error = "check process did not provide a PID";

package/dist/services/stage-lifecycle.js

@@ -13,7 +13,7 @@ import { reconcileSessionCoverage, registerFlowSession } from "./sessions.js";
 import { usageForRun } from "./usage.js";
 import { boundCanonicalPlan, prepareCanonicalPlan } from "./plan-runtime.js";
 import { prepareJsonFile, prepareJsonSchema, prepareOutputDirectory, prepareOutputFile, prepareTextFile } from "../cli/input-preparation.js";
-import { AppError } from "../shared/errors.js";
+import { AppError, errorRecord, processEvidence, diagnosticJson } from "../shared/errors.js";
 import { planJsonPath, projectHome, resolveProjectRoot } from "../storage/paths.js";
 import { resolveCanonRoot } from "./canon.js";
 import { preflightMemoryPermissions } from "./memory-permissions.js";
@@ -295,7 +295,7 @@ export async function finishStage(context, input, prepared = prepareStageFinish(
         if (coverage.jobs.missing?.length) {
             throw new AppError("worker_jobs_incomplete", "Stage finish requires all declared worker jobs", 1, { coverage });
         }
-        const lint = await runTargetedMemoryBankLint(projectRoot);
+        const lint = await runTargetedMemoryBankLint(projectRoot, undefined, path.join(stageRoot, "diagnostics"));
         if (planFinish)
             boundCanonicalPlan(context, { projectId: view.run.project_id, protocolId: view.run.subject.id, planPath: planFinish.plan_path }, planFinish.canonical);
         const report = buildStageReport(context, view, input.stage, status, semantic, stageRoot, lint, planFinish);
@@ -836,7 +836,7 @@ function workerCoverage(context, projectId, runId) {
         jobs: { expected: jobs.map((job) => job.job_id), missing: missingJobs }
     };
 }
-export async function runTargetedMemoryBankLint(projectRoot, selectedFiles) {
+export async function runTargetedMemoryBankLint(projectRoot, selectedFiles, diagnosticRoot) {
     const files = [...new Set((selectedFiles ?? gitChangedFiles(projectRoot)).filter((file) => file.startsWith(".memory-bank/") && file.toLowerCase().endsWith(".md") && !file.split(/[\\/]/u).some((part) => part === ".." || part.startsWith(".env"))))];
     for (const file of files)
         ensureWithin(projectRoot, path.resolve(projectRoot, file), "lint target");
@@ -844,27 +844,71 @@ export async function runTargetedMemoryBankLint(projectRoot, selectedFiles) {
         return { ok: true, status: "not_applicable_no_changed_docs", files, finding_count: 0 };
     }
     const binary = process.env.MB_LINT_BIN ?? "mb-lint";
+    const fail = (code, message, details) => {
+        const error = new AppError(code, message, 1, { binary, files, ...details });
+        if (diagnosticRoot) {
+            try {
+                fs.mkdirSync(diagnosticRoot, { recursive: true });
+                const file = path.join(diagnosticRoot, `lint-${crypto.randomUUID()}.json`);
+                if (details.report) {
+                    const reportFile = file.replace(/\.json$/, ".report.json"), report = diagnosticJson(details.report);
+                    const reportBytes = Buffer.from(report);
+                    fs.writeFileSync(reportFile, reportBytes.length <= 1024 * 1024 ? report : JSON.stringify({ truncated: true, bytes: reportBytes.length, excerpt: reportBytes.subarray(0, 128 * 1024).toString("utf8") }), { flag: "wx", mode: 0o600 });
+                    error.details.report_path = reportFile;
+                }
+                delete error.details.report;
+                fs.writeFileSync(file, diagnosticJson(errorRecord(error)), { flag: "wx", mode: 0o600 });
+                error.details.diagnostic_path = file;
+            }
+            catch (capture) {
+                delete error.details.report;
+                error.details.capture_error = errorRecord(capture);
+            }
+        }
+        delete error.details.report;
+        throw error;
+    };
     let result;
     try {
         result = await commandResult(binary, ["--root", projectRoot, "--files", ...files, "--format", "json"], { cwd: projectRoot, startupMs: SETUP_STARTUP_MS });
     }
     catch (cause) {
-        const error = cause;
-        throw new AppError("lint_gate_unavailable", "Selected-file mb-lint is unavailable", 1, { binary, files, cause: error.code, ...error.details });
+        const recorded = errorRecord(cause), unavailable = ["ENOENT", "EACCES", "ENOEXEC"].includes(recorded.code);
+        fail(unavailable ? "lint_gate_unavailable" : "lint_gate_tool_failed", "Selected-file mb-lint could not execute", { cause: recorded });
     }
-    let parsed = {};
+    const evidence = processEvidence(result);
+    if (result.signal || result.exit_code !== 0 && result.exit_code !== 1)
+        fail("lint_gate_tool_failed", "Selected-file mb-lint did not complete normally", { process: evidence });
+    let parsed;
     try {
-        parsed = result.stdout ? JSON.parse(result.stdout) : {};
+        parsed = JSON.parse(result.stdout);
     }
     catch {
-        throw new AppError("lint_gate_invalid_output", "Selected-file mb-lint did not return JSON", 1, { binary, files });
+        fail(result.exit_code === 0 ? "lint_gate_invalid_output" : "lint_gate_tool_failed", "Selected-file mb-lint did not return a report", { process: evidence });
     }
-    if (result.exit_code !== 0) {
-        throw new AppError("lint_gate_failed", "Selected-file mb-lint reported blocking findings", 1, { binary, files, result: parsed });
+    const report = parsed;
+    const severities = { error: "errors", warning: "warnings", info: "info", suggestion: "suggestions" };
+    const matchingRoot = () => { try {
+        return typeof report?.root === "string" && fs.realpathSync(path.resolve(projectRoot, report.root)) === fs.realpathSync(projectRoot);
     }
-    const findingCount = parsed && typeof parsed === "object" && Array.isArray(parsed.findings)
-        ? parsed.findings.length
-        : 0;
+    catch {
+        return false;
+    } };
+    const valid = report && report.tool === "mb-lint" && typeof report.version === "string" && report.version.trim()
+        && matchingRoot()
+        && report.memoryBank === ".memory-bank" && report.summary && Array.isArray(report.findings)
+        && report.findings.every(finding => finding && typeof finding === "object" && typeof finding.severity === "string" && Object.hasOwn(severities, finding.severity)
+            && [finding.ruleId, finding.file, finding.message].every(value => typeof value === "string" && value.trim()))
+        && Object.entries(severities).every(([severity, key]) => Number.isSafeInteger(report.summary[key]) && Number(report.summary[key]) >= 0
+            && report.summary[key] === report.findings.filter(finding => finding.severity === severity).length);
+    if (!valid)
+        fail(result.exit_code === 0 ? "lint_gate_invalid_output" : "lint_gate_tool_failed", "Selected-file mb-lint returned an invalid report", { process: evidence });
+    const errors = Number(report.summary.errors);
+    if ((errors > 0 ? 1 : 0) !== result.exit_code)
+        fail("lint_gate_invalid_output", "Selected-file mb-lint report contradicts its exit status", { process: evidence });
+    if (errors > 0)
+        fail("lint_gate_failed", "Selected-file mb-lint reported blocking findings", { process: evidence, report: parsed, summary: report.summary, finding_count: report.findings.length });
+    const findingCount = report.findings.length;
     return { ok: true, status: "passed", binary, files, finding_count: findingCount, result: parsed };
 }
 function renderMarkdown(report) {

package/dist/services/tooling.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { commandResult, commandText } from '../harness-runtime/lib/process-json.mjs';
 import { publishSetup, SETUP_STARTUP_MS } from '../harness-runtime/lib/setup-progress.mjs';
-import { AppError } from "../shared/errors.js";
+import { AppError, processEvidence } from "../shared/errors.js";
 import { ensureDir } from "../storage/paths.js";
 const manifestRelativePath = path.join("tools", "worktrunk-manifest.json");
 const managedToolRootName = "wt";
@@ -206,24 +206,26 @@ function verifyCachedWorktrunk(context, manifest, platform) {
         binary_sha256: actualBinaryChecksum
     };
 }
-async function extractArchive(archive, destination, format) {
+export async function extractArchive(archive, destination, format) {
     if (format === "tar.xz") {
         const listing = await commandResult("tar", ["-tJf", archive], { startupMs: SETUP_STARTUP_MS });
-        if (listing.exit_code !== 0 || listing.stdout.split("\n").some(unsafeArchivePath)) {
-            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive has an unsafe or unreadable file list", 1);
-        }
+        if (listing.exit_code !== 0 || listing.signal)
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive listing failed", 1, { process: processEvidence(listing) });
+        if (listing.stdout.split("\n").some(unsafeArchivePath))
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive has an unsafe file list", 1, { phase: "archive_path_validation" });
         const extracted = await commandResult("tar", ["-xJvf", archive, "-C", destination], { startupMs: SETUP_STARTUP_MS });
-        if (extracted.exit_code !== 0)
-            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive extraction failed", 1, { stderr: sanitize(extracted.stderr) });
+        if (extracted.exit_code !== 0 || extracted.signal)
+            throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive extraction failed", 1, { process: processEvidence(extracted) });
         return;
     }
     const listing = await commandResult("unzip", ["-Z1", archive], { startupMs: SETUP_STARTUP_MS });
-    if (listing.exit_code !== 0 || listing.stdout.split("\n").some(unsafeArchivePath)) {
-        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive has an unsafe or unreadable file list", 1);
-    }
+    if (listing.exit_code !== 0 || listing.signal)
+        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive listing failed", 1, { process: processEvidence(listing) });
+    if (listing.stdout.split("\n").some(unsafeArchivePath))
+        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive has an unsafe file list", 1, { phase: "archive_path_validation" });
     const extracted = await commandResult("unzip", [archive, "-d", destination], { startupMs: SETUP_STARTUP_MS });
-    if (extracted.exit_code !== 0)
-        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive extraction failed", 1, { stderr: sanitize(extracted.stderr) });
+    if (extracted.exit_code !== 0 || extracted.signal)
+        throw new AppError("tool_integrity_failed", "Pinned Worktrunk archive extraction failed", 1, { process: processEvidence(extracted) });
 }
 function findBinary(root) {
     const expected = process.platform === "win32" ? "wt.exe" : "wt";

package/dist/services/verification-matrix.js

@@ -52,9 +52,10 @@ export function renderVerificationMatrix(matrix) {
     return [`# Verification matrix`, "", `RUN: ${escape(h.run_id)}; stage: ${escape(h.stage)} / ${escape(h.stage_attempt)}; role: ${h.role}; completeness: ${h.completeness}.`, "", "This generated view is not semantic acceptance. A retained passed check proves only its declared contour and proof limits.", "", "## Requirements", "", "| Protocol | Requirement | Statement | PLAN items / checks |", "| --- | --- | --- | --- |", ...matrix.requirements.map(row => `| ${escape(row.protocol_id)} | ${escape(row.id)} | ${escape(row.statement)} | ${escape(row.plan_items.map(item => `${item.id}: ${item.check_refs.join(", ")}`).join("; "))} |`), "", "## Acceptance criteria", "", "| Protocol | Criterion | Gate | Checks / native results | Proof limits |", "| --- | --- | --- | --- | --- |", ...matrix.criteria.map(row => `| ${escape(row.protocol_id)} | ${escape(row.criterion_id)} | ${escape(row.gate ?? "not declared")} | ${escape(row.checks.map(check => `${check.canonical_ref}: ${status(check)}`).join("; "))} | ${escape(JSON.stringify(row.declaration?.proof_limits ?? []))} |`), "", "## Policy checks", "", ...matrix.policy_checks.map(check => `- ${escape(check.canonical_ref)}: ${escape(status(check))}`), "", "## Sources", "", ...matrix.sources.map(source => `- ${escape(source.role)}: ${escape(`${source.root}:${source.path}`)} (${source.sha256})`), ""].join("\n");
 }
 export function verificationMatrixInstruction(metadata, runHome, task) {
+    const contract = `<verification_evidence_contract>\nCheck prerequisites must be executable in the check command or supported project policy; purpose prose and list order do not prepare an environment. A readiness gate is final verification, not implicit setup before the first CODE Work. PLAN and PLAN-REVIEW must compare claimed prerequisites with the actual launch path: a description saying migrate-before-check cannot repair a command that checks before migration. Prefer the existing self-contained project verification alias.\nBrowser checks must prove the expected surface exists and the measured set is nonempty before asserting layout geometry. An empty DOM is not evidence of no overlap. Derive navigation from the actual UI and accepted specification. Review whether the test can fail for the intended defect; a green named contour does not prove complete product semantics. Keep native test outcome separate from observation/cleanup: passed assertions with unknown cleanup are neither PASS nor a product assertion failure. Use retained native diagnostics and proof limits; generic timeouts or infrastructure errors do not authorize source repair. Do not patch the candidate product outside the assigned flow Work.\n</verification_evidence_contract>\n`;
     if (!metadata)
-        return "";
-    return `<verification_matrix>\nRuntime generated the technical verification matrix: ${safePath(runHome, metadata.markdown.path, false)}; structured data: ${safePath(runHome, metadata.json.path, false)}. Source fingerprint: ${metadata.source_fingerprint}; completeness: ${metadata.completeness}. Read it before ${task}. This is a derived view of the named accepted requirements, PLAN and receipts, not semantic acceptance. Do not edit these generated files or manually duplicate receipt IDs/hashes/results. Record insufficient proof or violated criteria in the ordinary Stage/Work result with evidence references; modify only your assigned source/test/result documents. Review inputs remain read-only. A passed check proves only its named contour and limits, not all business semantics or production readiness.\n</verification_matrix>\n`;
+        return contract;
+    return `${contract}<verification_matrix>\nRuntime generated the technical verification matrix: ${safePath(runHome, metadata.markdown.path, false)}; structured data: ${safePath(runHome, metadata.json.path, false)}. Source fingerprint: ${metadata.source_fingerprint}; completeness: ${metadata.completeness}. Read it before ${task}. This is a derived view of the named accepted requirements, PLAN and receipts, not semantic acceptance. Do not edit these generated files or manually duplicate receipt IDs/hashes/results. Record insufficient proof or violated criteria in the ordinary Stage/Work result with evidence references; modify only your assigned source/test/result documents. Review inputs remain read-only. A passed check proves only its named contour and limits, not all business semantics or production readiness.\n</verification_matrix>\n`;
 }
 /** Attachment and packet authority share a short transaction, then both files
  * must be visible before the prompt claims they are ready. */

package/dist/services/vnext-plan.js

@@ -120,8 +120,7 @@ export function startVnextPlan(context, input, prepared = prepareVnextPlanStart(
         : `PLAN-REVIEW mode is ${planReviewMode}: include review groups only for genuinely applicable aspects; an empty set is allowed.`;
     fs.writeFileSync(promptPath, `${prompt}\n<review_mode_rule>${reviewModeRule}</review_mode_rule>\n<verification_rule>Every flow check must be an autonomous executable command. Do not declare external/manual proof or a human review as a check, evidence substitute, DEF, or gate. The only user interaction supported by this flow is an explicit stage pause for a material unanswered question.</verification_rule>\n${stageLifecycleInstruction}\n`);
     const externalContext = applyExternalStageContext({ context, stageRoot: root, promptPath, ...(input.externalContext ? { loaded: input.externalContext } : {}) });
-    if (prepared.matrix)
-        fs.appendFileSync(promptPath, verificationMatrixInstruction(prepared.matrix.metadata, home, "designing the source PLAN and its tests"));
+    fs.appendFileSync(promptPath, verificationMatrixInstruction(prepared.matrix?.metadata ?? null, home, "designing the source PLAN and its tests"));
     fs.writeFileSync(path.join(root, "work-context.json"), JSON.stringify({ schema_id: "dd-flow/work-context@1", system: { run_id: run.id, work_id: planWorkId, stage: "plan" }, workspace: { project_root: projectRoot, workspace_root: run.workspace_root, stage_root: root }, artifacts: artifactMaterialization, input: { protocols, owned_obligations: Object.fromEntries(owned) } }, null, 2));
     const binding = bindStageCoordinatorWork(context, { workId: planWorkId, hookEventId: input.hookEventId, stage: "plan", promptPath, resultPath: path.join(root, "stage-report.json"), ...(input.contextSha256 ? { contextSha256: input.contextSha256 } : {}) });
     const attachmentInput = { projectRoot, runId: run.id, stage: "plan", dir: "03-plan", status: "running", dataSchemaId: "dd-flow/protocol-plan@6" };

package/dist/services/vnext-protocolize.js

@@ -5,7 +5,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
-import { AppError } from "../shared/errors.js";
+import { AppError, errorRecord, redactDiagnostic, diagnosticJson } from "../shared/errors.js";
 import { projectFeatureWorktreePath, resolveProjectRoot } from "../storage/paths.js";
 import { previewNextEntityId } from "./ids.js";
 import { registerProtocol } from "./protocols.js";
@@ -291,6 +291,7 @@ async function prepareProtocolizeIntent(context, run, resultFile, result, obliga
     const protocolIds = allocateProtocolIds(context, run.project_id, projectRoot, result.delivery.members.map(member => member.slug));
     const psetId = result.delivery.kind === "protocol_set" ? allocatePsetId(context, run.project_id, projectRoot, result.delivery.slug) : null;
     const draft = fs.mkdtempSync(path.join(os.tmpdir(), "dd-flow-protocolize-"));
+    let draftFailure;
     try {
         // A draft must never follow a workspace symlink back into the live tree.
         fs.cpSync(path.join(projectRoot, ".memory-bank"), path.join(draft, ".memory-bank"), { recursive: true, filter: source => !fs.lstatSync(source).isSymbolicLink() });
@@ -321,9 +322,24 @@ async function prepareProtocolizeIntent(context, run, resultFile, result, obliga
             return candidate;
         });
     }
+    catch (error) {
+        draftFailure = error;
+        throw error;
+    }
     finally {
+        cleanupProtocolizeDraft(draft, draftFailure);
+    }
+}
+function cleanupProtocolizeDraft(draft, failure) {
+    try {
         fs.rmSync(draft, { recursive: true, force: true });
     }
+    catch (cleanup) {
+        if (!failure)
+            throw new AppError("protocolize_draft_cleanup_failed", "PROTOCOLIZE draft cleanup failed", 1, { cause: errorRecord(cleanup), draft_path: draft, recoverable: false, effect: "unknown" });
+        const primary = failure;
+        primary.details = { ...primary.details, draft_cleanup_error: errorRecord(cleanup), draft_path: draft, recoverable: false };
+    }
 }
 function readProtocolizeIntent(context, projectId, runId, attempt) {
     const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.protocolize_intent' ORDER BY id DESC", [projectId]);
@@ -465,20 +481,115 @@ async function materialize(projectRoot, runId, runHome, result, obligations, ids
             const absolute = path.resolve(projectRoot, file);
             return created.some((directory) => absolute.startsWith(`${directory}${path.sep}`)) || absolute === psetPath;
         });
-        await runTargetedMemoryBankLint(projectRoot, materializedFiles);
+        await runTargetedMemoryBankLint(projectRoot, materializedFiles, path.join(runHome, "diagnostics"));
         return { files, before: Object.fromEntries([...originals].map(([file, bytes]) => [path.relative(projectRoot, file), bytes === null ? null : sha256(bytes)])) };
     }
     catch (error) {
-        for (const [file, content] of originals) {
-            if (content === null)
-                fs.rmSync(file, { force: true });
-            else
-                fs.writeFileSync(file, content);
+        const primary = error instanceof Error ? error : new AppError("protocolize_materialization_failed", String(error));
+        const facts = {};
+        try {
+            facts.diagnostic_path = captureMaterializationFailure(projectRoot, runHome, [...changed].sort(), primary);
         }
-        for (const dir of created.reverse())
-            fs.rmSync(dir, { recursive: true, force: true });
-        throw error;
+        catch (capture) {
+            facts.capture_error = errorRecord(capture);
+        }
+        const rollback = rollbackMaterialization(projectRoot, originals, created);
+        const target = primary;
+        target.details = { ...target.details, ...facts, rollback,
+            ...(rollback.unrestored.length ? { effect: "unknown", recoverable: false, disposition: "tooling_blocker" } : {}) };
+        throw primary;
+    }
+}
+export function rollbackMaterialization(projectRoot, originals, created) {
+    const restored = [], unrestored = [];
+    const restore = (file, action) => {
+        try {
+            action();
+            restored.push(path.relative(projectRoot, file));
+        }
+        catch (cause) {
+            unrestored.push({ path: path.relative(projectRoot, file), error: errorRecord(cause) });
+        }
+    };
+    for (const [file, content] of originals)
+        restore(file, () => { if (content === null)
+            fs.rmSync(file, { force: true });
+        else
+            fs.writeFileSync(file, content); });
+    for (const dir of [...created].reverse())
+        restore(dir, () => fs.rmSync(dir, { recursive: true, force: true }));
+    return { restored, unrestored };
+}
+export function captureMaterializationFailure(projectRoot, runHome, files, error) {
+    const directory = path.join(runHome, "diagnostics", `protocolize-${crypto.randomUUID()}`);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    let remaining = 1024 * 1024;
+    const documents = files.slice(0, 64).map(relative => {
+        const absolute = path.resolve(projectRoot, relative);
+        if (!absolute.startsWith(`${path.resolve(projectRoot)}${path.sep}`))
+            return { path: relative, unavailable: "outside_workspace" };
+        try {
+            assertNoSymlinkPath(path.resolve(projectRoot), absolute);
+            inside(fs.realpathSync(projectRoot), fs.realpathSync(absolute));
+            const info = fs.lstatSync(absolute);
+            if (!info.isFile())
+                return { path: relative, unavailable: "not_regular_file" };
+            // ponytail: bounded diagnostic hash, never chase a growing live file.
+            // Larger inputs retain a prefix hash explicitly marked incomplete.
+            const hash = crypto.createHash("sha256"), fd = fs.openSync(absolute, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            const chunk = Buffer.alloc(64 * 1024), parts = [];
+            let kept = 0, offset = 0, complete = false;
+            try {
+                const opened = fs.fstatSync(fd);
+                if (!opened.isFile() || opened.dev !== info.dev || opened.ino !== info.ino)
+                    throw new AppError("diagnostic_input_changed", "Diagnostic input changed before capture");
+                const limit = Math.min(opened.size, 1024 * 1024);
+                while (offset < limit) {
+                    const read = fs.readSync(fd, chunk, 0, Math.min(chunk.length, limit - offset), offset);
+                    if (!read)
+                        break;
+                    offset += read;
+                    hash.update(chunk.subarray(0, read));
+                    if (kept < Math.min(remaining, 65536)) {
+                        const part = Buffer.from(chunk.subarray(0, Math.min(read, Math.min(remaining, 65536) - kept)));
+                        parts.push(part);
+                        kept += part.length;
+                    }
+                }
+                const after = fs.fstatSync(fd), current = fs.lstatSync(absolute);
+                complete = offset === opened.size && after.size === opened.size && after.mtimeMs === opened.mtimeMs && after.ctimeMs === opened.ctimeMs
+                    && current.dev === opened.dev && current.ino === opened.ino;
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const content = Buffer.from(redactDiagnostic(Buffer.concat(parts).toString("utf8"))).subarray(0, Math.min(remaining, 65536)).toString("utf8");
+            remaining -= Buffer.byteLength(content);
+            const digest = hash.digest("hex");
+            return { path: relative, sha256: complete ? digest : null, ...(!complete ? { prefix_sha256: digest, hashed_bytes: offset } : {}), hash_complete: complete, size: info.size, truncated: kept < info.size, content };
+        }
+        catch (cause) {
+            return { path: relative, unavailable: errorRecord(cause) };
+        }
+    });
+    const file = path.join(directory, "failure.json");
+    const capture = { schema_id: "dd-flow/protocolize-failure@1", error: errorRecord(error), documents, omitted_documents: Math.max(0, files.length - documents.length) };
+    let bytes = diagnosticJson(capture);
+    while (Buffer.byteLength(bytes) > 1024 * 1024) {
+        const contentLength = (document) => "content" in document ? String(document.content ?? "").length : 0;
+        const largest = documents.filter(document => contentLength(document) > 0).sort((a, b) => contentLength(b) - contentLength(a))[0];
+        if (largest && "content" in largest) {
+            largest.content = String(largest.content).slice(0, Math.floor(String(largest.content).length / 2));
+            largest.truncated = true;
+        }
+        else {
+            documents.pop();
+            capture.omitted_documents++;
+        }
+        bytes = diagnosticJson(capture);
     }
+    fs.writeFileSync(file, bytes, { flag: "wx", mode: 0o600 });
+    return file;
 }
 function protocolMarkdown(id, member, blockedBy, runId, psetPath, featurePath, result, obligations, rawIntakePath) {
     const a = member.primary_acceptance;

package/dist/services/worktrees.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { flowContractForState } from "../domain/flow-contract.js";
 import { requireStage } from "../domain/validation.js";
-import { AppError } from "../shared/errors.js";
+import { AppError, processEvidence, redactDiagnostic } from "../shared/errors.js";
 import { canonicalPath, projectCheckoutRoot, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { persistProtocolState, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
@@ -259,20 +259,23 @@ function activeWorktreeRecord(context, projectId, protocolId) {
 async function runExternal(command) {
     const [bin, ...args] = command;
     if (!bin) {
-        return { exit_code: null, stdout: "", stderr: "Missing executable." };
+        return { exit_code: null, signal: null, stdout: "", stderr: "Missing executable." };
     }
     const result = await commandResult(bin, args, { startupMs: SETUP_STARTUP_MS });
+    const evidence = processEvidence(result);
     return {
         exit_code: result.exit_code,
-        stdout: sanitizeOutput(result.stdout),
-        stderr: sanitizeOutput(result.stderr)
+        signal: result.signal,
+        stdout: result.exit_code === 0 && !result.signal ? sanitizeOutput(result.stdout) : evidence.stdout.text,
+        stderr: evidence.stderr.text,
+        output_truncated: { stdout: result.exit_code !== 0 && evidence.stdout.truncated, stderr: evidence.stderr.truncated }
     };
 }
 function sanitizeCommand(command) {
     return command.map((part) => (part.includes("=") ? part.replace(/=.*/, "=<redacted>") : part));
 }
 function sanitizeOutput(value) {
-    return value.replace(/(token|secret|password)=\S+/gi, "$1=<redacted>");
+    return redactDiagnostic(value);
 }
 function parseWorktrunkResponse(stdout, command) {
     let parsed;

package/dist/shared/errors.js

@@ -1,4 +1,5 @@
-import { errorRecord as nativeErrorRecord } from "../harness-runtime/lib/operation-errors.mjs";
+import { errorRecord as nativeErrorRecord, redactDiagnostic } from "../harness-runtime/lib/operation-errors.mjs";
+export { redactDiagnostic, diagnosticJson } from "../harness-runtime/lib/operation-errors.mjs";
 export class AppError extends Error {
     code;
     exitCode;
@@ -29,3 +30,12 @@ export function errorRecord(error, depth = 0) {
 export function isAppError(error) {
     return error instanceof AppError;
 }
+/** Bounded process diagnostics are observations, never command/retry authority. */
+export function processEvidence(result) {
+    const excerpt = (value, limit) => {
+        const safe = redactDiagnostic(value), bytes = Buffer.from(safe);
+        return { text: new TextDecoder().decode(bytes.subarray(0, limit), { stream: true }), truncated: bytes.length > limit, bytes: bytes.length };
+    };
+    return { exit_code: result.exit_code, signal: result.signal ?? null,
+        stdout: excerpt(result.stdout, 8192), stderr: excerpt(result.stderr, 16384) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.140",
+  "version": "0.9.0-beta.141",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "packageManager": "pnpm@10.23.0",