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

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);
@@ -246,6 +273,51 @@ export function readRunnerEvidenceDetailed(root, contract, binding) {
     });
 }
 export function readRunnerEvidence(root, contract, binding) { return readRunnerEvidenceDetailed(root, contract, binding).evidence; }
+/** Semantic attribution is diagnostic information, never permission to investigate a failed check. */
+export const checkDiagnosisPolicy = "settled-failure@1";
+export function checkDiagnosisDisposition(receipt) {
+    if (receipt.status === "running"
+        || receipt.execution_failures?.some(failure => ["cleanup_unconfirmed", "engine_outcome_unbound"].includes(failure.code)))
+        return "settlement_required";
+    if (!["passed", "failed", "aborted"].includes(receipt.status))
+        return "invalid_binding";
+    // Caller supplies the SQL-owned receipt, never a proposed runner report.
+    // Missing, malformed or foreign optional reports are diagnostic failures;
+    // they cannot change receipt ownership or grant a successful check.
+    if (receipt.status === "passed")
+        return "passed";
+    // New launchers record physical settlement even for spawn errors/signals.
+    // Historical aborted receipts with no such proof must first reconcile.
+    if (!receipt.execution_failures?.some(failure => failure.code === "check_execution_settled") && !Number.isSafeInteger(receipt.exit_code))
+        return "settlement_required";
+    return "diagnosis_required";
+}
+export function assertCheckDiagnosisEligible(receipts, _workspaceRoot) {
+    const dispositions = receipts.map(receipt => ({ check_receipt_id: receipt.id, disposition: checkDiagnosisDisposition(receipt) }));
+    if (!receipts.length || dispositions.some(item => item.disposition !== "diagnosis_required"))
+        throw new AppError("check_gate_blocked", "Check diagnosis requires owned, physically settled failed executions", 2, {
+            failures: receipts, dispositions, outcome: "blocked", recoverable: false,
+            instruction: "Reconcile any running or unknown check process before changing its workspace. Do not treat a foreign receipt or an agent report as proof of completion."
+        });
+}
+/** Human-readable retained facts; tool output remains data, never instructions. */
+export function checkDiagnosisSummary(receipt, workspaceRoot) {
+    const available = (file) => {
+        try {
+            fs.accessSync(file, fs.constants.R_OK);
+            return fs.statSync(file).isFile() ? file : `${file} (not a regular file)`;
+        }
+        catch {
+            return `${file} (unavailable; investigate the missing diagnostic, do not invent its content)`;
+        }
+    };
+    return [`Check: ${receipt.id}`, `Command: ${receipt.command}`, `cwd: ${workspaceRoot}`,
+        `Outcome: ${receipt.status}; exit: ${receipt.exit_code ?? "unavailable"}; epoch: ${receipt.verification_epoch}`,
+        `Receipt: ${available(receipt.receipt_path)}`, `stdout: ${available(receipt.stdout_path)}`, `stderr: ${available(receipt.stderr_path)}`,
+        `Execution facts: ${JSON.stringify(receipt.execution_failures ?? [])}`,
+        `Report: ${receipt.runner_evidence_required?.path ? path.join(path.dirname(receipt.receipt_path), "artifacts", receipt.runner_evidence_required.path) : "not declared"}`].join("\n");
+}
+/** Historical attribution reader only. New repair routing uses checkDiagnosisDisposition. */
 export function checkRepairDisposition(receipt) {
     if (receipt.fingerprint_scope != null && receipt.fingerprint_scope !== "check_inputs")
         return "tooling_blocker";
@@ -266,12 +338,7 @@ 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." });
-}

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/cli-operation-classifier.js

@@ -89,6 +89,10 @@ function isReadOnlyDiagnostic(family, command, action) {
         return ["status", "ls", "show"].includes(command ?? "");
     if (family === "stage")
         return command === "fanout" && action === "status";
+    if (family === "interactive")
+        return command === "inputs" || command === "git-inputs";
+    if (family === "delivery")
+        return command === "inputs";
     if (family === "lane") {
         return (command === "status" ||
             command === "waiters" ||
@@ -108,7 +112,8 @@ function isReadOnlyDiagnostic(family, command, action) {
     if (family === "dashboard")
         return command === "data" || command === "open";
     if (family === "memory")
-        return command === "permissions" && action === "preflight";
+        return command === "permissions" && action === "preflight" || command === "distill" && action === "inputs"
+            || command === "fix" && ["context", "scope"].includes(action ?? "");
     if (family === "codex" && command === "hooks")
         return action === "print" || action === "status";
     if (family === "codex" && command === "home")

package/dist/services/code-checks.js

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
-import { candidateAbsencesValid, candidateFailureAbsences, candidateFailureFiles, checkRepairDisposition, readRunnerEvidence, readRunnerEvidenceDetailed, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations, runnerProofArtifacts } from "./check-runner-evidence.js";
-export { assertSourceRepairEligible, checkRepairDisposition } from "./check-runner-evidence.js";
+import { candidateAbsencesValid, candidateFailureAbsences, candidateFailureFiles, candidateLibraryInputs, candidateLibraryInputsValid, currentCandidateLibraryInputsValid, checkDiagnosisDisposition, readRunnerEvidence, readRunnerEvidenceDetailed, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations, runnerProofArtifacts } from "./check-runner-evidence.js";
+export { assertCheckDiagnosisEligible, checkDiagnosisDisposition, checkRepairDisposition } from "./check-runner-evidence.js";
 import { isGitlessWorkspace, ownedWorkspaceHookPath, projectServicePathFilter, workspaceGitFiles } from "./workspace-files.js";
 import { spawn, spawnSync } from "node:child_process";
 import { ObservationClock, validateObservationDuration } from "../harness-runtime/lib/observation-clock.mjs";
@@ -352,14 +352,16 @@ 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) || input.mode !== "diagnostic" && !currentCandidateLibraryInputsValid(receipt, input.workspaceRoot))
                 fail();
             passed = passed && receipt.status === "passed";
-            for (const artifact of receipt.artifacts)
+            const availableArtifacts = input.mode === "diagnostic" ? availableDiagnosticArtifacts(receipt) : receipt.artifacts;
+            for (const artifact of availableArtifacts)
                 artifacts.push({ root: "run", path: path.relative(input.runHome, path.join(path.dirname(receipt.receipt_path), "artifacts", artifact.path)).split(path.sep).join("/"), sha256: artifact.sha256 });
             const bytes = fs.readFileSync(receipt.receipt_path);
-            completions.push({ root: "run", path: path.relative(input.runHome, receipt.completion_path).split(path.sep).join("/"), sha256: crypto.createHash("sha256").update(fs.readFileSync(receipt.completion_path)).digest("hex") });
-            if (receipt.input_manifest)
+            if (input.mode !== "diagnostic" || fs.existsSync(receipt.completion_path))
+                completions.push({ root: "run", path: path.relative(input.runHome, receipt.completion_path).split(path.sep).join("/"), sha256: crypto.createHash("sha256").update(readBoundedReleaseFile(receipt.completion_path, 1024 * 1024)).digest("hex") });
+            if (receipt.input_manifest && (input.mode !== "diagnostic" || fs.existsSync(path.join(path.dirname(receipt.receipt_path), receipt.input_manifest.path))))
                 completions.push({ root: "run", path: path.relative(input.runHome, path.join(path.dirname(receipt.receipt_path), receipt.input_manifest.path)).split(path.sep).join("/"), sha256: receipt.input_manifest.sha256 });
             return { id: receipt.id, path: receipt.receipt_path, sha256: crypto.createHash("sha256").update(bytes).digest("hex") };
         });
@@ -562,7 +564,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         const snapshot = workspaceState(input.workspaceRoot, [input.runHome]);
         const group = groups.find(candidate => candidate.declarations.some(check => check.run_at === predecessor.gate)
             && (checkInputHash(input.workspaceRoot, { ...candidate, gate: predecessor.gate }, profileHash, workspaceInputFingerprint(input.workspaceRoot, snapshot.files, candidate.inputs, [input.runHome]), input.evidenceContext, input.checkEnvironment) === predecessor.input_hash
-                || sourceRepairContractMatches(predecessor, candidate, profileHash)
+                || diagnosisRetryContractMatches(predecessor, candidate, profileHash, checkInputHash(input.workspaceRoot, { ...candidate, gate: predecessor.gate }, profileHash, "", input.evidenceContext, input.checkEnvironment, false), checkInputHash(input.workspaceRoot, { ...candidate, gate: predecessor.gate }, profileHash, "", input.evidenceContext, input.checkEnvironment))
                 || input.retryReason === "check_inputs_changed" && staleRetryContractMatches(predecessor, candidate, profileHash, input)));
         if (!group || retries.has(group))
             throw new AppError("retry_check_invalid", "Retry must match exactly one current execution contract", 2, { check_receipt_id: receiptId });
@@ -579,7 +581,9 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         const inputFingerprint = inputFilesFingerprint(inputFiles);
         const inputHash = checkInputHash(input.workspaceRoot, group, profileHash, inputFingerprint, input.evidenceContext, input.checkEnvironment);
         const epoch = crypto.createHash("sha256").update(`${group.gate}\0${inputFingerprint}`).digest("hex");
-        const executionContractHash = checkInputHash(input.workspaceRoot, group, profileHash, "", input.evidenceContext, input.checkEnvironment);
+        // Retry preserves the declared check/wave, not the failed conditions being
+        // corrected. Observed environment still participates in inputHash/PASS reuse.
+        const executionContractHash = checkInputHash(input.workspaceRoot, group, profileHash, "", input.evidenceContext, input.checkEnvironment, false);
         const reservationInput = { ...input, retryReceiptIds: retries.has(group) ? [retries.get(group)] : [], generation, group, before, inputFiles, inputFingerprint, executionContractHash, profileHash, inputHash, epoch, startedAt };
         delete reservationInput.retryReceiptId;
         const decision = reserveOrReuseReceipt(context, reservationInput);
@@ -592,6 +596,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         const { id, evidenceDir, stdoutPath, stderrPath, receiptPath, completionPath } = reserved;
         let resources = {};
         let result = { exitCode: null, error: "check did not start", aborted: true };
+        let dispatched = false, physicallySettled = false;
         try {
             fs.mkdirSync(evidenceDir, { recursive: true });
             retainInputManifest(context, reserved);
@@ -624,6 +629,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
                 const runnerEnvironment = group.runnerEvidence ? { DD_FLOW_CHECK_RUNNER_EVIDENCE_PATH: path.join(evidenceDir, group.runnerEvidence.path), DD_FLOW_CHECK_RUNNER_PROGRESS_PATH: path.join(evidenceDir, "runner-progress.jsonl"), DD_FLOW_CHECK_INVOCATION_ID: id, DD_FLOW_CHECK_ID: id, DD_FLOW_CHECK_INPUT_HASH: inputHash, DD_FLOW_CHECK_VERIFICATION_EPOCH: epoch } : {};
                 if (group.runnerEvidence)
                     fs.mkdirSync(path.dirname(path.join(evidenceDir, group.runnerEvidence.path)), { recursive: true });
+                dispatched = true;
                 result = await runCheck(group.command, input.workspaceRoot, { ...codeExecutionEnvironment(input.workspaceRoot, input.checkEnvironment), ...browserCheckCapabilityEnvironment(context, input.runId, input.runHome), DD_FLOW_EVIDENCE_DIR: evidenceDir, DD_FLOW_CHECK_COMPLETION_FILE: completionPath, ...runnerEnvironment, ...portEnvironment(resources) }, stdout, stderr, (elapsed) => input.progress?.(`check ${index + 1}/${groups.length} still running (${elapsed}s): ${group.command}`), (pid) => {
                     confirmedExpiry = confirmManagedProcess(context, { id: managed.id, leaseToken: managed.lease_token, pid, processGroupId: process.platform === "win32" ? null : pid }).lease_expires_at;
                     assertRunMutationAllowed(context, input.projectId, input.runId, generation);
@@ -638,6 +644,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
             const current = managedProcessStatus(context).find(item => item.id === managed.id);
             if (processTreeIsAlive(current))
                 throw new AppError("check_in_progress", "The check shell exited but its process tree is still live; retain this receipt and its resources until settlement", 2, { process_id: managed.id, check_receipt_id: id });
+            physicallySettled = !result.cleanupUnconfirmed;
             allocation.release();
             if (!result.cleanupUnconfirmed)
                 finishManagedProcess(context, { id: managed.id, leaseToken: managed.lease_token, state: result.aborted || result.exitCode !== 0 || Boolean(result.error) ? "failed" : "stopped", reason: result.error });
@@ -664,10 +671,14 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         const physicalFailures = executionFailures({ fingerprintScope: "check_inputs", 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);
+        // This marker is SQL-owned execution metadata, not a semantic runner verdict.
+        if (result.aborted && (!dispatched || physicallySettled))
+            physicalFailures.push({ code: "check_execution_settled", message: "No owned check process remains; investigate the retained launch or execution 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 +687,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 +780,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 +791,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 +812,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")
@@ -821,7 +836,7 @@ function reserveOrReuseReceipt(context, input) {
     const successor = retryIds.size === 1 ? receipts.find((receipt) => receipt.retry_of_receipt_id === [...retryIds][0] && receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash) : null;
     const reusableSuccessor = successor?.status === "passed" && checkReceiptEvidenceValid(successor);
     const retryPredecessor = receipts.find(receipt => retryIds.has(receipt.id));
-    const sourceCorrection = Boolean(retryPredecessor && (sourceRepairContractMatches(retryPredecessor, input.group, input.profileHash)
+    const sourceCorrection = Boolean(retryPredecessor && (diagnosisRetryContractMatches(retryPredecessor, input.group, input.profileHash, input.executionContractHash, checkInputHash(input.workspaceRoot, input.group, input.profileHash, "", input.evidenceContext, input.checkEnvironment))
         || 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);
     return context.db.writeTransaction(() => {
@@ -879,9 +894,12 @@ function reserveOrReuseReceipt(context, input) {
         return { reserved };
     }, "checks.reserveOrReuseReceipt");
 }
-function sourceRepairContractMatches(receipt, group, profileHash) {
-    return checkRepairDisposition(receipt) === "source_repair" && group.command === receipt.command && profileHash === receipt.profile_hash && isDeepStrictEqual(group.inputs, receipt.inputs)
-        && isDeepStrictEqual(derivedReceiptArtifacts(group, receipt).sort(), [...receipt.required_artifacts].sort()) && isDeepStrictEqual([...group.ports].sort(), Object.keys(receipt.resources.ports).sort());
+function diagnosisRetryContractMatches(receipt, group, profileHash, executionContractHash, legacyExecutionContractHash) {
+    return checkDiagnosisDisposition(receipt) === "diagnosis_required" && group.command === receipt.command && profileHash === receipt.profile_hash && isDeepStrictEqual(group.inputs, receipt.inputs)
+        && [executionContractHash, legacyExecutionContractHash].includes(receipt.execution_contract_hash ?? "")
+        && group.requiredArtifacts.every(artifact => receipt.required_artifacts.includes(artifact))
+        && isDeepStrictEqual(group.runnerEvidence ?? null, receipt.runner_evidence_required ?? null)
+        && isDeepStrictEqual([...group.ports].sort(), Object.keys(receipt.resources.ports).sort());
 }
 function staleCheckRetryEligible(receipt) {
     if (receipt.fingerprint_scope !== "check_inputs" || receipt.status !== "failed" || receipt.exit_code !== 0 || receipt.retry_reason === "check_inputs_changed"
@@ -892,7 +910,8 @@ function staleCheckRetryEligible(receipt) {
 }
 function staleRetryContractMatches(receipt, group, profileHash, input) {
     return group.reusable && staleCheckRetryEligible(receipt) && isDeepStrictEqual(group.runnerEvidence ?? null, receipt.runner_evidence_required ?? null)
-        && receipt.execution_contract_hash === checkInputHash(input.workspaceRoot, group, profileHash, "", input.evidenceContext, input.checkEnvironment);
+        && [checkInputHash(input.workspaceRoot, group, profileHash, "", input.evidenceContext, input.checkEnvironment, false),
+            checkInputHash(input.workspaceRoot, group, profileHash, "", input.evidenceContext, input.checkEnvironment)].includes(receipt.execution_contract_hash ?? "");
 }
 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, fingerprint_scope: "check_inputs", input_manifest: input.inputManifest ?? null, execution_contract_hash: input.executionContractHash, workspace_fingerprint: input.before.fingerprint, before_fingerprint: input.inputFingerprint, after_fingerprint: input.status === "running" ? input.inputFingerprint : 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 retainInputManifest(context, reserved) {
@@ -950,8 +969,6 @@ export function validateFailedCheckRetry(context, input) {
     const declared = new Set(input.declarations.flatMap((check) => [check.id, checkRef(check)]));
     if (!receipt.check_refs.some((ref) => declared.has(ref)))
         throw new AppError("retry_check_invalid", "--retry-check does not belong to this stage gate", 2, { check_receipt_id: input.receiptId, check_refs: receipt.check_refs });
-    if (receipt.fingerprint_scope === "check_inputs" && receipt.execution_failures?.some(failure => failure.code === "check_inputs_changed") && input.reason !== "check_inputs_changed")
-        throw new AppError("retry_check_invalid", "Scoped drift uses its bounded stale transition, not an environment/source retry", 2, { check_receipt_id: receipt.id });
     if (input.reason === "check_inputs_changed" && (!staleCheckRetryEligible(receipt) || receipt.retry_reason === "check_inputs_changed"))
         throw new AppError("retry_check_invalid", "Scoped input retry requires a bound, safely completed stale predecessor and one unconsumed episode", 2, { check_receipt_id: receipt.id });
     return receipt;
@@ -1004,12 +1021,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 +1044,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; }
@@ -1310,12 +1327,28 @@ function explicitInputFiles(root, inputs, ignoredRoots, sourceFiles) {
         visit(path.resolve(root, input), input, new Set());
     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 checkInputHash(workspaceRoot, group, profileHash, inputFingerprint, evidenceContext, checkEnvironment, observedEnvironment = true) { 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: observedEnvironment ? environmentFingerprint(workspaceRoot, group.environmentInputs, checkEnvironment) : null, input_fingerprint: inputFingerprint, ...(group.environmentInputs === undefined ? {} : { environment_inputs: group.environmentInputs }), ...(evidenceContext === undefined ? {} : { evidence_context: evidenceContext }) })).digest("hex"); }
 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 availableDiagnosticArtifacts(receipt) {
+    const root = path.join(path.dirname(receipt.receipt_path), "artifacts");
+    return receipt.artifacts.flatMap(artifact => {
+        const relative = path.isAbsolute(artifact.path) ? path.relative(root, artifact.path) : artifact.path;
+        const observed = collectCheckArtifacts(root, [relative]);
+        return observed.items.filter(item => item.sha256 === artifact.sha256);
+    });
+}
 function checkReceiptEvidenceValidForMode(receipt, mode) {
     try {
+        if (mode === "diagnostic" && receipt.status !== "passed") {
+            if (checkDiagnosisDisposition(receipt) !== "diagnosis_required")
+                return false;
+            // SQL selects this execution. Only its identity must survive in the
+            // diagnostic packet; missing reports/logs cannot erase a failed command.
+            const stored = JSON.parse(readBoundedReleaseFile(receipt.receipt_path, 1024 * 1024).toString("utf8"));
+            return ["id", "scope", "work_id", "command", "input_hash", "verification_epoch", "status", "exit_code", "started_at", "finished_at"].every(field => (stored[field] ?? null) === (receipt[field] ?? null));
+        }
         const staleDiagnostic = mode === "diagnostic" && receipt.fingerprint_scope === "check_inputs" && receipt.status === "failed" && Number.isInteger(receipt.exit_code)
             && receipt.before_fingerprint !== receipt.after_fingerprint && receipt.mutation_paths.length > 0 && receipt.execution_failures?.some(failure => failure.code === "check_inputs_changed");
         if (receipt.fingerprint_scope != null && receipt.fingerprint_scope !== "check_inputs")
@@ -1361,7 +1394,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/codex-hook-delivery.js

@@ -19,7 +19,10 @@ export async function verifyCodexHookDelivery(env, payload) {
         throw new AppError("native_hook_timeout", "Native hook deadline expired before delivery verification", 1, { phase: "verification", effect: "no_effect", recoverable: false });
     const proof = await callDaemon(env.DD_FLOW_CODEX_STATE_DIR, "hook.verify", {
         daemonId: env.DD_FLOW_DAEMON_ID, rootSessionId: payload.session_id,
-        sessionId: payload.agent_id ?? payload.session_id, toolCallId: payload.tool_use_id, turnId: payload.turn_id
+        sessionId: payload.agent_id ?? payload.session_id, toolCallId: payload.tool_use_id, turnId: payload.turn_id,
+        // The daemon verifies the native delivery before retaining it; the source
+        // command cannot itself grant admission to the CLI.
+        nativePayload: payload, nativeCommand: command
     }, Math.min(5000, remaining));
     if (typeof proof.projectRoot !== "string"
         || typeof proof.ddFlowHome !== "string" || !env.DD_FLOW_HOME || path.resolve(env.DD_FLOW_HOME) !== path.resolve(proof.ddFlowHome)
@@ -27,6 +30,12 @@ export async function verifyCodexHookDelivery(env, payload) {
         || typeof proof.toolCallId !== "string" || !(proof.parentSessionId === null || typeof proof.parentSessionId === "string")) {
         throw new AppError("native_hook_unproven", "Native hook proof differs from the requested project/runtime", 1, { effect: "no_effect" });
     }
+    const binding = proof.nativeHookBinding;
+    const retained = binding && typeof binding === "object" && !Array.isArray(binding) ? binding : null;
     return { daemonId: proof.daemonId, rootSessionId: proof.rootSessionId, sessionId: proof.sessionId,
-        parentSessionId: proof.parentSessionId, toolCallId: proof.toolCallId, projectRoot: proof.projectRoot, command: command };
+        parentSessionId: proof.parentSessionId, toolCallId: proof.toolCallId, projectRoot: proof.projectRoot, command: command,
+        ...(retained?.schema_id === "dd-flow/hook-request@1" && retained.source_harness === "codex-desktop"
+            && retained.daemon_id === proof.daemonId && retained.root_provider_session_id === proof.rootSessionId
+            && retained.provider_session_id === proof.sessionId && retained.tool_call_id === proof.toolCallId
+            && retained.native_command === command && typeof retained.request_id === "string" ? { nativeHookBinding: retained } : {}) };
 }

package/dist/services/controller-execution.js

@@ -5,6 +5,7 @@ import { resolveExecutionPolicy, resolveStageTransition, stageExecutionCwd } fro
 import { readFlowRunExecutionBundle } from "./runs.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
+import { isDeliveryFlow } from "../domain/delivery-flows.js";
 /** Adapt generic routing to shared fanout APIs, not to SDLC settings. No alias,
  * operator file, merge policy or project default participates in this selection.
  */
@@ -44,7 +45,9 @@ export function genericControllerRouting(execution, workspaceRoot) {
  * Legacy SDLC manifests retain their original settings and routing behavior.
  */
 export function selectControllerExecution(context, run, manifest) {
-    if (manifest?.schema_id === "dd-flow/run-controller-manifest@2" || ["mb-init", "mb-upgrade"].includes(run.flow_kind) || isDiagnosticFlow(run.flow_kind)) {
+    const boundDistill = run.flow_kind === "mb-distill" && JSON.parse(run.index_json).execution_bundle?.flow_id === "mb-distill";
+    const boundDelivery = isDeliveryFlow(run.flow_kind) && JSON.parse(run.index_json).execution_bundle?.flow_id === run.flow_kind;
+    if (manifest?.schema_id === "dd-flow/run-controller-manifest@2" || ["mb-init", "mb-upgrade", "mb-fix", "review-fix", "interactive"].includes(run.flow_kind) || isDiagnosticFlow(run.flow_kind) || boundDistill || boundDelivery) {
         const bundle = readFlowRunExecutionBundle(context, { projectRoot: run.project_root, runId: run.id });
         if (!bundle || bundle.descriptor.descriptor.id !== run.flow_kind || bundle.descriptor.descriptor.id === "sdlc")
             throw new AppError("controller_execution_invalid", "Generic controller requires its retained non-SDLC bundle", 1);