@deksden-com/dd-flow-cli 0.9.0-beta.142 → 0.9.0-beta.144

package/dist/services/code-checks.js

@@ -275,7 +275,9 @@ function validateCheckEvidenceContext(value) {
     if (value !== undefined && (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9:._-]{0,255}$/.test(value)))
         throw new AppError("check_evidence_context_invalid", "Check evidence context must be a bounded opaque identifier", 2, { effect: "no_effect" });
 }
-const evidenceDigest = (value) => crypto.createHash("sha256").update(JSON.stringify(value)).digest("hex");
+// Additive NULL columns must not invalidate accepted legacy SQL digests.
+const scopedReceiptColumns = new Set(["fingerprint_scope", "input_manifest_json", "execution_failures_json", "execution_contract_hash"]);
+const evidenceDigest = (value) => crypto.createHash("sha256").update(JSON.stringify(value, (key, item) => scopedReceiptColumns.has(key) && item === null ? undefined : item)).digest("hex");
 /** Prepares current physical evidence outside a writer and retains an exact
  * SQL-only fence. Declarations must come from the owning handler/policy, never
  * from the result whose acceptance is being decided. This does not supply
@@ -348,6 +350,8 @@ export class PreparedCheckEvidence {
                 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)
+                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") };
         });
         const prepared = new PreparedCheckEvidence(input, snapshot, generation, references, artifacts, passed);
@@ -497,13 +501,29 @@ export async function runCodeChecks(context, input) {
         }
     }
     try {
-        return await runCodeChecksOwned(context, input, gate.id, generation);
+        let receipts = await runCodeChecksOwned(context, input, gate.id, generation);
+        // One bounded episode, not a product-repair turn. The second execution
+        // remains guarded by its own before/after snapshot and SQL reservation.
+        const stale = receipts.filter(staleCheckRetryEligible);
+        if (!input.retryReceiptId && !input.retryReceiptIds?.length && stale.length) {
+            const otherSession = context.db.get("SELECT 1 FROM work_sessions s JOIN works w ON w.work_id = s.work_id WHERE w.project_id = ? AND w.run_id = ? AND w.work_id != ? AND s.status = 'running' AND s.completed_at IS NULL LIMIT 1", [input.projectId, input.runId, input.workId ?? ""]);
+            if (!otherSession) {
+                for (const predecessor of stale) {
+                    const selected = input.checks.filter(check => predecessor.check_refs.includes(checkRef(check)));
+                    if (!selected.length || selected.some(check => check.reuse !== "deterministic"))
+                        continue;
+                    const retried = await runCodeChecksOwned(context, { ...input, retryReceiptId: predecessor.id, retryReason: "check_inputs_changed" }, gate.id, generation, new Set(predecessor.check_refs));
+                    receipts = receipts.filter(receipt => receipt.id !== predecessor.id).concat(retried);
+                }
+            }
+        }
+        return receipts;
     }
     finally {
         finishManagedProcess(context, { id: gate.id, leaseToken: gate.lease_token, state: "stopped", reason: "workspace_gate_settled" });
     }
 }
-async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
+async function runCodeChecksOwned(context, input, workspaceGateId, generation, selectedRefs) {
     assertRunMutationAllowed(context, input.projectId, input.runId, generation);
     for (const check of input.checks)
         validateCheckDeclaration(input.workspaceRoot, check);
@@ -520,7 +540,9 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
     });
     const resolved = resolveCodeCheckCommands(input.workspaceRoot, input.runId, checks.map((check) => check.command));
     assertConsistentDeclarations(checks, resolved);
-    const groups = deduplicate(checks, resolved), receipts = [];
+    // Retain all declarations for the planned-alias profile hash; filter only
+    // execution, otherwise a targeted retry changes its own frozen contract.
+    const groups = deduplicate(checks, resolved).filter(group => !selectedRefs || group.declarations.some(check => selectedRefs.has(checkRef(check)))), receipts = [];
     const retryIds = [...new Set([...(input.retryReceiptId ? [input.retryReceiptId] : []), ...(input.retryReceiptIds ?? [])])];
     const retries = new Map();
     for (const receiptId of retryIds) {
@@ -528,7 +550,8 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
         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)));
+                || sourceRepairContractMatches(predecessor, candidate, profileHash)
+                || 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 });
         // Preserve the identity of a pre-deduplication failed execution when an
@@ -540,10 +563,12 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
         const group = groups[index];
         const before = workspaceState(input.workspaceRoot, [input.runHome]);
         const startedAt = context.now();
-        const inputFingerprint = workspaceInputFingerprint(input.workspaceRoot, before.files, group.inputs, [input.runHome]);
+        const inputFiles = selectedInputFiles(input.workspaceRoot, before.files, group.inputs, [input.runHome]);
+        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${before.fingerprint}`).digest("hex");
-        const reservationInput = { ...input, retryReceiptIds: retries.has(group) ? [retries.get(group)] : [], generation, group, before, profileHash, inputHash, epoch, startedAt };
+        const epoch = crypto.createHash("sha256").update(`${group.gate}\0${inputFingerprint}`).digest("hex");
+        const executionContractHash = checkInputHash(input.workspaceRoot, group, profileHash, "", input.evidenceContext, input.checkEnvironment);
+        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);
         if (decision.receipt) {
@@ -557,6 +582,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
         let result = { exitCode: null, error: "check did not start", aborted: true };
         try {
             fs.mkdirSync(evidenceDir, { recursive: true });
+            retainInputManifest(context, reserved);
             const startingReceipt = receiptFor({ ...reserved, resources, result, status: "running", after: before, mutationPaths: [], artifacts: [] });
             if (group.runnerEvidence)
                 startingReceipt.runner_evidence_required = group.runnerEvidence;
@@ -610,7 +636,8 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
             result = { exitCode: null, error: error instanceof Error ? error.message : String(error), aborted: true };
         }
         const after = workspaceState(input.workspaceRoot, [input.runHome]);
-        const mutationPaths = changedPaths(before.files, after.files);
+        const afterFiles = selectedInputFiles(input.workspaceRoot, after.files, group.inputs, [input.runHome]);
+        const mutationPaths = changedPaths(reserved.inputFiles, afterFiles);
         let artifacts = collectCheckArtifacts(evidenceDir, group.requiredArtifacts);
         if (fs.existsSync(stderrPath)) {
             if (!artifacts.complete)
@@ -618,23 +645,27 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation) {
             if (result.error)
                 fs.appendFileSync(stderrPath, `\n${result.error}\n`);
             if (mutationPaths.length)
-                fs.appendFileSync(stderrPath, `\ncheck mutated project workspace: ${mutationPaths.join(", ")}\n`);
+                fs.appendFileSync(stderrPath, `\ncheck inputs changed while running: ${mutationPaths.join(", ")}\n`);
         }
         const runnerEvidence = group.runnerEvidence ? readRunnerEvidence(evidenceDir, group.runnerEvidence, { invocation_id: id, check_id: id, command: group.command, input_hash: inputHash, verification_epoch: epoch }) : undefined;
-        const physicalFailures = executionFailures({ exitCode: result.exitCode, launcherError: result.error ?? undefined, cleanupUnconfirmed: result.cleanupUnconfirmed, missing: artifacts.missing, mutations: mutationPaths, invalidRunner: Boolean(group.runnerEvidence && !runnerEvidence) });
+        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);
         const candidateFiles = candidateFailureFiles(runnerEvidence, input.workspaceRoot);
         if (group.runnerEvidence)
-            retainExecutionOutcome(evidenceDir, { id, command: group.command, input_hash: inputHash, verification_epoch: epoch }, input.workspaceRoot, physicalFailures, candidateFiles);
+            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);
         const requiredArtifacts = [...new Set([...group.requiredArtifacts, ...runnerProofArtifacts(runnerEvidence), ...(group.runnerEvidence ? ["engine-outcome.json"] : [])])];
         artifacts = collectCheckArtifacts(evidenceDir, requiredArtifacts);
         const status = result.aborted ? "aborted" : result.exitCode === 0 && !result.error && artifacts.complete && mutationPaths.length === 0 && (!group.runnerEvidence || runnerEvidencePass(runnerEvidence)) ? "passed" : "failed";
-        const receipt = receiptFor({ ...reserved, resources, result, status, after, mutationPaths, artifacts: artifacts.items });
+        const receipt = receiptFor({ ...reserved, resources, result, status, after: { ...after, fingerprint: inputFilesFingerprint(afterFiles) }, mutationPaths, artifacts: artifacts.items });
         receipt.required_artifacts = requiredArtifacts;
         receipt.candidate_root = input.workspaceRoot;
         receipt.candidate_files = candidateFiles;
         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);
+        if (completion)
+            writeCompletionSnapshot(completionPath, completion, receipt);
         if (group.runnerEvidence) {
             receipt.runner_evidence_required = group.runnerEvidence;
             receipt.runner_evidence = runnerEvidence ?? null;
@@ -678,6 +709,10 @@ export function reconcileUnfinishedChecks(context, input) {
     for (const pendingReceipt of pending) {
         const process = processes.filter((item) => item.check_id === pendingReceipt.id && item.project_id === input.projectId && item.run_id === input.runId).at(-1);
         const receipt = readReceipt(pendingReceipt.receipt_path);
+        const authority = context.db.get("SELECT * FROM check_receipts WHERE project_id = ? AND id = ?", [input.projectId, pendingReceipt.id]);
+        if ((receipt?.fingerprint_scope ?? null) !== (authority?.fingerprint_scope ?? null)
+            || authority?.fingerprint_scope === "check_inputs" && JSON.stringify(receipt?.input_manifest ?? null) !== authority.input_manifest_json)
+            throw new AppError("check_receipt_changed", "Detached receipt scope or input manifest differs from SQL custody", 2, { check_receipt_id: pendingReceipt.id });
         const completion = receipt ? readCompletion(receipt.completion_path || path.join(path.dirname(pendingReceipt.receipt_path), "completion.json")) : null;
         // A stale lease after host sleep is not permission to duplicate a living
         // check.  Its durable completion marker or explicit reconciliation decides
@@ -694,11 +729,24 @@ export function reconcileUnfinishedChecks(context, input) {
         }
         const after = workspaceState(input.workspaceRoot, input.runHome ? [input.runHome] : []);
         let artifacts = receipt ? collectCheckArtifacts(path.join(path.dirname(receipt.completion_path || pendingReceipt.receipt_path), "artifacts"), receipt.required_artifacts ?? []) : { complete: false, missing: [], items: [] };
-        const workspaceUnchanged = receipt?.before_fingerprint === after.fingerprint;
+        const scoped = receipt?.fingerprint_scope === "check_inputs";
+        const completionSnapshot = scoped && completion?.fingerprint_scope === "check_inputs" && completion.id === receipt.id && completion.input_hash === receipt.input_hash
+            && completion.verification_epoch === receipt.verification_epoch && completion.before_fingerprint === receipt.before_fingerprint
+            && JSON.stringify(completion.input_manifest ?? null) === JSON.stringify(receipt.input_manifest ?? null) && typeof completion.after_fingerprint === "string";
+        const afterFingerprint = scoped ? completionSnapshot ? completion.after_fingerprint : workspaceInputFingerprint(input.workspaceRoot, after.files, receipt.inputs ?? [], input.runHome ? [input.runHome] : []) : after.fingerprint;
+        const workspaceUnchanged = receipt?.before_fingerprint === afterFingerprint;
+        const beforeFiles = scoped ? retainedInputFiles(receipt) : null;
+        // A completion digest describes that instant, not the later recovery tree.
+        // Without an after manifest, never attach today's delta to that old proof.
+        const mutationPaths = workspaceUnchanged ? [] : scoped && completionSnapshot ? ["<declared check inputs differed at completion; exact delta unavailable>"]
+            : scoped && beforeFiles ? changedPaths(beforeFiles, selectedInputFiles(input.workspaceRoot, after.files, receipt.inputs ?? [], input.runHome ? [input.runHome] : []))
+                : [scoped ? "<declared check inputs changed; exact manifest unavailable>" : "<workspace changed while detached check ran>"];
         const runnerEvidence = receipt?.runner_evidence_required ? readRunnerEvidence(path.join(path.dirname(pendingReceipt.receipt_path), "artifacts"), receipt.runner_evidence_required, { invocation_id: receipt.id, check_id: receipt.id, command: receipt.command, input_hash: receipt.input_hash, verification_epoch: receipt.verification_epoch }) : undefined;
         const exitCode = completion?.exit_code ?? null;
         const finishedAt = completion?.finished_at ?? context.now();
-        const physicalFailures = executionFailures({ exitCode, missing: artifacts.missing.filter(file => file !== "engine-outcome.json"), mutations: workspaceUnchanged ? [] : ["<workspace changed while detached check ran>"], invalidRunner: Boolean(receipt?.runner_evidence_required && !runnerEvidence) });
+        const physicalFailures = executionFailures({ fingerprintScope: scoped ? "check_inputs" : undefined, exitCode, missing: artifacts.missing.filter(file => file !== "engine-outcome.json"), mutations: mutationPaths, invalidRunner: Boolean(receipt?.runner_evidence_required && !runnerEvidence) });
+        if (scoped && !completionSnapshot)
+            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);
         if (receipt?.runner_evidence_required) {
             const evidenceDir = path.join(path.dirname(pendingReceipt.receipt_path), "artifacts");
@@ -720,11 +768,12 @@ export function reconcileUnfinishedChecks(context, input) {
             artifacts = collectCheckArtifacts(evidenceDir, receipt.required_artifacts);
         }
         const status = completion === null ? "aborted" : completion.exit_code === 0 && workspaceUnchanged && artifacts.complete && physicalFailures.length === 0 && (!receipt?.runner_evidence_required || runnerEvidencePass(runnerEvidence)) ? "passed" : "failed";
-        context.db.run("UPDATE check_receipts SET status = ?, exit_code = ?, after_fingerprint = ?, mutation_paths_json = ?, artifacts_json = ?, finished_at = ? WHERE id = ? AND project_id = ? AND status = 'running'", [status, exitCode, after.fingerprint, JSON.stringify(workspaceUnchanged ? [] : ["<workspace changed while detached check ran>"]), JSON.stringify(artifacts.items), finishedAt, pendingReceipt.id, input.projectId]);
+        context.db.run("UPDATE check_receipts SET status = ?, exit_code = ?, after_fingerprint = ?, mutation_paths_json = ?, artifacts_json = ?, finished_at = ? WHERE id = ? AND project_id = ? AND status = 'running'", [status, exitCode, afterFingerprint, JSON.stringify(mutationPaths), JSON.stringify(artifacts.items), finishedAt, pendingReceipt.id, input.projectId]);
+        context.db.run("UPDATE check_receipts SET execution_failures_json = ? WHERE project_id = ? AND id = ?", [JSON.stringify(physicalFailures), input.projectId, pendingReceipt.id]);
         if (process)
             finishManagedProcess(context, { id: process.id, leaseToken: process.lease_token, state: status === "passed" ? "stopped" : "failed", reason: status === "passed" ? "reconciled_completion" : completion === null ? "completion_marker_missing" : "reconciled_check_failed" });
         if (receipt) {
-            const repaired = { ...receipt, ...(receipt.runner_evidence_required ? { runner_evidence: runnerEvidence ?? null } : {}), completion_path: receipt.completion_path || path.join(path.dirname(pendingReceipt.receipt_path), "completion.json"), required_artifacts: receipt.required_artifacts ?? [], ...(status === "aborted" ? { abort_reason: "completion_marker_missing" } : {}), status, exit_code: exitCode, after_fingerprint: after.fingerprint, mutation_paths: workspaceUnchanged ? [] : ["<workspace changed while detached check ran>"], artifacts: artifacts.items, finished_at: finishedAt };
+            const repaired = { ...receipt, ...(receipt.runner_evidence_required ? { runner_evidence: runnerEvidence ?? null } : {}), completion_path: receipt.completion_path || path.join(path.dirname(pendingReceipt.receipt_path), "completion.json"), required_artifacts: receipt.required_artifacts ?? [], ...(status === "aborted" ? { abort_reason: "completion_marker_missing" } : {}), status, exit_code: exitCode, after_fingerprint: afterFingerprint, mutation_paths: mutationPaths, artifacts: artifacts.items, finished_at: finishedAt };
             repaired.candidate_root = input.workspaceRoot;
             repaired.candidate_files = candidateFiles;
             repaired.execution_failures = physicalFailures;
@@ -739,18 +788,19 @@ export function reconcileUnfinishedChecks(context, input) {
 function reserveOrReuseReceipt(context, input) {
     // Receipt files and artifact hashes are prepared before reserving SQLite.
     // The compact SQL snapshot below fences races with another check settlement.
-    const snapshotSql = "SELECT id, status, exit_code, input_hash, profile_hash, command, gate, retry_of_receipt_id, receipt_path FROM check_receipts WHERE project_id = ? AND run_id = ? ORDER BY reservation_sequence, rowid";
+    const snapshotSql = "SELECT * FROM check_receipts WHERE project_id = ? AND run_id = ? ORDER BY reservation_sequence, rowid";
     const snapshot = JSON.stringify(context.db.all(snapshotSql, [input.projectId, input.runId]));
     const receipts = checkReceipts(context, { projectId: input.projectId, runId: input.runId });
     if (JSON.stringify(context.db.all(snapshotSql, [input.projectId, input.runId])) !== snapshot)
         throw new AppError("check_receipt_changed", "Check receipts changed during evidence preparation", 1);
-    const prior = receipts.filter((receipt) => receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash).at(-1) ?? null;
+    const prior = receipts.filter((receipt) => receipt.fingerprint_scope === "check_inputs" && receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash).at(-1) ?? null;
     const reusablePrior = prior?.status === "passed" && checkReceiptEvidenceValid(prior);
     const retryIds = new Set([...(input.retryReceiptId ? [input.retryReceiptId] : []), ...(input.retryReceiptIds ?? [])]);
     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 && (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);
     return context.db.writeTransaction(() => {
         assertRunMutationAllowed(context, input.projectId, input.runId, input.generation);
@@ -762,6 +812,13 @@ function reserveOrReuseReceipt(context, input) {
             throw new AppError("retry_check_invalid", "A check execution accepts exactly one retry predecessor", 2);
         const retryId = [...retryIds][0];
         if (retryId) {
+            if (input.retryReason === "check_inputs_changed" && retryPredecessor) {
+                const allSuccessors = receipts.filter(receipt => receipt.retry_of_receipt_id === retryId);
+                if (allSuccessors.length === 1 && reusableSuccessor)
+                    return { receipt: successor };
+                if (retryPredecessor.retry_reason === "check_inputs_changed" || allSuccessors.length)
+                    throw new AppError("retry_check_invalid", "Scoped input retry episode already consumed its one successor", 2, { check_receipt_id: retryId });
+            }
             if (!input.retryReason?.trim())
                 throw new AppError("retry_check_invalid", "A check retry requires the restored-condition reason", 2, { check_receipt_id: retryId });
             const predecessor = receipts.find(receipt => receipt.id === retryId);
@@ -779,6 +836,9 @@ 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)
+            return { receipt: latestContract };
         if (prior && ["failed", "aborted"].includes(prior.status) && !retryId)
             return { receipt: prior };
         if (prior?.status === "passed" && !retryIds.has(prior.id) && input.group.reusable && reusablePrior)
@@ -791,8 +851,9 @@ function reserveOrReuseReceipt(context, input) {
             id = `${input.workId ?? input.runId}/${localId}`;
         }
         const directory = path.join(input.runHome, input.artifactDir ?? "05-code", "checks", localId);
-        const reserved = { id, localId, directory, evidenceDir: path.join(directory, "artifacts"), stdoutPath: path.join(directory, "stdout.log"), stderrPath: path.join(directory, "stderr.log"), receiptPath: path.join(directory, "receipt.json"), completionPath: path.join(directory, "completion.json"), group: input.group, before: input.before, profileHash: input.profileHash, inputHash: input.inputHash, epoch: input.epoch, startedAt: input.startedAt, scope: input.scope, ...(retryId ? { retryOf: retryId, retryReason: input.retryReason } : {}), ...(input.workId ? { workId: input.workId } : {}), projectId: input.projectId, runId: input.runId };
+        const reserved = { id, localId, directory, evidenceDir: path.join(directory, "artifacts"), stdoutPath: path.join(directory, "stdout.log"), stderrPath: path.join(directory, "stderr.log"), receiptPath: path.join(directory, "receipt.json"), completionPath: path.join(directory, "completion.json"), group: input.group, before: input.before, inputFiles: input.inputFiles, inputFingerprint: input.inputFingerprint, executionContractHash: input.executionContractHash, profileHash: input.profileHash, inputHash: input.inputHash, epoch: input.epoch, startedAt: input.startedAt, scope: input.scope, ...(retryId ? { retryOf: retryId, retryReason: input.retryReason } : {}), ...(input.workId ? { workId: input.workId } : {}), projectId: input.projectId, runId: input.runId, workspaceRoot: input.workspaceRoot, runHome: input.runHome };
         context.db.run("INSERT INTO check_receipts (id, project_id, run_id, work_id, scope, declaration_id, check_refs_json, gate, command, input_hash, verification_epoch, reservation_sequence, retry_of_receipt_id, retry_reason, status, exit_code, stdout_path, stderr_path, receipt_path, workspace_fingerprint, before_fingerprint, after_fingerprint, profile_hash, mutation_paths_json, artifacts_json, started_at, finished_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', NULL, ?, ?, ?, ?, ?, ?, ?, '[]', '[]', ?, ?)", [id, input.projectId, input.runId, input.workId ?? null, input.scope, input.group.declarations[0].id, JSON.stringify(input.group.declarations.map(checkRef).sort()), input.group.gate, input.group.command, input.inputHash, input.epoch, ordinal, reserved.retryOf ?? null, reserved.retryReason ?? null, reserved.stdoutPath, reserved.stderrPath, reserved.receiptPath, input.before.fingerprint, input.before.fingerprint, input.before.fingerprint, input.profileHash, input.startedAt, input.startedAt]);
+        context.db.run("UPDATE check_receipts SET fingerprint_scope = ?, before_fingerprint = ?, after_fingerprint = ?, execution_contract_hash = ? WHERE id = ? AND project_id = ?", ["check_inputs", input.inputFingerprint, input.inputFingerprint, input.executionContractHash, id, input.projectId]);
         return { reserved };
     }, "checks.reserveOrReuseReceipt");
 }
@@ -800,7 +861,48 @@ 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 receiptFor(input) { return { id: input.id, local_id: input.localId, declaration_id: input.group.declarations[0].id, check_refs: input.group.declarations.map(checkRef), gate: input.group.gate, scope: input.scope, work_id: input.workId ?? null, command: input.group.command, input_hash: input.inputHash, verification_epoch: input.epoch, retry_of_receipt_id: input.retryOf ?? null, retry_reason: input.retryReason ?? null, status: input.status, ...(input.status === "aborted" ? { abort_reason: input.result.error } : {}), exit_code: input.status === "running" ? null : input.result.exitCode, stdout_path: input.stdoutPath, stderr_path: input.stderrPath, receipt_path: input.receiptPath, completion_path: input.completionPath, required_artifacts: input.group.requiredArtifacts, inputs: input.group.inputs, workspace_fingerprint: input.before.fingerprint, before_fingerprint: input.before.fingerprint, after_fingerprint: input.after.fingerprint, profile_hash: input.profileHash, mutation_paths: input.mutationPaths, artifacts: input.artifacts, resources: { ports: input.resources }, started_at: input.startedAt, finished_at: input.status === "running" ? input.startedAt : new Date().toISOString() }; }
+function staleCheckRetryEligible(receipt) {
+    if (receipt.fingerprint_scope !== "check_inputs" || receipt.status !== "failed" || receipt.exit_code !== 0 || receipt.retry_reason === "check_inputs_changed"
+        || !receipt.execution_failures?.length || receipt.execution_failures.some(failure => failure.code !== "check_inputs_changed")
+        || receipt.runner_evidence_required && !runnerEvidencePass(receipt.runner_evidence))
+        return false;
+    return checkReceiptEvidenceValidForMode(receipt, "diagnostic");
+}
+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);
+}
+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) {
+    const full = JSON.stringify({ fingerprint_scope: "check_inputs", before_fingerprint: reserved.inputFingerprint, files: [...reserved.inputFiles].sort(([left], [right]) => left.localeCompare(right)) });
+    const truncated = Buffer.byteLength(full) > 1024 * 1024;
+    const bytes = truncated ? JSON.stringify({ fingerprint_scope: "check_inputs", before_fingerprint: reserved.inputFingerprint, truncated: true }) : full;
+    const relative = "inputs-before.json", file = path.join(reserved.directory, relative);
+    fs.writeFileSync(file, bytes, { flag: "wx", mode: 0o600 });
+    reserved.inputManifest = { path: relative, sha256: crypto.createHash("sha256").update(bytes).digest("hex"), truncated };
+    context.db.run("UPDATE check_receipts SET input_manifest_json = ? WHERE project_id = ? AND id = ? AND status = 'running'", [JSON.stringify(reserved.inputManifest), reserved.projectId, reserved.id]);
+}
+function retainedInputFiles(receipt) {
+    if (!receipt.input_manifest || receipt.input_manifest.truncated || receipt.input_manifest.path !== "inputs-before.json")
+        return null;
+    try {
+        const bytes = readBoundedReleaseFile(path.join(path.dirname(receipt.receipt_path), receipt.input_manifest.path), 1024 * 1024);
+        if (crypto.createHash("sha256").update(bytes).digest("hex") !== receipt.input_manifest.sha256)
+            return null;
+        const value = JSON.parse(bytes.toString("utf8"));
+        if (value.before_fingerprint !== receipt.before_fingerprint || !Array.isArray(value.files) || value.files.some((entry) => !Array.isArray(entry) || entry.length !== 2 || entry.some(item => typeof item !== "string")))
+            return null;
+        return new Map(value.files);
+    }
+    catch {
+        return null;
+    }
+}
+function writeCompletionSnapshot(file, completion, receipt) {
+    const temporary = file + ".tmp-" + crypto.randomUUID();
+    fs.writeFileSync(temporary, JSON.stringify({ ...completion, fingerprint_scope: receipt.fingerprint_scope, id: receipt.id, input_hash: receipt.input_hash, verification_epoch: receipt.verification_epoch, before_fingerprint: receipt.before_fingerprint, after_fingerprint: receipt.after_fingerprint, input_manifest: receipt.input_manifest ?? null }));
+    fs.renameSync(temporary, file);
+}
 function writeReceipt(file, receipt) { const temporary = `${file}.tmp-${process.pid}-${crypto.randomUUID()}`; fs.writeFileSync(temporary, `${JSON.stringify(receipt, null, 2)}\n`); fs.renameSync(temporary, file); }
 function readReceipt(file) { try {
     return JSON.parse(fs.readFileSync(file, "utf8"));
@@ -811,7 +913,7 @@ catch {
 function readCompletion(file) { try {
     const value = JSON.parse(fs.readFileSync(file, "utf8"));
     const done = value;
-    return value && typeof value === "object" && Number.isInteger(done.exit_code) ? { exit_code: Number(done.exit_code), finished_at: typeof done.finished_at === "string" && Number.isFinite(Date.parse(done.finished_at)) ? done.finished_at : null } : null;
+    return value && typeof value === "object" && Number.isInteger(done.exit_code) ? { ...done, exit_code: Number(done.exit_code), finished_at: typeof done.finished_at === "string" && Number.isFinite(Date.parse(done.finished_at)) ? done.finished_at : null } : null;
 }
 catch {
     return null;
@@ -826,15 +928,20 @@ 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;
 }
 export function checkReceipts(context, input) {
     const where = input.workId ? "project_id = ? AND run_id = ? AND work_id = ?" : "project_id = ? AND run_id = ?";
     const params = input.workId ? [input.projectId, input.runId, input.workId] : [input.projectId, input.runId];
-    return context.db.all(`SELECT id, declaration_id, check_refs_json, gate, scope, work_id, command, input_hash, verification_epoch, retry_of_receipt_id, retry_reason, status, exit_code, stdout_path, stderr_path, receipt_path, workspace_fingerprint, before_fingerprint, after_fingerprint, profile_hash, mutation_paths_json, artifacts_json, started_at, finished_at FROM check_receipts WHERE ${where} ORDER BY reservation_sequence, rowid`, params).map(projectCheckReceiptRow);
+    return context.db.all(`SELECT * FROM check_receipts WHERE ${where} ORDER BY reservation_sequence, rowid`, params).map(projectCheckReceiptRow);
 }
 function projectCheckReceiptRow(row) {
-    const receipt = { ...row, local_id: row.id.slice(row.id.lastIndexOf("/") + 1), check_refs: parseArray(row.check_refs_json, [row.declaration_id]), mutation_paths: parseArray(row.mutation_paths_json, []), resources: readReceiptResources(row.receipt_path), ...resolvedReceiptArtifacts(row.receipt_path, JSON.parse(row.artifacts_json), row) };
+    const inputManifest = row.input_manifest_json ? JSON.parse(row.input_manifest_json) : null;
+    const receipt = { ...row, input_manifest: inputManifest, local_id: row.id.slice(row.id.lastIndexOf("/") + 1), check_refs: parseArray(row.check_refs_json, [row.declaration_id]), mutation_paths: parseArray(row.mutation_paths_json, []), resources: readReceiptResources(row.receipt_path), ...resolvedReceiptArtifacts(row.receipt_path, JSON.parse(row.artifacts_json), { ...row, input_manifest: inputManifest }), ...(row.execution_failures_json ? { execution_failures: JSON.parse(row.execution_failures_json) } : {}) };
     if (receipt.status === "failed")
         receipt.diagnostic_evidence_valid = checkReceiptEvidenceValidForMode(receipt, "diagnostic");
     return receipt;
@@ -867,7 +974,7 @@ 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 && 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)) && 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)) && 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. */ }
@@ -885,7 +992,7 @@ function executionFailures(input) {
     if (input.missing.length)
         failures.push({ code: "missing_required_artifact", message: input.missing.join(", ") });
     if (input.mutations.length)
-        failures.push({ code: "check_input_mutated", message: input.mutations.join(", ") });
+        failures.push({ code: input.fingerprintScope === "check_inputs" ? "check_inputs_changed" : "check_input_mutated", message: input.mutations.join(", ") });
     if (input.invalidRunner)
         failures.push({ code: "invalid_runner_evidence", message: "Required runner evidence is unavailable or invalid" });
     return failures;
@@ -894,7 +1001,7 @@ function retainExecutionOutcome(evidenceDir, binding, candidateRoot, failures, c
     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, candidate_root: candidateRoot, candidate_files: candidateFiles, 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, execution_failures: failures }), { flag: "wx", mode: 0o600 });
     fs.renameSync(temporary, path.join(evidenceDir, "engine-outcome.json"));
 }
 export function workspaceFingerprint(root) { return workspaceState(root).fingerprint; }
@@ -1002,10 +1109,16 @@ function workspaceState(root, ignoredRoots = []) {
     }
     return { fingerprint: hash.digest("hex"), files };
 }
-function workspaceInputFingerprint(root, files, inputs, ignoredRoots) {
+function selectedInputFiles(root, files, inputs, ignoredRoots) {
     const selected = new Map(inputs.length === 0 || inputs.includes(".") ? files : []);
-    for (const [file, digest] of explicitInputFiles(root, inputs.filter(input => input !== "."), ignoredRoots))
+    for (const [file, digest] of explicitInputFiles(root, inputs.filter(input => input !== "."), ignoredRoots, files.keys()))
         selected.set(file, digest);
+    return selected;
+}
+function workspaceInputFingerprint(root, files, inputs, ignoredRoots) {
+    return inputFilesFingerprint(selectedInputFiles(root, files, inputs, ignoredRoots));
+}
+function inputFilesFingerprint(selected) {
     const hash = crypto.createHash("sha256");
     for (const [file, digest] of [...selected].sort(([left], [right]) => left.localeCompare(right)))
         hash.update(file).update("\0").update(digest).update("\0");
@@ -1080,23 +1193,40 @@ export function reconcileWorkspaceOwnership(context, workspaceRoot) {
 }
 function normalizedInputs(inputs) { for (const input of inputs)
     validateCheckInputSyntax(input); return [...new Set(inputs.map((input) => { const normalized = path.posix.normalize(input.replaceAll("\\", "/")).replace(/^\.\/$/, ""); return normalized === "" || normalized === "." ? "." : normalized.replace(/\/$/, ""); }))].sort(); }
-function validateCheckInputs(workspaceRoot, inputs) { const root = fs.realpathSync.native(workspaceRoot); for (const input of normalizedInputs(inputs)) {
-    if (input === ".git" || input.startsWith(".git/"))
-        throw new AppError("invalid_check_input", "Check inputs cannot include Git internals", 2, { input });
+function validateCheckInputs(workspaceRoot, inputs) { const root = fs.realpathSync.native(workspaceRoot); const allowed = sourceInputPathFilter(workspaceRoot, inputs); for (const input of normalizedInputs(inputs)) {
+    if (input.split("/").some(part => [".git", "node_modules"].includes(part)))
+        throw new AppError("invalid_check_input", "Check inputs cannot include Git internals or installed dependencies; declare lock/config inputs", 2, { input });
     const candidate = path.resolve(workspaceRoot, input);
     if (candidate !== workspaceRoot && !candidate.startsWith(`${workspaceRoot}${path.sep}`))
         throw new AppError("invalid_check_input", "Check inputs must stay within the workspace", 2, { input });
     if (fs.existsSync(candidate))
-        validateInputTree(root, candidate, input, new Set());
+        validateInputTree(root, candidate, input, new Set(), allowed);
     else
         validateMissingInputParent(root, candidate, input);
 } }
+/** Directory scopes select source inventory, not generated Git-ignored output.
+ * Direct ignored inputs (e.g. a real config) remain explicit obligations. */
+function sourceInputPathFilter(root, inputs, sourceFiles) {
+    const listing = sourceFiles ? [...sourceFiles] : workspaceGitFiles(root, ["-co", "--exclude-standard"]);
+    const retained = new Set([...(listing ?? []), ...inputs]), branches = new Set();
+    for (const file of retained)
+        for (let parent = path.posix.dirname(file); parent !== "." && parent !== "/"; parent = path.posix.dirname(parent))
+            branches.add(parent);
+    const explicitTrees = inputs.filter(input => !listing?.some(file => file === input || file.startsWith(`${input}/`)));
+    const serviceAllowed = projectServicePathFilter(root, inputs, listing ?? []);
+    return file => {
+        const relative = path.relative(root, file).split(path.sep).join("/");
+        if (relative.split("/").some(part => [".git", "node_modules"].includes(part)) || !serviceAllowed(file))
+            return false;
+        return listing === null || retained.has(relative) || branches.has(relative) || explicitTrees.some(input => relative.startsWith(`${input}/`));
+    };
+}
 function validateCheckInputSyntax(input) { if (typeof input !== "string" || !input.trim() || path.isAbsolute(input) || input.split(/[\\/]/).includes(".."))
     throw new AppError("invalid_check_input", "Check inputs must be non-empty relative workspace paths", 2, { input }); }
 function validateMissingInputParent(root, candidate, input) { let parent = candidate; while (!fs.existsSync(parent))
     parent = path.dirname(parent); const resolved = fs.realpathSync.native(parent); if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`))
     throw new AppError("invalid_check_input", "Check input parent symlink escapes the workspace", 2, { input }); }
-function validateInputTree(root, candidate, input, seen) {
+function validateInputTree(root, candidate, input, seen, allowed) {
     const resolved = fs.realpathSync.native(candidate);
     if (resolved !== root && !resolved.startsWith(`${root}${path.sep}`))
         throw new AppError("invalid_check_input", "Check input symlink escapes the workspace", 2, { input });
@@ -1104,13 +1234,19 @@ function validateInputTree(root, candidate, input, seen) {
         throw new AppError("invalid_check_input", "Check input contains a symbolic-link cycle", 2, { input });
     seen.add(resolved);
     const stat = fs.statSync(candidate);
+    if (stat.isDirectory() && fs.lstatSync(candidate).isSymbolicLink())
+        throw new AppError("invalid_check_input", "Directory symlinks cannot prove scoped source inputs; declare their contained real source path instead", 2, { input });
     if (stat.isDirectory())
-        for (const entry of fs.readdirSync(candidate))
-            validateInputTree(root, path.join(candidate, entry), input, seen);
+        for (const entry of fs.readdirSync(candidate)) {
+            const file = path.join(candidate, entry);
+            if (allowed(file))
+                validateInputTree(root, file, input, seen, allowed);
+        }
     seen.delete(resolved);
 }
-function explicitInputFiles(root, inputs, ignoredRoots) {
+function explicitInputFiles(root, inputs, ignoredRoots, sourceFiles) {
     const rootReal = fs.realpathSync.native(root), ignored = ignoredRoots.map(entry => path.resolve(entry)), result = new Map();
+    const allowed = sourceInputPathFilter(root, inputs, sourceFiles);
     const visit = (file, relative, seen) => {
         if (ignored.some(entry => file === entry || file.startsWith(`${entry}${path.sep}`)))
             return;
@@ -1123,15 +1259,21 @@ function explicitInputFiles(root, inputs, ignoredRoots) {
             throw new AppError("invalid_check_input", "Check input symlink escapes the workspace", 2, { input: relative });
         if (seen.has(resolved))
             throw new AppError("invalid_check_input", "Check input contains a symbolic-link cycle", 2, { input: relative });
+        const symbolic = fs.lstatSync(file).isSymbolicLink();
         const stat = fs.statSync(file);
+        if (symbolic && stat.isDirectory())
+            throw new AppError("invalid_check_input", "Directory symlinks cannot prove scoped source inputs; declare their contained real source path instead", 2, { input: relative });
         if (stat.isDirectory()) {
             seen.add(resolved);
-            for (const entry of fs.readdirSync(file).sort())
-                visit(path.join(file, entry), path.posix.join(relative, entry), seen);
+            for (const entry of fs.readdirSync(file).sort()) {
+                const child = path.join(file, entry);
+                if (allowed(child))
+                    visit(child, path.posix.join(relative, entry), seen);
+            }
             seen.delete(resolved);
         }
         else if (stat.isFile())
-            result.set(relative, crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex"));
+            result.set(relative, crypto.createHash("sha256").update(symbolic ? `symlink\0${fs.readlinkSync(file)}\0` : "").update(fs.readFileSync(file)).digest("hex"));
     };
     for (const input of inputs)
         visit(path.resolve(root, input), input, new Set());
@@ -1143,8 +1285,24 @@ function bindReceipt(receipt, group) { return { ...receipt, gate: group.gate, de
 export function checkReceiptEvidenceValid(receipt) { return checkReceiptEvidenceValidForMode(receipt); }
 function checkReceiptEvidenceValidForMode(receipt, mode) {
     try {
-        if (!(receipt.status === "passed" && receipt.exit_code === 0 || mode === "diagnostic" && receipt.status === "failed" && typeof receipt.exit_code === "number" && receipt.exit_code !== 0) || receipt.before_fingerprint !== receipt.after_fingerprint
-            || receipt.mutation_paths.length !== 0 || receipt.completion_path !== path.join(path.dirname(receipt.receipt_path), "completion.json")
+        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")
+            return false;
+        if (receipt.fingerprint_scope === "check_inputs") {
+            const completion = readCompletion(receipt.completion_path);
+            if (!completion || completion.fingerprint_scope !== "check_inputs" || completion.id !== receipt.id || completion.input_hash !== receipt.input_hash
+                || completion.verification_epoch !== receipt.verification_epoch || completion.before_fingerprint !== receipt.before_fingerprint || completion.after_fingerprint !== receipt.after_fingerprint
+                || JSON.stringify(completion.input_manifest ?? null) !== JSON.stringify(receipt.input_manifest ?? null))
+                return false;
+            if (!receipt.input_manifest || receipt.input_manifest.path !== "inputs-before.json")
+                return false;
+            const manifestBytes = readBoundedReleaseFile(path.join(path.dirname(receipt.receipt_path), receipt.input_manifest.path), 1024 * 1024);
+            if (crypto.createHash("sha256").update(manifestBytes).digest("hex") !== receipt.input_manifest.sha256)
+                return false;
+        }
+        if (!(receipt.status === "passed" && receipt.exit_code === 0 || mode === "diagnostic" && receipt.status === "failed" && typeof receipt.exit_code === "number" && receipt.exit_code !== 0 || staleDiagnostic) || !staleDiagnostic && receipt.before_fingerprint !== receipt.after_fingerprint
+            || !staleDiagnostic && receipt.mutation_paths.length !== 0 || receipt.completion_path !== path.join(path.dirname(receipt.receipt_path), "completion.json")
             || readCompletion(receipt.completion_path)?.exit_code !== receipt.exit_code)
             return false;
         const stored = readReceipt(receipt.receipt_path);
@@ -1156,16 +1314,24 @@ function checkReceiptEvidenceValidForMode(receipt, mode) {
         // Gate/ref labels may be rebound for explicit deterministic reuse. Physical
         // execution identity and settled SQL evidence must never be rebound from a
         // mutable receipt file, including after recovery relocates the RUN home.
-        const fields = ["id", "scope", "work_id", "command", "input_hash", "verification_epoch", "status", "exit_code",
+        const fields = ["fingerprint_scope", "execution_contract_hash", "id", "scope", "work_id", "command", "input_hash", "verification_epoch", "status", "exit_code",
             "workspace_fingerprint", "before_fingerprint", "after_fingerprint", "profile_hash", "started_at", "finished_at"];
-        if (fields.some(field => stored[field] !== receipt[field]) || !Array.isArray(stored.artifacts)
-            || !Array.isArray(stored.mutation_paths) || stored.mutation_paths.length !== 0
+        if (JSON.stringify(stored.input_manifest ?? null) !== JSON.stringify(receipt.input_manifest ?? null))
+            return false;
+        if (fields.some(field => (stored[field] ?? null) !== (receipt[field] ?? null)) || !Array.isArray(stored.artifacts)
+            || !Array.isArray(stored.mutation_paths) || !isDeepStrictEqual(stored.mutation_paths, receipt.mutation_paths)
             || JSON.stringify(stored.required_artifacts) !== JSON.stringify(receipt.required_artifacts)
             || JSON.stringify(stored.inputs) !== JSON.stringify(receipt.inputs))
             return false;
-        const retained = resolvedReceiptArtifacts(receipt.receipt_path, stored.artifacts, receipt).artifacts;
+        const retainedProof = resolvedReceiptArtifacts(receipt.receipt_path, stored.artifacts, receipt);
+        const retained = retainedProof.artifacts;
         if (JSON.stringify(retained) !== JSON.stringify(receipt.artifacts))
             return false;
+        // 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 ?? []))
+            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 })))
             return false;

package/dist/services/provider-capacity.js

@@ -275,7 +275,11 @@ export async function continueProviderCapacity(input) {
             const seen = await observe(() => input.inspectSession(turnId));
             input.signal?.throwIfAborted();
             input.assertCurrent();
-            const items = (seen.terminal_turn_id === turnId && seen.terminal_status === "failed" ? seen.native_turn_items : confirmed?.native_turn_items);
+            // An unloaded exact-Turn snapshot is not conflicting tool evidence.
+            // Preserve the bound failure receipt, but never hide a pending item.
+            const freshItems = seen.native_turn_items;
+            const items = (seen.terminal_turn_id === turnId && seen.terminal_status === "failed"
+                && !(freshItems?.observed === false && freshItems.pending !== true) ? freshItems : confirmed?.native_turn_items);
             return capacityReadiness(seen, input.sessionId, operationId, turnId, items, input.allowSettledDescendants);
         };
         const ready = await readiness();

package/dist/services/repair-intents.js

@@ -8,7 +8,7 @@ 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 causes = input.failures.map(receipt => ({ id: receipt.id, epoch: receipt.verification_epoch, fingerprint: receipt.workspace_fingerprint })).sort((a, b) => a.id.localeCompare(b.id));
+    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);
 }
 export function ensureRepairIntent(context, input, create) {