@deksden-com/dd-flow-cli 0.9.0-beta.151 → 0.9.0-beta.152

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.151",
-  "cli_commit": "89cad0d654601de59b12929240eee4e958b74207",
-  "built_at": "2026-10-25T10:59:05.638Z",
+  "cli_version": "0.9.0-beta.152",
+  "cli_commit": "70ed6da341845d1b7f262b74f6731ac4787aff73",
+  "built_at": "2026-10-26T03:31:35.940Z",
   "built_with_canon": {
     "version": "4.1.2",
     "commit": "925ef10ecc0b683f7feba6f74913e15560842500",

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

@@ -14,7 +14,7 @@ import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, tr
 import { waitForSettlement } from "./session-settlement.mjs";
 import { nativeExecutionReceipt } from "./native-children.mjs";
 import { errorRecord, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
-import { checkObservedProfile, observeModel } from "./model-observations.mjs";
+import { checkObservedProfile, observeModel, observedFields, readModelObservations } from "./model-observations.mjs";
 import os from "node:os";
 import path from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
@@ -202,6 +202,15 @@ export class Runtime {
     const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: root, cwd: info.directory };
     this.sessions.set(id, record); return record;
   }
+  registerObservedChild(info, root) {
+    const owner = this.sessions.get(root);
+    if (!owner || owner.parent_provider_session_id || owner.root_provider_session_id !== root
+      || info.id === root || info.parentID !== root || info.fork)
+      throw new DaemonError("session_identity_mismatch", "OpenCode child is not a direct member of the owned root");
+    if (typeof info.directory !== "string" || !path.isAbsolute(info.directory))
+      throw new OpenCodeError("opencode_unavailable", "OpenCode child directory binding is not yet observable");
+    return this.retainSession(info, root);
+  }
   async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
   async childTree(id, seen = new Set()) {
     if (seen.has(id)) throw new DaemonError("session_identity_mismatch", "OpenCode native topology contains a cycle");
@@ -299,17 +308,52 @@ export class Runtime {
     return nativeExecutionReceipt(receipt, { daemonId: this.state.daemon_id, revision: before.get(id) ?? 0 });
   }
   async observeModels(id, messages, parent = null) {
-    this.modelMessages ??= new Set();
+    const journal = this.state.config.journal ?? this.paths.journal;
+    if (!this.modelMessages) {
+      this.modelMessages = new Map();
+      for (const event of journal ? await readModelObservations(journal) : []) {
+        if (event.harness !== 'opencode-server' || event.source?.method !== 'session/message' || !event.source.message_id) continue;
+        const key = `${event.session_id}:${event.source.message_id}`;
+        if (event.evidence_conflict) { const prior = this.modelMessages.get(key); if (prior) prior.conflicted = true; continue; }
+        if (!this.modelMessages.has(key)) this.modelMessages.set(key, { source: event.source,
+          known: { parent: event.parent_session_id, root: event.native_agent_role?.launch?.root_session_id,
+            role: event.native_agent_role ?? null, requested: observedFields(event.requested), observed: observedFields(event.observed) } });
+      }
+    }
     for (const message of messages ?? []) {
       const info = message.info;
-      if (info?.role !== "assistant" || !info.id || this.modelMessages.has(info.id)) continue;
+      if (info?.role !== "assistant" || !info.id) continue;
       if (info.sessionID && info.sessionID !== id) throw new DaemonError("session_identity_mismatch", "native message belongs to another Session");
-      await observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
-        requested: { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent },
-        nativeAgentRole: this.state.config.workerLaunchConfig ? { name: info.mode ?? null, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
-          launch: { ...this.state.config.workerLaunchConfig, root_session_id: this.sessions.get(id)?.root_provider_session_id ?? null } } : null,
-        observed: { provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode }, source: { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}:${info.modelID}`).digest("hex") }, evidence: "response" });
-      this.modelMessages.add(info.id);
+      const record = this.sessions.get(id);
+      if (record && (record.parent_provider_session_id ?? null) !== parent)
+        throw new DaemonError("session_identity_mismatch", "OpenCode observed message parent changed");
+      if (!record?.root_provider_session_id || !info.mode) {
+        await observeModel({ journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
+          source: { channel: "native.message_observer", scope: "response", non_asserting: true }, evidence: "unavailable", reason: "native_role_binding_unavailable" });
+        continue;
+      }
+      const requested = { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent };
+      const nativeAgentRole = this.state.config.workerLaunchConfig ? { name: info.mode, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
+        launch: { ...this.state.config.workerLaunchConfig, root_session_id: record.root_provider_session_id } } : null;
+      const observed = observedFields({ provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode });
+      const tuple = { parent, root: record.root_provider_session_id, role: nativeAgentRole, requested: observedFields(requested), observed };
+      const key = `${id}:${info.id}`, previous = this.modelMessages.get(key);
+      if (previous?.conflicted) throw new DaemonError("model_observation_identity_conflict", "OpenCode native message has a retained identity/profile conflict", false, { session_id: id, message_id: info.id });
+      const conflicts = (before, after) => before != null && after != null && (typeof before === "object" && typeof after === "object"
+        ? [...new Set([...Object.keys(before), ...Object.keys(after)])].some(field => conflicts(before[field], after[field])) : before !== after);
+      if (previous && !conflicts(previous.known, tuple)) {
+        // Optional disclosure can arrive late. Do not rewrite the old native fact;
+        // remember known values only to detect a later positive contradiction.
+        for (const [field, value] of Object.entries(observed)) if (value != null) previous.known.observed[field] = value;
+        continue;
+      }
+      const source = previous?.source ?? { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}`).digest("hex") };
+      const published = await observeModel({ journal, harness: "opencode-server", sessionId: id, parentSessionId: parent, requested, nativeAgentRole, observed, source, evidence: "response" });
+      if (previous || published?.evidence_conflict) {
+        if (previous) previous.conflicted = true;
+        throw new DaemonError("model_observation_identity_conflict", "OpenCode native message changed its published identity/profile", false, { session_id: id, message_id: info.id });
+      }
+      this.modelMessages.set(key, { known: structuredClone(tuple), source });
     }
   }
   async requireSettled(id) {
@@ -462,6 +506,9 @@ export class Runtime {
       assertDispatch, checkHookFailures, livenessTimeoutMs: params.livenessTimeoutMs ?? this.client.timeoutMs,
       onDispatched: () => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: params.sessionId }),
       onModelMessages: (id, messages, parent) => this.observeModels(id, messages, parent),
+      onNativeSession: (info, root) => this.registerObservedChild(info, root),
+      rootSessionId: this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId,
+      parentSessionId: this.sessions.get(params.sessionId)?.parent_provider_session_id ?? null,
       onObservationError: error => observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: params.sessionId, requested: this.state.config, source: "native.message_observer", evidence: "unavailable", reason: error.code ?? "observation_unavailable" })
     }); await checkHookFailures(); }
       finally { current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; }

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

@@ -169,13 +169,32 @@ export class OpenCodeClient {
   import(data) { return this.call("session.import", data, { productive: true }); }
 
   async prompt(id, { prompt, messageId = `msg_${randomUUID().replaceAll("-", "")}`, retained,
-    save, onModelMessages, onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
+    save, onModelMessages, onNativeSession, rootSessionId = id, parentSessionId = null,
+    onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
     validateObservationDuration(livenessTimeoutMs);
     const request = { sessionID: id, id: messageId, text: prompt, delivery: "queue", resume: true }, digest = requestDigest(request);
     if (retained && (retained.request_sha256 !== digest || retained.message_id !== messageId)) throw new OpenCodeError("operation_request_mismatch", "OpenCode operation already binds another prompt", false, { effect: "no_effect" });
     let state = retained ?? { message_id: messageId, request_sha256: digest, phase: "prepared", cursor: 0 };
-    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map();
-    const capture = async session => { for (const child of await this.children(session)) { parents.set(child.id, child.parentID); baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id))); await capture(child.id); } };
+    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map([[id, parentSessionId]]);
+    // The same native lineage guard applies before dispatch and while polling.
+    // Registration precedes message publication; a list ID alone is not ownership.
+    const childrenOf = async (session, visited) => {
+      const children = await this.children(session);
+      for (const child of children) {
+        if (!child?.id || child.parentID !== session || child.fork || session !== rootSessionId || visited.has(child.id)
+          || parents.has(child.id) && parents.get(child.id) !== session || visited.size >= 1024)
+          throw new OpenCodeError("session_identity_mismatch", "OpenCode native child lineage is invalid", false, { session_id: child?.id, parent_session_id: session });
+        visited.add(child.id); parents.set(child.id, session);
+        await onNativeSession?.(child, rootSessionId);
+      }
+      return children;
+    };
+    const capture = async (session, visited = new Set([id])) => {
+      for (const child of await childrenOf(session, visited)) {
+        baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id)));
+        await capture(child.id, visited);
+      }
+    };
     await capture(id);
     if (retained) {
       const index = previous.findIndex(item => item.info.id === messageId);
@@ -258,8 +277,8 @@ export class OpenCodeClient {
           }
           if (state.cursor !== watermark) { state = { ...state, cursor: watermark }; await save?.(state); }
           let runningTools = false;
-          const observe = async (session, visited = new Set()) => {
-            if (visited.has(session)) throw lost("OpenCode topology contains a cycle"); visited.add(session); known.add(session);
+          const observe = async (session, visited = new Set([id])) => {
+            known.add(session);
             const messages = await this.messages(session);
             await onModelMessages?.(session, messages, parents.get(session) ?? null);
             const floor = baseline.get(session) ?? new Set(), current = messages.filter(item => item.info.role === "assistant" && !floor.has(item.info.id));
@@ -291,10 +310,7 @@ export class OpenCodeClient {
                 }
               }
             }
-            for (const child of await this.children(session)) {
-              if (child.parentID !== session) throw lost("OpenCode child has a foreign parent");
-              parents.set(child.id, session); await observe(child.id, visited);
-            }
+            for (const child of await childrenOf(session, visited)) await observe(child.id, visited);
             return current;
           };
           const current = await observe(id), rootMessages = await this.messages(id);
@@ -309,8 +325,9 @@ export class OpenCodeClient {
                 // Native messages and topology are separate reads: a child can
                 // finish between them. Reconcile its ancestry before rejecting
                 // the notification, never trust the notification alone.
-                const child = (await this.children(id)).find(child => child.id === item.info.metadata.childID && child.parentID === id);
-                if (child) { parents.set(child.id, id); await observe(child.id); }
+                const visited = new Set([id]);
+                const child = (await childrenOf(id, visited)).find(child => child.id === item.info.metadata.childID);
+                if (child) await observe(child.id, visited);
               }
               if (item.info.role === "user" || item.info.role === "synthetic" && !(
                 item.info.metadata?.source === "subagent" && parents.get(item.info.metadata.childID) === id
@@ -353,7 +370,8 @@ export class OpenCodeClient {
           }
         } catch (error) {
           await checkHookFailures?.();
-          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)) throw error;
+          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)
+            || ["session_identity_mismatch", "model_observation_identity_conflict"].includes(error.code)) throw error;
           await onObservationError?.(error);
         }
         if (clock.sample(marker)) throw lost("OpenCode native progress stopped or observation could not recover", { session_id: id, message_id: messageId, observation: clock.state(), ...(observationErrors.count ? { observation_errors: observationErrors } : {}) });

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

@@ -5,8 +5,8 @@ import { parse } from "shell-quote";
 import { AppError } from "../shared/errors.js";
 import { validateObservationDuration } from "../harness-runtime/lib/observation-clock.mjs";
 import { isDeepStrictEqual } from "node:util";
-import { runnerFailureValid, validateRunnerProof, validatedRunnerChild, hasValidatedNativeProof, hasValidatedBrowserProof, hasUnsupportedObservation } from "./check-runner-proof.js";
-export { candidateAbsencesValid, runnerFailureValid, runnerEvidencePass, runnerProofArtifacts } from "./check-runner-proof.js";
+import { runnerFailureValid, validateRunnerProof, validatedRunnerChild, hasValidatedNativeProof, hasValidatedBrowserProof, hasUnsupportedObservation, runnerLibraryInputs } from "./check-runner-proof.js";
+export { candidateAbsencesValid, candidateLibraryInputsValid, runnerFailureValid, runnerEvidencePass, runnerProofArtifacts } from "./check-runner-proof.js";
 const absoluteFile = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0") && path.isAbsolute(value);
 function candidateFile(root, file) {
     if (!root || !path.isAbsolute(file))
@@ -45,6 +45,28 @@ export function candidateFailureFiles(evidence, root) {
             }
         }))];
 }
+export function candidateLibraryInputs(evidence, root) {
+    const inputs = new Map();
+    for (const failure of evidence?.failures ?? []) {
+        const child = validatedRunnerChild(failure);
+        const candidates = child ? candidateLibraryInputs({ ...child.evidence, failures: [child.failure] }, root)
+            : failure.repair_evidence?.rule === "candidate_library_query_error" ? runnerLibraryInputs(failure.repair_evidence) ?? [] : [];
+        try {
+            if (candidates.some(input => !candidateFile(root, input.file) || crypto.createHash("sha256").update(readBoundedProofFile(input.file, 2 * 1024 * 1024)).digest("hex") !== input.sha256))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        for (const input of candidates)
+            inputs.set(input.file, input.sha256);
+    }
+    return [...inputs].map(([file, sha256]) => ({ file, sha256 }));
+}
+/** Current execution/repair boundary only; historical readers retain captured proof. */
+export function currentCandidateLibraryInputsValid(receipt, workspaceRoot) {
+    return isDeepStrictEqual(receipt.candidate_library_inputs ?? [], candidateLibraryInputs(receipt.runner_evidence, workspaceRoot));
+}
 function absentCandidate(root, file) {
     if (!root || !absoluteFile(file))
         return false;
@@ -104,10 +126,10 @@ export function candidateFailureAbsences(evidence, root) {
         }
     });
 }
-function candidateFailure(failure, evidence, root, capturedFiles, capturedAbsences) {
+function candidateFailure(failure, evidence, root, capturedFiles, capturedAbsences, capturedLibraryInputs) {
     const child = validatedRunnerChild(failure);
     if (child)
-        return candidateFailure(child.failure, child.evidence, root, capturedFiles, capturedAbsences);
+        return candidateFailure(child.failure, child.evidence, root, capturedFiles, capturedAbsences, capturedLibraryInputs);
     const owned = (file) => {
         if (capturedFiles !== undefined)
             return capturedFiles.includes(file);
@@ -126,6 +148,11 @@ function candidateFailure(failure, evidence, root, capturedFiles, capturedAbsenc
     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_library_query_error") {
+        const required = runnerLibraryInputs(proof), captured = capturedFiles !== undefined ? capturedLibraryInputs : root ? candidateLibraryInputs({ ...evidence, failures: [failure] }, root) : undefined;
+        return hasValidatedNativeProof(proof) && failure.category === "unclassified" && failure.origin === "candidate" && failure.phase === "test" && failure.native_code === proof.exception_type
+            && failure.test_id === proof.test_id && failure.file === proof.file && owned(proof.file) && Boolean(required?.length && captured && required.every(input => captured.some(item => item.file === input.file && item.sha256 === input.sha256)));
+    }
     if (proof?.rule === "candidate_test_runtime_error")
         return hasValidatedNativeProof(proof) && failure.category === "unclassified" && failure.origin === "candidate"
             && failure.phase === proof.phase && failure.native_code === proof.exception_type && failure.file === proof.file && owned(proof.file);
@@ -266,12 +293,15 @@ export function checkRepairDisposition(receipt) {
         return "tooling_blocker";
     if (!evidence.completed)
         return "unclassified";
-    if (evidence.failures.some(f => !runnerFailureValid(f) || !candidateFailure(f, evidence, receipt.candidate_root, receipt.candidate_files, receipt.candidate_absences)))
+    if (evidence.failures.some(f => !runnerFailureValid(f) || !candidateFailure(f, evidence, receipt.candidate_root, receipt.candidate_files, receipt.candidate_absences, receipt.candidate_library_inputs)))
         return "unclassified";
     return "source_repair";
 }
-export function assertSourceRepairEligible(receipts) {
-    const blockers = receipts.filter(receipt => checkRepairDisposition(receipt) !== "source_repair");
-    if (!receipts.length || blockers.length)
-        throw new AppError("check_gate_blocked", "Checks require tooling diagnosis or settlement before product repair; retained nonzero is not a candidate-source verdict", 2, { failures: receipts, dispositions: receipts.map(receipt => ({ check_receipt_id: receipt.id, disposition: checkRepairDisposition(receipt) })), outcome: "blocked", recoverable: false, instruction: "Inspect retained runner evidence. Do not change product code to repair tooling, unknown observation or unclassified failure. Retry only after establishing and correcting the cause." });
+export function assertSourceRepairEligible(receipts, workspaceRoot) {
+    const dispositions = receipts.map(receipt => {
+        const drift = workspaceRoot !== undefined && !currentCandidateLibraryInputsValid(receipt, workspaceRoot);
+        return { check_receipt_id: receipt.id, disposition: drift ? "tooling_blocker" : checkRepairDisposition(receipt), ...(drift ? { reason: "candidate_library_inputs_changed" } : {}) };
+    });
+    if (!receipts.length || dispositions.some(item => item.disposition !== "source_repair"))
+        throw new AppError("check_gate_blocked", "Checks require tooling diagnosis or settlement before product repair; retained nonzero is not a candidate-source verdict", 2, { failures: receipts, dispositions, outcome: "blocked", recoverable: false, instruction: "Inspect retained runner evidence. Do not change product code to repair tooling, unknown observation or unclassified failure. Retry only after establishing and correcting the cause." });
 }

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

@@ -8,11 +8,13 @@ function boundedString(value, bytes) { return typeof value === "string" && Buffe
 const validatedBrowserProofs = new WeakSet();
 const unsupportedObservationContracts = new WeakSet();
 const validatedNativeProofs = new WeakSet();
+const validatedLibraryInputs = new WeakMap();
 const validatedChildren = new WeakMap();
 const validatedReports = new WeakMap();
 const hash = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 const absoluteFile = (value) => typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.includes("\0") && path.isAbsolute(value);
 export function candidateAbsencesValid(value) { return Array.isArray(value) && value.length <= 64 && value.every(item => object(item) && absoluteFile(item.file) && item.path_state === "missing" && object(item.declaration) && absoluteFile(item.declaration.file) && hash(item.declaration.sha256)); }
+export function candidateLibraryInputsValid(value) { return Array.isArray(value) && value.length <= 64 && new Set(value.map(item => object(item) ? item.file : null)).size === value.length && value.every(item => object(item) && absoluteFile(item.file) && hash(item.sha256)); }
 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) {
@@ -35,6 +37,13 @@ export function runnerFailureValid(value) {
         return false;
     if (value.repair_evidence !== undefined) {
         const proof = value.repair_evidence;
+        if (object(proof) && proof.rule === "candidate_library_query_error")
+            return proof.exception_type === "TestingLibraryElementError" && proof.phase === "test"
+                && boundedString(proof.test_id, 4096) && Boolean(proof.test_id) && absoluteFile(proof.file) && hash(proof.file_sha256)
+                && [proof.line, proof.column].every(n => Number.isSafeInteger(n) && Number(n) > 0) && object(proof.library)
+                && proof.library.name === "@testing-library/dom" && proof.library.version === "10.4.1" && hash(proof.library.package_json_sha256) && hash(proof.library.lockfile_sha256)
+                && Array.isArray(proof.helper_frames) && proof.helper_frames.length >= 2 && proof.helper_frames.length <= 8
+                && proof.helper_frames.every(frame => object(frame) && absoluteFile(frame.file) && hash(frame.file_sha256) && [frame.line, frame.column].every(n => Number.isSafeInteger(n) && Number(n) > 0)) && proofArtifact(proof.native_artifact);
         if (object(proof) && proof.rule === "candidate_test_runtime_error")
             return ["TypeError", "ReferenceError", "Error"].includes(String(proof.exception_type)) && (proof.exception_type !== "Error" || proof.phase === "test")
                 && absoluteFile(proof.file) && hash(proof.file_sha256) && ["test", "setup", "collection"].includes(String(proof.phase))
@@ -82,6 +91,62 @@ function readProofArtifact(root, ref, context, limit = 2 * 1024 * 1024) {
         throw new Error("Invalid proof object");
     return value;
 }
+// Exact known helper bytes keep this a library-specific proof, not permission
+// to skip arbitrary dependency frames. New versions need explicit evidence.
+const queryInputHashes = {
+    "dist/config.js": "3627f6265cccd26604777602d7249788c2347a273bdd1cae41719c790f2c5a7a",
+    "dist/query-helpers.js": "901f513f2ac901992d7c5002e644aef69286edbcd7d050d3ee7dd6aaaebfc9cc",
+    "package.json": "4e62e2aa8b974b6a5d2d532396f7610d1b4e806d9d2aaef3c84221f0d2fab06d",
+};
+function validateLibraryQuery(root, proof, failure, evidence, context) {
+    const native = readProofArtifact(root, proof.native_artifact, context, 256 * 1024);
+    const facts = Object.fromEntries(Object.entries(proof).filter(([key]) => key !== "native_artifact"));
+    if (evidence.schema_id !== "dd-flow/check-runner-evidence@2" || !isDeepStrictEqual(native.binding, evidence.binding)
+        || Object.entries(facts).some(([key, value]) => !isDeepStrictEqual(native[key], value)) || native.executing_file !== proof.file || native.exception_name !== proof.exception_type
+        || failure.category !== "unclassified" || failure.origin !== "candidate" || failure.native_code !== proof.exception_type || failure.phase !== "test" || failure.test_id !== proof.test_id || failure.file !== proof.file
+        || native.stack_complete !== true || native.frames_complete !== true || !Array.isArray(native.frame_lines) || native.frame_lines.length !== proof.helper_frames.length + 1
+        || native.frame_lines.some(line => !boundedString(line, 4096)) || Buffer.byteLength(JSON.stringify(native.frame_lines)) > 128 * 1024)
+        return false;
+    const expectedFrames = [...proof.helper_frames, { file: proof.file, line: proof.line, column: proof.column }];
+    for (const [index, line] of native.frame_lines.entries()) {
+        const match = String(line).match(/^\s*at (?:.*?\()?((?:file:\/\/)?\/[^\n]+):(\d+):(\d+)\)?$/), expected = expectedFrames[index];
+        if (!match || (match[1].startsWith("file:") ? fileURLToPath(match[1]) : match[1]) !== expected.file || Number(match[2]) !== expected.line || Number(match[3]) !== expected.column)
+            return false;
+    }
+    const packageRoot = path.dirname(path.dirname(proof.helper_frames[0].file));
+    if (proof.helper_frames[0].file !== path.join(packageRoot, "dist/config.js") || !String(native.frame_lines[0]).includes("getElementError")
+        || proof.helper_frames.slice(1).some(frame => frame.file !== path.join(packageRoot, "dist/query-helpers.js")))
+        return false;
+    if (!Array.isArray(native.library_inputs) || native.library_inputs.length !== 4)
+        return false;
+    const inputs = [];
+    let packageJson;
+    for (const [index, value] of native.library_inputs.entries()) {
+        if (!object(value) || !absoluteFile(value.file) || !hash(value.sha256) || !proofArtifact(value.artifact))
+            return false;
+        const expectedName = Object.keys(queryInputHashes)[index];
+        if (expectedName ? value.file !== path.join(packageRoot, expectedName) || value.sha256 !== queryInputHashes[expectedName]
+            : path.basename(value.file) !== "pnpm-lock.yaml" || value.sha256 !== proof.library.lockfile_sha256)
+            return false;
+        const bytes = readBytes(context, path.posix.join(root, value.artifact.relative_path), 2 * 1024 * 1024);
+        if (crypto.createHash("sha256").update(bytes).digest("hex") !== value.sha256 || value.artifact.sha256 !== value.sha256)
+            return false;
+        if (index === 2)
+            packageJson = JSON.parse(bytes.toString("utf8"));
+        if (index === 3 && !bytes.toString("utf8").includes("@testing-library/dom@10.4.1"))
+            return false;
+        inputs.push({ file: value.file, sha256: value.sha256, artifact: value.artifact });
+    }
+    if (packageJson?.name !== proof.library.name || packageJson.version !== proof.library.version || inputs[2].sha256 !== proof.library.package_json_sha256
+        || proof.helper_frames.some(frame => inputs.find(input => input.file === frame.file)?.sha256 !== frame.file_sha256))
+        return false;
+    const candidateRoot = path.dirname(inputs[3].file);
+    if ([proof.file, ...inputs.map(input => input.file)].some(file => { const relative = path.relative(candidateRoot, file); return !relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative); }))
+        return false;
+    validatedLibraryInputs.set(proof, inputs);
+    validatedNativeProofs.add(proof);
+    return true;
+}
 function matches(actual, expected) { return object(actual) && Object.entries(expected).every(([key, value]) => actual[key] === value); }
 function validateBrowserArtifacts(root, proof, binding, context) {
     const snapshot = readProofArtifact(root, proof.worker_snapshot, context), native = readProofArtifact(root, proof.native_result, context);
@@ -104,7 +169,7 @@ export function runnerProofArtifacts(evidence) {
                 if (child && failure.child_evidence)
                     return [failure.child_evidence.report.relative_path, ...runnerProofArtifacts(child.evidence).map(file => path.posix.join(path.posix.dirname(failure.child_evidence.report.relative_path), file))];
                 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] : proof && "native_artifact" in proof ? [proof.native_artifact.relative_path] : [])];
+                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] : proof && "native_artifact" in proof ? [proof.native_artifact.relative_path, ...(proof.rule === "candidate_library_query_error" ? (validatedLibraryInputs.get(proof) ?? []).map(input => input.artifact.relative_path) : [])] : [])];
             }), ...(evidence ? validatedReports.get(evidence) ?? [] : []).flatMap(child => [child.report.relative_path, ...runnerProofArtifacts(child.evidence).map(file => path.posix.join(path.posix.dirname(child.report.relative_path), file))])])];
 }
 function diagnostic(context, value) {
@@ -224,6 +289,8 @@ function readRunnerEvidenceInternal(root, contract, binding, depth, budget, cont
             if (failure.diagnostic_artifact && !matches(readProofArtifact(root, failure.diagnostic_artifact, context, 2 * 1024 * 1024).binding, binding))
                 return null;
             const proof = failure.repair_evidence;
+            if (proof?.rule === "candidate_library_query_error" && !validateLibraryQuery(root, proof, failure, evidence, context))
+                return null;
             if (proof?.rule === "candidate_migration_sql" || proof?.rule === "candidate_tool_diagnostic" || proof?.rule === "candidate_test_runtime_error") {
                 const native = readProofArtifact(root, proof.native_artifact, context, 2 * 1024 * 1024), facts = Object.fromEntries(Object.entries(proof).filter(([key]) => key !== "native_artifact"));
                 if (!isDeepStrictEqual(native.binding, binding) || Object.entries(facts).some(([key, value]) => !isDeepStrictEqual(native[key], value)))
@@ -301,5 +368,6 @@ function readRunnerEvidenceInternal(root, contract, binding, depth, budget, cont
 export function runnerEvidencePass(evidence) { return Boolean(evidence?.completed && !evidence.failure_projection && !evidence.observation_unknown && evidence.counts.failed === 0 && evidence.failures.length === 0); }
 export const validatedRunnerChild = (failure) => validatedChildren.get(failure);
 export const hasValidatedNativeProof = (proof) => validatedNativeProofs.has(proof);
+export const runnerLibraryInputs = (proof) => validatedLibraryInputs.get(proof)?.map(({ file, sha256 }) => ({ file, sha256 }));
 export const hasValidatedBrowserProof = (proof) => validatedBrowserProofs.has(proof);
 export const hasUnsupportedObservation = (evidence) => unsupportedObservationContracts.has(evidence);

package/dist/services/code-checks.js

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { candidateAbsencesValid, candidateFailureAbsences, candidateFailureFiles, checkRepairDisposition, readRunnerEvidence, readRunnerEvidenceDetailed, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations, runnerProofArtifacts } from "./check-runner-evidence.js";
+import { candidateAbsencesValid, candidateFailureAbsences, candidateFailureFiles, candidateLibraryInputs, candidateLibraryInputsValid, currentCandidateLibraryInputsValid, checkRepairDisposition, readRunnerEvidence, readRunnerEvidenceDetailed, 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";
@@ -352,7 +352,7 @@ export class PreparedCheckEvidence {
                     candidates: receipts.filter(item => item.scope === input.scope && item.work_id === (input.workId ?? null))
                         .slice(-16).map(item => ({ id: item.id, input_hash: item.input_hash, profile_hash: item.profile_hash }))
                 });
-            if (!checkReceiptEvidenceValidForMode(bindReceipt(receipt, group), input.mode))
+            if (!checkReceiptEvidenceValidForMode(bindReceipt(receipt, group), input.mode) || !currentCandidateLibraryInputsValid(receipt, input.workspaceRoot))
                 fail();
             passed = passed && receipt.status === "passed";
             for (const artifact of receipt.artifacts)
@@ -666,8 +666,9 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
             physicalFailures.push(result.failure);
         const candidateFiles = candidateFailureFiles(runnerEvidence, input.workspaceRoot);
         const candidateAbsences = candidateFailureAbsences(runnerEvidence, input.workspaceRoot);
+        const libraryInputs = candidateLibraryInputs(runnerEvidence, input.workspaceRoot);
         if (group.runnerEvidence)
-            retainExecutionOutcome(evidenceDir, { id, command: group.command, input_hash: inputHash, verification_epoch: epoch, fingerprint_scope: "check_inputs", input_manifest: reserved.inputManifest ?? null, execution_contract_hash: executionContractHash }, input.workspaceRoot, physicalFailures, candidateFiles, candidateAbsences);
+            retainExecutionOutcome(evidenceDir, { id, command: group.command, input_hash: inputHash, verification_epoch: epoch, fingerprint_scope: "check_inputs", input_manifest: reserved.inputManifest ?? null, execution_contract_hash: executionContractHash }, input.workspaceRoot, physicalFailures, candidateFiles, candidateAbsences, libraryInputs);
         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";
@@ -676,6 +677,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         receipt.candidate_root = input.workspaceRoot;
         receipt.candidate_files = candidateFiles;
         receipt.candidate_absences = candidateAbsences;
+        receipt.candidate_library_inputs = libraryInputs;
         receipt.execution_failures = physicalFailures;
         context.db.run("UPDATE check_receipts SET execution_failures_json = ? WHERE project_id = ? AND id = ? AND status = 'running'", [JSON.stringify(physicalFailures), input.projectId, id]);
         const completion = readCompletion(completionPath);
@@ -768,6 +770,7 @@ export function reconcileUnfinishedChecks(context, input) {
             physicalFailures.push({ code: "completion_snapshot_unknown", message: "Detached check has no bound scoped completion snapshot; current inputs cannot prove inputs at command completion" });
         let candidateFiles = candidateFailureFiles(runnerEvidence, input.workspaceRoot);
         let candidateAbsences = candidateFailureAbsences(runnerEvidence, input.workspaceRoot);
+        let libraryInputs = candidateLibraryInputs(runnerEvidence, input.workspaceRoot);
         if (receipt?.runner_evidence_required) {
             const evidenceDir = path.join(path.dirname(pendingReceipt.receipt_path), "artifacts");
             if (fs.existsSync(path.join(evidenceDir, "engine-outcome.json"))) {
@@ -778,13 +781,14 @@ export function reconcileUnfinishedChecks(context, input) {
                     physicalFailures.push(...(proven.execution_failures ?? []));
                     candidateFiles = proven.candidate_files ?? candidateFiles;
                     candidateAbsences = proven.candidate_absences ?? [];
+                    libraryInputs = proven.candidate_library_inputs ?? [];
                 }
                 else {
                     physicalFailures.push({ code: "engine_outcome_unbound", message: "Existing execution outcome is not bound to retained inventory; prior launcher/cleanup outcome is unknown" });
                     fs.renameSync(path.join(evidenceDir, "engine-outcome.json"), path.join(evidenceDir, `engine-outcome-unconfirmed-${crypto.randomUUID()}.json`));
                 }
             }
-            retainExecutionOutcome(evidenceDir, receipt, input.workspaceRoot, physicalFailures, candidateFiles, candidateAbsences);
+            retainExecutionOutcome(evidenceDir, receipt, input.workspaceRoot, physicalFailures, candidateFiles, candidateAbsences, libraryInputs);
             receipt.required_artifacts = [...new Set([...(receipt.required_artifacts ?? []), ...runnerProofArtifacts(runnerEvidence), "engine-outcome.json"])];
             artifacts = collectCheckArtifacts(evidenceDir, receipt.required_artifacts);
         }
@@ -798,6 +802,7 @@ export function reconcileUnfinishedChecks(context, input) {
             repaired.candidate_root = input.workspaceRoot;
             repaired.candidate_files = candidateFiles;
             repaired.candidate_absences = candidateAbsences;
+            repaired.candidate_library_inputs = libraryInputs;
             repaired.execution_failures = physicalFailures;
             writeReceipt(pendingReceipt.receipt_path, repaired);
             if (status === "failed")
@@ -824,6 +829,11 @@ function reserveOrReuseReceipt(context, input) {
     const sourceCorrection = Boolean(retryPredecessor && (sourceRepairContractMatches(retryPredecessor, input.group, input.profileHash)
         || input.retryReason === "check_inputs_changed" && staleRetryContractMatches(retryPredecessor, input.group, input.profileHash, input)));
     const latestContract = receipts.filter(receipt => receipt.command === input.group.command && receipt.profile_hash === input.profileHash && receipt.gate === input.group.gate && receipt.scope === input.scope && receipt.work_id === (input.workId ?? null)).at(-1);
+    // Hash files before SQLite's writer reservation. Captured identities remain
+    // valid historical evidence, but cannot authorize reuse in a changed install.
+    const priorLibrariesCurrent = !prior || currentCandidateLibraryInputsValid(prior, input.workspaceRoot);
+    const latestLibrariesCurrent = !latestContract || currentCandidateLibraryInputsValid(latestContract, input.workspaceRoot);
+    const libraryDrift = (receipt) => { throw new AppError("check_evidence_stale", "Captured library inputs differ from the current candidate installation; request an explicit restored-condition retry", 2, { reason: "candidate_library_inputs_changed", check_receipt_id: receipt.id, effect: "no_effect" }); };
     return context.db.writeTransaction(() => {
         assertRunMutationAllowed(context, input.projectId, input.runId, input.generation);
         if (JSON.stringify(context.db.all(snapshotSql, [input.projectId, input.runId])) !== snapshot)
@@ -859,10 +869,16 @@ function reserveOrReuseReceipt(context, input) {
         // An unchanged failed contract needs a concrete restored-condition retry,
         // not repeated coordinator finish until it happens to become green.
         if (!retryId && latestContract?.fingerprint_scope === "check_inputs" && latestContract.status === "failed"
-            && latestContract.execution_failures?.some(failure => failure.code === "check_inputs_changed") && latestContract.execution_contract_hash === input.executionContractHash)
+            && latestContract.execution_failures?.some(failure => failure.code === "check_inputs_changed") && latestContract.execution_contract_hash === input.executionContractHash) {
+            if (!latestLibrariesCurrent)
+                libraryDrift(latestContract);
             return { receipt: latestContract };
-        if (prior && ["failed", "aborted"].includes(prior.status) && !retryId)
+        }
+        if (prior && ["failed", "aborted"].includes(prior.status) && !retryId) {
+            if (!priorLibrariesCurrent)
+                libraryDrift(prior);
             return { receipt: prior };
+        }
         if (prior?.status === "passed" && !retryIds.has(prior.id) && input.group.reusable && reusablePrior)
             return { receipt: prior };
         let ordinal = (context.db.get("SELECT COALESCE(MAX(reservation_sequence), 0) + 1 AS sequence FROM check_receipts WHERE project_id = ? AND run_id = ?", [input.projectId, input.runId])?.sequence ?? 1);
@@ -1004,12 +1020,12 @@ function resolvedReceiptArtifacts(receiptPath, artifacts, binding) {
     if (retainedOutcome.complete && retainedOutcome.items.every(item => artifacts.some(artifact => relocate(artifact.path) === item.path && artifact.sha256 === item.sha256))) {
         try {
             const value = JSON.parse(fs.readFileSync(outcomePath, "utf8"));
-            if (value.schema_id === "dd-flow/check-execution-outcome@1" && value.id === binding.id && value.command === binding.command && value.input_hash === binding.input_hash && value.verification_epoch === binding.verification_epoch && (value.fingerprint_scope ?? null) === (binding.fingerprint_scope ?? null) && (value.execution_contract_hash ?? null) === (binding.execution_contract_hash ?? null) && JSON.stringify(value.input_manifest ?? null) === JSON.stringify(binding.input_manifest ?? null) && typeof value.candidate_root === "string" && path.isAbsolute(value.candidate_root) && (value.candidate_files === undefined || Array.isArray(value.candidate_files) && value.candidate_files.length <= 64 && value.candidate_files.every((file) => typeof file === "string" && path.isAbsolute(file) && Buffer.byteLength(file) <= 4096)) && (value.candidate_absences === undefined || candidateAbsencesValid(value.candidate_absences)) && Array.isArray(value.execution_failures) && value.execution_failures.every((failure) => failure && typeof failure === "object" && typeof failure.code === "string" && typeof failure.message === "string"))
+            if (value.schema_id === "dd-flow/check-execution-outcome@1" && value.id === binding.id && value.command === binding.command && value.input_hash === binding.input_hash && value.verification_epoch === binding.verification_epoch && (value.fingerprint_scope ?? null) === (binding.fingerprint_scope ?? null) && (value.execution_contract_hash ?? null) === (binding.execution_contract_hash ?? null) && JSON.stringify(value.input_manifest ?? null) === JSON.stringify(binding.input_manifest ?? null) && typeof value.candidate_root === "string" && path.isAbsolute(value.candidate_root) && (value.candidate_files === undefined || Array.isArray(value.candidate_files) && value.candidate_files.length <= 64 && value.candidate_files.every((file) => typeof file === "string" && path.isAbsolute(file) && Buffer.byteLength(file) <= 4096)) && (value.candidate_absences === undefined || candidateAbsencesValid(value.candidate_absences)) && (value.candidate_library_inputs === undefined || candidateLibraryInputsValid(value.candidate_library_inputs)) && Array.isArray(value.execution_failures) && value.execution_failures.every((failure) => failure && typeof failure === "object" && typeof failure.code === "string" && typeof failure.message === "string"))
                 outcome = value;
         }
         catch { /* Missing physical proof cannot grant attribution. */ }
     }
-    return { completion_path: path.join(currentRoot, "completion.json"), required_artifacts: original.required_artifacts ?? [], inputs: original.inputs ?? [], artifacts: artifacts.map((artifact) => ({ ...artifact, path: relocate(artifact.path) })), ...(original.runner_evidence_required ? { runner_evidence_required: original.runner_evidence_required, runner_evidence: evidence, runner_evidence_diagnostics: diagnostics, ...(diagnosticsTruncated ? { runner_evidence_diagnostics_truncated: true } : {}) } : {}), execution_failures: outcome.execution_failures ?? [], ...(outcome.candidate_root ? { candidate_root: outcome.candidate_root } : {}), ...(outcome.candidate_files ? { candidate_files: outcome.candidate_files } : {}), ...(outcome.candidate_absences ? { candidate_absences: outcome.candidate_absences } : {}) };
+    return { completion_path: path.join(currentRoot, "completion.json"), required_artifacts: original.required_artifacts ?? [], inputs: original.inputs ?? [], artifacts: artifacts.map((artifact) => ({ ...artifact, path: relocate(artifact.path) })), ...(original.runner_evidence_required ? { runner_evidence_required: original.runner_evidence_required, runner_evidence: evidence, runner_evidence_diagnostics: diagnostics, ...(diagnosticsTruncated ? { runner_evidence_diagnostics_truncated: true } : {}) } : {}), execution_failures: outcome.execution_failures ?? [], ...(outcome.candidate_root ? { candidate_root: outcome.candidate_root } : {}), ...(outcome.candidate_files ? { candidate_files: outcome.candidate_files } : {}), ...(outcome.candidate_absences ? { candidate_absences: outcome.candidate_absences } : {}), ...(outcome.candidate_library_inputs ? { candidate_library_inputs: outcome.candidate_library_inputs } : {}) };
 }
 function executionFailures(input) {
     const failures = [];
@@ -1027,11 +1043,11 @@ function executionFailures(input) {
         failures.push({ code: "invalid_runner_evidence", message: "Required runner evidence is unavailable or invalid" });
     return failures;
 }
-function retainExecutionOutcome(evidenceDir, binding, candidateRoot, failures, candidateFiles, candidateAbsences = []) {
+function retainExecutionOutcome(evidenceDir, binding, candidateRoot, failures, candidateFiles, candidateAbsences = [], libraryInputs = []) {
     const temporary = path.join(evidenceDir, `.engine-outcome-${crypto.randomUUID()}.tmp`);
     if (!fs.lstatSync(evidenceDir).isDirectory() || fs.lstatSync(evidenceDir).isSymbolicLink())
         throw new AppError("check_evidence_stale", "Check evidence directory was replaced", 1);
-    fs.writeFileSync(temporary, JSON.stringify({ schema_id: "dd-flow/check-execution-outcome@1", id: binding.id, command: binding.command, input_hash: binding.input_hash, verification_epoch: binding.verification_epoch, fingerprint_scope: binding.fingerprint_scope ?? null, input_manifest: binding.input_manifest ?? null, execution_contract_hash: binding.execution_contract_hash ?? null, candidate_root: candidateRoot, candidate_files: candidateFiles, candidate_absences: candidateAbsences, execution_failures: failures }), { flag: "wx", mode: 0o600 });
+    fs.writeFileSync(temporary, JSON.stringify({ schema_id: "dd-flow/check-execution-outcome@1", id: binding.id, command: binding.command, input_hash: binding.input_hash, verification_epoch: binding.verification_epoch, fingerprint_scope: binding.fingerprint_scope ?? null, input_manifest: binding.input_manifest ?? null, execution_contract_hash: binding.execution_contract_hash ?? null, candidate_root: candidateRoot, candidate_files: candidateFiles, candidate_absences: candidateAbsences, candidate_library_inputs: libraryInputs, execution_failures: failures }), { flag: "wx", mode: 0o600 });
     fs.renameSync(temporary, path.join(evidenceDir, "engine-outcome.json"));
 }
 export function workspaceFingerprint(root) { return workspaceState(root).fingerprint; }
@@ -1361,7 +1377,7 @@ function checkReceiptEvidenceValidForMode(receipt, mode) {
         // Receipt annotations are not execution authority. Compare the SQL-owned
         // failures with the independently hash/binding-checked engine sidecar.
         const hasEngineOutcome = receipt.required_artifacts.includes("engine-outcome.json") || receipt.artifacts.some(artifact => artifact.path === "engine-outcome.json" || artifact.path === path.join(path.dirname(receipt.receipt_path), "artifacts", "engine-outcome.json"));
-        if (hasEngineOutcome && (!isDeepStrictEqual(retainedProof.execution_failures ?? [], receipt.execution_failures ?? []) || !isDeepStrictEqual(retainedProof.candidate_absences ?? [], receipt.candidate_absences ?? [])))
+        if (hasEngineOutcome && (!isDeepStrictEqual(retainedProof.execution_failures ?? [], receipt.execution_failures ?? []) || !isDeepStrictEqual(retainedProof.candidate_absences ?? [], receipt.candidate_absences ?? []) || !isDeepStrictEqual(retainedProof.candidate_library_inputs ?? [], receipt.candidate_library_inputs ?? [])))
             return false;
         const root = path.join(path.dirname(receipt.receipt_path), "artifacts");
         if (stored.runner_evidence_required && mode !== "diagnostic" && !runnerEvidencePass(readRunnerEvidence(root, stored.runner_evidence_required, { invocation_id: receipt.id, check_id: receipt.id, command: receipt.command, input_hash: receipt.input_hash, verification_epoch: receipt.verification_epoch })))

package/dist/services/repair-intents.js

@@ -7,7 +7,10 @@ import { assertSourceRepairEligible } from "./code-checks.js";
 export function ensureAggregateRepair(context, input, create) {
     if (!input.failures.length)
         throw new AppError("repair_intent_invalid", "Repair requires candidate-source-backed failed receipts", 1);
-    assertSourceRepairEligible(input.failures);
+    const workspace = context.db.get("SELECT workspace_root FROM runs WHERE project_id=? AND id=?", [input.projectId, input.runId]);
+    if (!workspace?.workspace_root && input.failures.some(receipt => receipt.candidate_library_inputs?.length))
+        throw new AppError("repair_intent_invalid", "Library-backed repair requires the current RUN workspace", 1);
+    assertSourceRepairEligible(input.failures, workspace?.workspace_root);
     const causes = input.failures.map(receipt => ({ id: receipt.id, epoch: receipt.verification_epoch, fingerprint: receipt.fingerprint_scope === "check_inputs" ? receipt.before_fingerprint : receipt.workspace_fingerprint })).sort((a, b) => a.id.localeCompare(b.id));
     return ensureRepairIntent(context, { ...input, causes: { receipts: causes, origins: [...(input.origins ?? [])].sort() } }, create);
 }

package/dist/services/vnext-code-review.js

@@ -253,7 +253,7 @@ export async function finishVnextCodeReview(context, input) {
     const matrix = prepareRunVerificationMatrix(context, { projectId: project.id, runId: run.id, stage, role: "output", receipts, semanticFile: decisionFile });
     const failed = receipts.filter((receipt) => receipt.status !== "passed");
     if (failed.length) {
-        assertSourceRepairEligible(failed);
+        assertSourceRepairEligible(failed, run.workspace_root);
         context.db.writeTransaction(() => acceptVerificationMatrix(context, matrix));
         publishVerificationMatrix(context, matrix);
         throw new AppError("code_review_gate_failed", "CODE-REVIEW repair changed the project but the aggregate gate failed", 2, {

package/dist/services/vnext-code.js

@@ -225,7 +225,7 @@ export async function finishVnextCode(context, input) {
     const matrix = prepareRunVerificationMatrix(context, { projectId: project.id, runId: run.id, stage, role: "output", receipts, semanticFile: input.verificationFile });
     const matrixInstruction = matrix ? verificationMatrixInstruction(matrix.metadata, home, "semantic verification in code-verification.json") : "";
     if (failed.length) {
-        assertSourceRepairEligible(failed);
+        assertSourceRepairEligible(failed, run.workspace_root);
         context.db.writeTransaction(() => acceptVerificationMatrix(context, matrix));
         publishVerificationMatrix(context, matrix);
         const continuation = registerAggregateCodeRepair(context, { projectRoot, runId: run.id, stage, failures: failed, checks, generation });
@@ -408,8 +408,9 @@ export function prepareVnextCodeRepair(context, input) {
             check_receipt_id: input.checkReceiptId
         });
     }
+    // Aggregate registration validated current inputs before its SQL transaction.
     if (input.checkReceiptId)
-        assertSourceRepairEligible(checkReceipts(context, { projectId: project.id, runId: run.id }).filter(item => item.id === input.checkReceiptId));
+        assertSourceRepairEligible(checkReceipts(context, { projectId: project.id, runId: run.id }).filter(item => item.id === input.checkReceiptId), input.registrationOwned ? undefined : run.workspace_root);
     const origins = [...new Set(input.originWorkIds)].map((id) => requireCodeWork(context, project.id, run.id, id));
     const packets = origins.map((work) => packet(work));
     const invariantPackets = receipt || input.semanticUnresolved?.length

package/dist/services/vnext-merge.js

@@ -479,7 +479,7 @@ export async function repairVnextMerge(context, input) {
     if (request.project_id !== project.id || request.status !== "action_required" || errorCode(request) !== "merge_gate_failed") {
         throw new AppError("invalid_merge_repair_state", "MERGE source repair requires an action-required failed integration gate", 2, { merge_request_id: input.requestId, status: request.status, code: errorCode(request) });
     }
-    assertSourceRepairEligible(checkReceipts(context, { projectId: project.id, runId: request.run_id }).filter(receipt => failedReceiptIds(request).includes(receipt.id)));
+    assertSourceRepairEligible(checkReceipts(context, { projectId: project.id, runId: request.run_id }).filter(receipt => failedReceiptIds(request).includes(receipt.id)), request.target_workspace);
     abortIntegration(request);
     const originWorkIds = sourceCodeWorkIds(context, request.project_id, request.run_id);
     if (!originWorkIds.length)

package/dist/services/work-registry.js

@@ -1564,7 +1564,7 @@ async function settle(context, id, status, result, progress, retry, memoryResult
             receipts = await runCodeChecks(context, { projectId: work.project_id, runId: work.run_id, runHome: requireRunHome(run), workspaceRoot: run.workspace_root, workId: work.work_id, artifactDir, scope: "work", checks: requiredChecks, ...(retry ? { retryReceiptId: retry.receiptId, retryReason: retry.reason } : {}), ...(progress ? { progress } : {}) });
             const failed = receipts.filter((receipt) => receipt.status !== "passed");
             if (failed.length)
-                assertSourceRepairEligible(failed);
+                assertSourceRepairEligible(failed, run.workspace_root);
             if (failed.length)
                 throw new AppError("work_checks_failed", "Work remains running because required checks failed", 2, { work_id: id, failures: failed, all_receipts: receipts });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.151",
+  "version": "0.9.0-beta.152",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "packageManager": "pnpm@10.23.0",
@@ -30,7 +30,7 @@
     "test": "node scripts/verification.mjs run",
     "gate:merge": "node scripts/verification.mjs run",
     "verify:plan": "node scripts/verification.mjs plan",
-    "test:verification": "node --test --test-concurrency=1 scripts/verification-policy.test.mjs scripts/generate-verification-components.test.mjs",
+    "test:verification": "node --test --test-concurrency=1 scripts/verification-policy.test.mjs scripts/generate-verification-components.test.mjs scripts/verification-jobs.test.mjs",
     "test:hybrid": "node --import ./scripts/source-test-loader.mjs --test --test-concurrency=1 scripts/hybrid-contracts.test.mjs",
     "test:hybrid:canon": "node --import ./scripts/source-test-loader.mjs --test --test-concurrency=1 scripts/hybrid-canon.test.mjs scripts/hybrid-inventory.test.mjs scripts/hybrid-consumers.test.mjs scripts/hybrid-schema-copies.test.mjs scripts/verify-e3-canon.test.mjs",
     "test:e2": "node --import ./scripts/source-test-loader.mjs --test --test-concurrency=1 scripts/e2-*.test.mjs",

package/tools/verification-jobs.mjs

@@ -0,0 +1,317 @@
+// SSOT for the cooperating verification entrypoints. Standalone consumers vendor
+// this file byte-for-byte; contract catalogs and report validators stay local.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { spawn, execFileSync } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { setTimeout, clearTimeout } from 'node:timers';
+import process from 'node:process';
+
+const realHome = os.userInfo().homedir; // OS identity, never a fixture's HOME.
+const providerCredentials = ['OPENAI_API_KEY','OPENROUTER_API_KEY','OPENAI_DECISIONS_API_KEY','ANTHROPIC_API_KEY','GEMINI_API_KEY','GOOGLE_API_KEY','XAI_API_KEY','ZAI_API_KEY','NODE_AUTH_TOKEN','NPM_TOKEN','NPM_ACCESS_TOKEN'];
+const read = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+const optional = file => { try { return read(file); } catch (e) { if (e.code === 'ENOENT') return null; throw e; } };
+const blocked = message => Object.assign(new Error(message), { code: 'verification_ownership_unknown' });
+export function atomicJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try { fs.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' }); fs.renameSync(temporary, file); }
+  catch (error) {
+    try { fs.unlinkSync(temporary); } catch (cleanup) { if (cleanup.code !== 'ENOENT') error.cleanup_error = cleanup; }
+    throw error;
+  }
+}
+
+// Same physical identity fields as EVAL's process-snapshot helper. Observation
+// failure is never interpreted as an empty process table.
+function snapshot() {
+  return execFileSync('ps', ['-axo', 'pid=,ppid=,pgid=,lstart=,stat='], {
+    encoding: 'utf8', timeout: 5000, env: { PATH: process.env.PATH, LC_ALL: 'C', TZ: 'UTC' },
+  }).trim().split('\n').flatMap(line => {
+    const p = line.trim().split(/\s+/);
+    return p.length >= 9 ? [{ pid: +p[0], ppid: +p[1], pgid: +p[2], birth: p.slice(3, 8).join(' '), zombie: p[8].startsWith('Z') }] : [];
+  });
+}
+const same = (a, b) => a && b && a.pid === b.pid && a.birth === b.birth && !b.zombie;
+function self() {
+  const identity = snapshot().find(p => p.pid === process.pid && !p.zombie);
+  if (!identity) throw blocked('Cannot establish verification owner identity');
+  return identity;
+}
+function alive(owner, processes = snapshot()) { return same(owner, processes.find(p => p.pid === owner?.pid)); }
+function release(lock, owner) {
+  // Only one reclaimer can remove this unique fence. A late reclaimer cannot
+  // unlink the next owner's record after the directory has been reacquired.
+  fs.unlinkSync(path.join(lock, `fence-${owner.token}`));
+  fs.unlinkSync(path.join(lock, 'owner.json')); fs.rmdirSync(lock);
+}
+async function claim(lock, signal) {
+  fs.mkdirSync(path.dirname(lock), { recursive: true });
+  const identity = self();
+  for (;;) {
+    signal?.throwIfAborted();
+    try {
+      fs.mkdirSync(lock);
+      const owner = { ...identity, token: randomUUID(), groups: [] };
+      fs.writeFileSync(path.join(lock, `fence-${owner.token}`), '', { flag: 'wx' });
+      atomicJson(path.join(lock, 'owner.json'), owner);
+      return owner;
+    } catch (e) { if (e.code !== 'EEXIST') throw e; }
+    const owner = optional(path.join(lock, 'owner.json'));
+    if (owner) {
+      const processes = snapshot();
+      if (!alive(owner, processes)) {
+        // A dead coordinator is NOT cleanup. A surviving process group keeps
+        // the whole lease until its physical absence is positively observed.
+        if (!Array.isArray(owner.groups)) throw blocked(`Unconfirmed lease groups: ${lock}`);
+        if (!owner.groups.some(g => !g.pgid || processes.some(p => p.pgid === g.pgid && !p.zombie))) {
+          // Recheck the immutable owner token before removing its record.
+          if (optional(path.join(lock, 'owner.json'))?.token === owner.token) {
+            try { release(lock, owner); } catch (e) { if (!['ENOENT', 'ENOTEMPTY'].includes(e.code)) throw e; }
+          }
+          continue;
+        }
+      }
+    }
+    await delay(50, undefined, { signal });
+  }
+}
+
+/** One immutable producer attempt. The index is scheduling state, not proof;
+ * callers must validate the returned report bytes and meaningful inputs. */
+export async function withContractAttempt(index, { rerun = false, reason, signal, validate, validationKey } = {}, action) {
+  if (rerun && !reason) throw new Error('Explicit rerun requires a reason');
+  const lock = `${index}.claim`;
+  const initial = optional(index);
+  if (initial?.status === 'running' && !rerun) {
+    const result = await joinAttempt(initial, signal);
+    await validate?.(result.result, initial);
+    signal?.throwIfAborted();
+    return result;
+  }
+  let joined = null;
+  const owner = await claim(lock, signal);
+  let attempt;
+  try {
+    const current = optional(index); // Mandatory reread under claim.
+    if (current?.status === 'running' && !rerun) { joined = current; }
+    else if (current && !rerun) {
+      if (current.status !== 'passed') throw blocked(`Retained ${current.status} attempt requires explicit rerun: ${index}`);
+      try {
+        const terminal = read(current.report);
+        if (terminal.attemptId !== current.attemptId || terminal.status !== 'passed') throw new Error('Invalid terminal attempt');
+        await validate?.(terminal.result, current);
+        signal?.throwIfAborted();
+        return { ...terminal, reused: true, joined: false };
+      } catch (error) {
+        signal?.throwIfAborted(); // A cancelled reader never invalidates its producer.
+        atomicJson(index, { ...current, status: 'evidence_invalid', reason: String(error.message) });
+        reason = `Invalid evidence: ${error.message}`;
+      }
+    }
+    if (!joined) {
+      if (current?.status === 'running') throw blocked('Cannot supersede an active producer');
+      const attemptId = randomUUID();
+      const root = path.join(`${index}.attempts`, attemptId);
+      fs.mkdirSync(root, { recursive: true });
+      attempt = { attemptId, root, report: path.join(root, 'terminal.json'), owner, status: 'running', reason: reason ?? null, validationKey };
+      // Accepted rerun supersedes an old PASS before dispatch.
+      atomicJson(index, attempt);
+    }
+  } finally { release(lock, owner); }
+  if (joined) {
+    const result = await joinAttempt(joined, signal);
+    await validate?.(result.result, joined);
+    signal?.throwIfAborted();
+    return result;
+  }
+  try {
+    signal?.throwIfAborted();
+    const result = await action({ attemptId: attempt.attemptId, root: attempt.root });
+    await validate?.(result, attempt);
+    signal?.throwIfAborted();
+    const terminal = { attemptId: attempt.attemptId, result, status: 'passed' };
+    atomicJson(attempt.report, terminal);
+    atomicJson(index, { ...attempt, status: 'passed' });
+    return { ...terminal, reused: false, joined: false };
+  } catch (error) {
+    const terminal = { attemptId: attempt.attemptId, status: signal?.aborted ? 'interrupted' : 'failed', error: String(error.stack ?? error) };
+    atomicJson(attempt.report, terminal);
+    atomicJson(index, { ...attempt, status: terminal.status });
+    throw error;
+  }
+}
+async function joinAttempt(attempt, signal) {
+  for (;;) {
+    signal?.throwIfAborted(); // Cancels only this waiter.
+    const terminal = optional(attempt.report);
+    if (terminal) {
+      if (terminal.attemptId !== attempt.attemptId || terminal.status !== 'passed') throw blocked(`Producer attempt did not pass: ${attempt.attemptId}`);
+      return { ...terminal, reused: false, joined: true };
+    }
+    if (!alive(attempt.owner)) throw blocked(`Producer died without terminal evidence: ${attempt.attemptId}`);
+    await delay(50, undefined, { signal });
+  }
+}
+
+function isAncestor(identity, processes) {
+  let cursor = processes.find(p => p.pid === process.pid);
+  const seen = new Set();
+  while (cursor && !seen.has(cursor.pid)) {
+    if (same(identity, cursor)) return true;
+    seen.add(cursor.pid); cursor = processes.find(p => p.pid === cursor.ppid);
+  }
+  return false;
+}
+async function inheritedSlot(env, home, signal) {
+  if (!env.DD_FLOW_VERIFICATION_SLOT) return false;
+  let context;
+  try { context = JSON.parse(env.DD_FLOW_VERIFICATION_SLOT); } catch { throw blocked('Malformed inherited slot'); }
+  for (;;) {
+    const owner = optional(path.join(home, 'lease', 'owner.json')), processes = snapshot();
+    const group = owner?.groups?.find(g => g.token === context.token);
+    if (!group || owner.token !== context.owner || !alive(owner, processes)) break;
+    // A child may reach its first import before spawn() publishes its identity.
+    if (!group.pid) { await delay(10, undefined, { signal }); continue; }
+    if (isAncestor(group, processes)) return { owner, group };
+    break;
+  }
+  throw blocked('Inherited slot is not owned by an ancestor job');
+}
+async function nestedScope(env, home, outer, signal) {
+  if (!env.DD_FLOW_VERIFICATION_NESTED_SLOT) return outer ? `${outer.owner.token}-${outer.group.token}` : null;
+  let context;
+  try { context = JSON.parse(env.DD_FLOW_VERIFICATION_NESTED_SLOT); } catch { throw blocked('Malformed nested slot'); }
+  if (!outer || !/^[a-f0-9-]+$/.test(context.scope ?? '')) throw blocked('Invalid nested slot scope');
+  for (;;) {
+    const owner = optional(path.join(home, 'nested-slots', context.scope, 'owner.json')), processes = snapshot();
+    const child = owner?.groups?.find(group => group.token === context.child);
+    if (!child || owner.token !== context.owner || !alive(owner, processes)) break;
+    if (!child.pid) { await delay(10, undefined, { signal }); continue; }
+    if (isAncestor(child, processes)) return `${owner.token}-${child.token}`;
+    break;
+  }
+  throw blocked('Nested slot is not owned by an ancestor dispatch');
+}
+
+/** FIFO host-wide pool; descriptors are child commands, never callbacks sharing
+ * process.env. Exclusive drains both slots; inherited runners use one slot. */
+export async function runJobs(jobs, { jobs: budget = 2, signal, env = process.env, coordinationHome } = {}) {
+  const queuedAt = Date.now();
+  if (![1, 2].includes(budget)) throw new Error('Verification budget must be 1 or 2');
+  if (Array.isArray(jobs) && jobs.some(job => job?.credentialKeys !== undefined && (!Array.isArray(job.credentialKeys) || job.credentialKeys.some(name => typeof name !== 'string' || !providerCredentials.includes(name))))) throw new Error('Invalid credential allowlist');
+  if (!Array.isArray(jobs) || jobs.some(job=>!job || typeof job.id!=='string' || !job.id || typeof job.command!=='string' || !job.command || job.args && (!Array.isArray(job.args)||job.args.some(arg=>typeof arg!=='string')) || job.executionClass!==undefined && !['isolated','exclusive'].includes(job.executionClass)) || new Set(jobs.map(job=>job.id)).size!==jobs.length) throw new Error('Invalid/duplicate verification job descriptor');
+  const home = coordinationHome ?? env.DD_FLOW_VERIFICATION_COORDINATION_HOME ?? path.join(realHome, '.dd-flow', 'verification-coordinator');
+  const nested = await inheritedSlot(env, home, signal);
+  const scope = await nestedScope(env, home, nested, signal);
+  const lock = scope ? path.join(home, 'nested-slots', scope) : path.join(home, 'lease');
+  const owner = await claim(lock, signal);
+  // A dead nested coordinator cannot free this slot while its outer group lives.
+  if (nested) { owner.groups = [{ ...nested.group, token: 'outer-group' }]; atomicJson(path.join(lock, 'owner.json'), owner); }
+  const results = new Array(jobs.length);
+  const active = new Set();
+  let failure;
+  const save = () => { if (owner) atomicJson(path.join(lock, 'owner.json'), owner); };
+  const start = (job, index) => {
+    signal?.throwIfAborted();
+    if (failure) throw failure;
+    const promise = execute(job, { home, owner, nested, scope, signal, env, save, queuedAt }).then(result => { results[index] = result; }, error => { failure ??= error; }).finally(() => active.delete(promise));
+    active.add(promise); return promise;
+  };
+  try {
+    for (let i = 0; i < jobs.length; i++) {
+      signal?.throwIfAborted();
+      if (failure) throw failure;
+      if (jobs[i].executionClass === 'exclusive') { await Promise.all(active); await start(jobs[i], i); }
+      else { while (active.size >= (nested ? 1 : budget)) await Promise.race(active); start(jobs[i], i); }
+    }
+    await Promise.all(active);
+    if (failure) throw failure;
+    return results;
+  } finally {
+    await Promise.allSettled(active);
+    // Never release a lease after unknown cleanup.
+    if (nested && owner.groups.every(group => group.token === 'outer-group')) owner.groups = [];
+    if (owner.groups.length === 0) release(lock, owner);
+  }
+}
+
+async function execute(job, { home, owner, nested, scope, signal, env, save, queuedAt }) {
+  const started = Date.now();
+  const attemptId = randomUUID();
+  const root = path.join(home, 'jobs', attemptId);
+  fs.mkdirSync(root, { recursive: true });
+  const childEnv = { ...env, ...job.env };
+  for (const name of providerCredentials) if (!job.credentialKeys?.includes(name)) delete childEnv[name];
+  childEnv.DD_FLOW_VERIFICATION_COORDINATION_HOME = home;
+  // node:test sets this private flag for its own children; a separately managed
+  // test command must produce a standalone report, not use its parent's IPC.
+  delete childEnv.NODE_TEST_CONTEXT;
+  for (const name of ['HOME', 'TMPDIR', 'XDG_CACHE_HOME', 'XDG_CONFIG_HOME', 'XDG_RUNTIME_DIR', 'CODEX_HOME', 'AGY_HOME', 'DD_FLOW_HOME', 'DD_FLOW_RESOURCE_HOME', 'DD_FLOW_CONFIG_HOME']) {
+    childEnv[name] = path.join(root, name.toLowerCase()); fs.mkdirSync(childEnv[name], { recursive: true });
+  }
+  // Only an explicit native/delivery descriptor may opt into provider credentials.
+  const token = randomUUID();
+  if (!nested) {
+    childEnv.DD_FLOW_VERIFICATION_SLOT = JSON.stringify({ owner: owner.token, token });
+    delete childEnv.DD_FLOW_VERIFICATION_NESTED_SLOT;
+  } else {
+    childEnv.DD_FLOW_VERIFICATION_SLOT = env.DD_FLOW_VERIFICATION_SLOT;
+    childEnv.DD_FLOW_VERIFICATION_NESTED_SLOT = JSON.stringify({ scope, owner: owner.token, child: token });
+  }
+  // Unknown spawn outcome must retain the lease after coordinator death.
+  owner.groups.push({ token, attemptId, root, pgid: null }); save();
+  const child = spawn(job.command, job.args ?? [], { cwd: job.cwd, env: childEnv, stdio: job.stdio ?? 'inherit', detached: !nested });
+  let spawnError;
+  const closed = new Promise(resolve => child.once('close', resolve));
+  const completion = new Promise(resolve => { child.once('error', error => { spawnError = error; resolve({ code: null, signal: null }); }); child.once('exit', (code, exitSignal) => resolve({ code, signal: exitSignal })); });
+  // A pipe is owned by this helper, not exposed to callers. Drain it while
+  // preserving output; an orphan holding it open must not hide direct exit.
+  for (const [name, stream] of [['stdout', child.stdout], ['stderr', child.stderr]]) stream?.on('data', bytes => fs.appendFileSync(path.join(root, `${name}.log`), bytes));
+  let identity;
+  if (child.pid) identity = snapshot().find(p => p.pid === child.pid && !p.zombie);
+  if (identity && owner) { identity = { ...identity, token, attemptId, root }; owner.groups = owner.groups.map(g => g.token === token ? identity : g); save(); }
+  let cleanupError;
+  const stop = (killSignal = 'SIGTERM') => {
+    if (!identity) return;
+    try {
+      const current = snapshot().find(p => p.pid === identity.pid);
+      if (same(identity, current)) process.kill(nested ? identity.pid : -identity.pgid, killSignal);
+    } catch (error) { if (error.code !== 'ESRCH') cleanupError = error; }
+  };
+  let forceTimer;
+  const cancel = () => { stop(); forceTimer = setTimeout(() => stop('SIGKILL'), 1000); };
+  signal?.addEventListener('abort', cancel, { once: true });
+  if (signal?.aborted) cancel();
+  const result = await completion;
+  clearTimeout(forceTimer);
+  signal?.removeEventListener('abort', cancel);
+  try {
+  if (cleanupError) throw cleanupError;
+  if (identity && !nested) {
+    for (let n = 0; n < 100 && snapshot().some(p => p.pgid === identity.pgid && !p.zombie); n++) {
+      stop(); await delay(50);
+    }
+    if (snapshot().some(p => p.pgid === identity.pgid && !p.zombie)) throw blocked(`Owned group cleanup unconfirmed: ${identity.pgid}`);
+  }
+  if (child.pid && !identity && snapshot().some(p => !p.zombie && (nested ? p.pid === child.pid : p.pgid === child.pid))) throw blocked(`Spawned process identity unconfirmed: ${child.pid}`);
+  const ioClosed = await Promise.race([closed.then(() => true), delay(5000, undefined, { ref: false }).then(() => false)]);
+  if (!ioClosed) {
+    owner.groups = owner.groups.map(group => group.token === token ? { ...group, pgid: null, reason: 'stdio_cleanup_unconfirmed' } : group); save();
+    throw blocked(`Owned stdio cleanup unconfirmed: ${child.pid}`);
+  }
+  // Missing startup identity is not an eternal unknown after actual exit plus
+  // positive absence of the exact spawned group. Never kill by an inferred PID.
+  owner.groups = owner.groups.filter(g => g.token !== token); save();
+  if (spawnError) throw spawnError;
+  const finished = Date.now();
+  const terminal = { id: job.id, attemptId, root, ...result, started_at: new Date(started).toISOString(), finished_at: new Date(finished).toISOString(), queue_ms: started - queuedAt, elapsed_ms: finished - started, status: signal?.aborted ? 'interrupted' : result.code === 0 ? 'passed' : 'failed' };
+  atomicJson(path.join(root, 'terminal.json'), terminal);
+  return terminal;
+  } catch (error) {
+    child.stdout?.destroy(); child.stderr?.destroy();
+    throw error;
+  }
+}