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

package/dist/services/cli-upgrade-allowlist.js

@@ -10,7 +10,7 @@ export function isUpgradeAllowlisted(args) {
         return true;
     if (family === "engine" && command === "resolve")
         return true;
-    if (family === "migration" && ["impact", "plan", "report", "verify", "apply"].includes(command ?? ""))
+    if (family === "migration" && ["impact", "readiness", "plan", "report", "verify", "apply"].includes(command ?? ""))
         return true;
     if (family === "memory" && command === "permissions" && parsed.positional[2] === "preflight")
         return true;

package/dist/services/code-checks.js

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { candidateFailureFiles, checkRepairDisposition, readRunnerEvidence, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations, runnerProofArtifacts } from "./check-runner-evidence.js";
+import { candidateAbsencesValid, candidateFailureAbsences, candidateFailureFiles, checkRepairDisposition, readRunnerEvidence, readRunnerProgress, runnerContractsValid, runnerEvidencePass, runnerObservationDurations, runnerProofArtifacts } from "./check-runner-evidence.js";
 export { assertSourceRepairEligible, checkRepairDisposition } from "./check-runner-evidence.js";
 import { isGitlessWorkspace, ownedWorkspaceHookPath, projectServicePathFilter, workspaceGitFiles } from "./workspace-files.js";
 import { spawn, spawnSync } from "node:child_process";
@@ -16,6 +16,7 @@ import { confirmManagedProcess, finishManagedProcess, renewManagedProcess, manag
 import { admitRuntimeCheck, runtimeBudgetForRun } from "./runtime-budget.js";
 import { getResourceDatabase } from "../storage/database.js";
 import { readBoundedReleaseFile } from "./release-source.js";
+import { ownedCheckEnvironment, validateCheckEnvironment } from "./check-environment.js";
 const profileRelativePath = path.join(".memory-bank", "spec", "engineering", "code-check-profile.json");
 // Receipt reservation precedes child spawn so an interrupted CLI leaves an
 // auditable attempt. A second caller must not mistake that small handoff window
@@ -61,10 +62,7 @@ export function terminalCheckSettled(context, record) {
     }
 }
 export function codeExecutionEnvironment(workspaceRoot, checkEnvironment) {
-    if (checkEnvironment !== undefined && (!checkEnvironment || typeof checkEnvironment !== "object" || Array.isArray(checkEnvironment)
-        || Object.keys(checkEnvironment).length !== 1 || typeof checkEnvironment.CODEX_HOME !== "string"
-        || checkEnvironment.CODEX_HOME.length > 4096 || checkEnvironment.CODEX_HOME.includes("\0") || !path.isAbsolute(checkEnvironment.CODEX_HOME)))
-        throw new AppError("invalid_check_environment", "Owned check environment must name one absolute Codex home", 2, { effect: "no_effect" });
+    const selected = validateCheckEnvironment(checkEnvironment);
     const suffix = crypto.createHash("sha256").update(path.resolve(workspaceRoot)).digest("hex").slice(0, 12);
     // The managed CLI's Node must win over a provider app's PATH: a Rosetta
     // provider can otherwise run x64 checks against arm64-installed modules.
@@ -72,8 +70,7 @@ export function codeExecutionEnvironment(workspaceRoot, checkEnvironment) {
     delete environment.NODE_PATH;
     for (const key of ["DD_FLOW_CHECK_RUNNER_EVIDENCE_PATH", "DD_FLOW_CHECK_RUNNER_PROGRESS_PATH", "DD_FLOW_CHECK_INVOCATION_ID", "DD_FLOW_CHECK_ID", "DD_FLOW_CHECK_INPUT_HASH", "DD_FLOW_CHECK_VERIFICATION_EPOCH", "DD_FLOW_CHECK_COMMAND"])
         delete environment[key];
-    if (checkEnvironment)
-        environment.CODEX_HOME = checkEnvironment.CODEX_HOME;
+    Object.assign(environment, selected);
     return environment;
 }
 export function workspaceOperationId(workspaceRoot) { return `workspace:${crypto.createHash("sha256").update(path.resolve(workspaceRoot)).digest("hex")}`; }
@@ -302,6 +299,9 @@ export class PreparedCheckEvidence {
         Object.freeze(this);
     }
     static prepare(context, input) {
+        const checkEnvironment = ownedCheckEnvironment(context.env, input.checkEnvironment);
+        if (checkEnvironment)
+            input = { ...input, checkEnvironment };
         validateCheckEvidenceContext(input.evidenceContext);
         const fail = () => { throw new AppError("check_evidence_stale", "Current declared checks lack owned passed evidence", 2, { effect: "no_effect" }); };
         if (!input.checks.length || (input.scope === "work") !== Boolean(input.workId) || input.mode !== undefined && input.mode !== "diagnostic")
@@ -343,7 +343,13 @@ export class PreparedCheckEvidence {
         const references = deduplicate(checks, commands).map(group => {
             const inputHash = checkInputHash(input.workspaceRoot, group, profileHash, workspaceInputFingerprint(input.workspaceRoot, state.files, group.inputs, [input.runHome]), input.evidenceContext, input.checkEnvironment);
             const receipt = receipts.filter(item => item.input_hash === inputHash && item.profile_hash === profileHash && item.scope === input.scope && item.work_id === (input.workId ?? null)).at(-1);
-            if (!receipt || !checkReceiptEvidenceValidForMode(bindReceipt(receipt, group), input.mode))
+            if (!receipt)
+                throw new AppError("check_evidence_stale", "Current declared checks lack owned passed evidence", 2, {
+                    effect: "no_effect", reason: "input_identity_mismatch", expected_input_hash: inputHash,
+                    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))
                 fail();
             passed = passed && receipt.status === "passed";
             for (const artifact of receipt.artifacts)
@@ -482,6 +488,9 @@ function checkEvidenceSqlSnapshot(context, input) {
     }));
 }
 export async function runCodeChecks(context, input) {
+    const checkEnvironment = ownedCheckEnvironment(context.env, input.checkEnvironment);
+    if (checkEnvironment)
+        input = { ...input, checkEnvironment };
     validateCheckEvidenceContext(input.evidenceContext);
     const generation = assertRunMutationAllowed(context, input.projectId, input.runId);
     let gate;
@@ -652,8 +661,9 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         if (result.failure)
             physicalFailures.push(result.failure);
         const candidateFiles = candidateFailureFiles(runnerEvidence, input.workspaceRoot);
+        const candidateAbsences = candidateFailureAbsences(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);
+            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);
         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";
@@ -661,6 +671,7 @@ async function runCodeChecksOwned(context, input, workspaceGateId, generation, s
         receipt.required_artifacts = requiredArtifacts;
         receipt.candidate_root = input.workspaceRoot;
         receipt.candidate_files = candidateFiles;
+        receipt.candidate_absences = candidateAbsences;
         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);
@@ -748,6 +759,7 @@ export function reconcileUnfinishedChecks(context, input) {
         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);
+        let candidateAbsences = candidateFailureAbsences(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"))) {
@@ -757,13 +769,14 @@ export function reconcileUnfinishedChecks(context, input) {
                 if (proven.candidate_root) {
                     physicalFailures.push(...(proven.execution_failures ?? []));
                     candidateFiles = proven.candidate_files ?? candidateFiles;
+                    candidateAbsences = proven.candidate_absences ?? [];
                 }
                 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);
+            retainExecutionOutcome(evidenceDir, receipt, input.workspaceRoot, physicalFailures, candidateFiles, candidateAbsences);
             receipt.required_artifacts = [...new Set([...(receipt.required_artifacts ?? []), ...runnerProofArtifacts(runnerEvidence), "engine-outcome.json"])];
             artifacts = collectCheckArtifacts(evidenceDir, receipt.required_artifacts);
         }
@@ -776,6 +789,7 @@ export function reconcileUnfinishedChecks(context, input) {
             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.candidate_absences = candidateAbsences;
             repaired.execution_failures = physicalFailures;
             writeReceipt(pendingReceipt.receipt_path, repaired);
             if (status === "failed")
@@ -974,12 +988,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)) && 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)) && 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 } : {}), execution_failures: outcome.execution_failures ?? [], ...(outcome.candidate_root ? { candidate_root: outcome.candidate_root } : {}), ...(outcome.candidate_files ? { candidate_files: outcome.candidate_files } : {}) };
+    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 } : {}), 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 } : {}) };
 }
 function executionFailures(input) {
     const failures = [];
@@ -997,18 +1011,18 @@ 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) {
+function retainExecutionOutcome(evidenceDir, binding, candidateRoot, failures, candidateFiles, candidateAbsences = []) {
     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, 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, execution_failures: failures }), { flag: "wx", mode: 0o600 });
     fs.renameSync(temporary, path.join(evidenceDir, "engine-outcome.json"));
 }
 export function workspaceFingerprint(root) { return workspaceState(root).fingerprint; }
 /** One NUL-aware source of truth for paths differing from HEAD. Rename/copy
  * records carry a second path; retain both because the old side is a deletion. */
 export function workspaceChangedPaths(root) {
-    const status = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: root, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+    const status = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: root, env: { ...process.env, LC_ALL: "C" }, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
     // A workspace can be intentionally gitless. Keep the same conservative
     // file inventory used for fingerprints instead of making result validation
     // fail before the work contract can report its actual error.
@@ -1041,7 +1055,7 @@ export function ignoredWorkspacePaths(root, paths) {
     const normalized = [...new Set(paths.map((item) => normalizeWorkspacePath(root, item)))];
     if (!normalized.length)
         return [];
-    const status = spawnSync("git", ["check-ignore", "-z", "--stdin"], { cwd: root, encoding: "utf8", input: `${normalized.join("\0")}\0`, maxBuffer: 64 * 1024 * 1024 });
+    const status = spawnSync("git", ["check-ignore", "-z", "--stdin"], { cwd: root, env: { ...process.env, LC_ALL: "C" }, encoding: "utf8", input: `${normalized.join("\0")}\0`, maxBuffer: 64 * 1024 * 1024 });
     // The canonical owned hook has one meaning across Git status, check cache
     // and MERGE, without changing a sibling worktree's shared Git excludes.
     const gitless = isGitlessWorkspace(root, status);
@@ -1150,12 +1164,13 @@ function environmentFingerprint(workspaceRoot, inputs, checkEnvironment) {
     // and tool selection; omit only known process/control bookkeeping.
     const bookkeeping = new Set(["PWD", "OLDPWD", "SHLVL", "_", "DD_FLOW_DAEMON_ID",
         "DD_FLOW_CURRENT_INVOCATION", "DD_FLOW_INVOCATION_READONLY", "DD_FLOW_INVOCATION_SCOPE", "DD_FLOW_CODEX_STATE_DIR",
+        "DD_FLOW_HOOK_DEADLINE_AT", // Per-call transport budget, not a project check input.
         "DD_FLOW_RUNTIME_OWNER", "DD_FLOW_CONTROLLER_TOKEN", "DD_FLOW_CONTROL_TOKEN", "DD_FLOW_SCOPE_CONTROL_TOKEN",
         "DD_FLOW_BIN", "DD_FLOW_ENGINE_HOME", "DD_FLOW_RUNTIME_BUDGET", "DD_FLOW_WORK_ID", "DD_FLOW_SESSION_ID", "CODEX_THREAD_ID", "DD_EVAL_OPERATION_ID",
-        "CODEX_PERMISSION_PROFILE", "CODEX_SESSION_ID", "CODEX_VERSION"]);
+        "CODEX_PERMISSION_PROFILE", "CODEX_SESSION_ID", "CODEX_VERSION", "CODEX_TOOL_CALL_ID"]);
     return crypto.createHash("sha256").update(JSON.stringify(Object.entries(environment)
         .filter(([name, value]) => value !== undefined && !bookkeeping.has(name)
-        && (inputs === undefined || inputs.some(input => input.endsWith("*") ? name.startsWith(input.slice(0, -1)) : name === input)))
+        && (name === "PLAYWRIGHT_BROWSERS_PATH" || inputs === undefined || inputs.some(input => input.endsWith("*") ? name.startsWith(input.slice(0, -1)) : name === input)))
         .sort(([left], [right]) => left.localeCompare(right)))).digest("hex");
 }
 function acquireWorkspaceGate(context, input) {
@@ -1330,7 +1345,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 ?? []))
+        if (hasEngineOutcome && (!isDeepStrictEqual(retainedProof.execution_failures ?? [], receipt.execution_failures ?? []) || !isDeepStrictEqual(retainedProof.candidate_absences ?? [], receipt.candidate_absences ?? [])))
             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/compatibility-preflight.js

@@ -13,7 +13,7 @@ export async function preflightCliCompatibility(context, args, env = process.env
     if (resolvedProjectRoot === null && parsed.positional[0] === "runtime" && parsed.positional[1] === "process"
         && !parsed.options.has("project-root") && !parsed.options.has("root"))
         return { ok: true, classification, compatibility: null };
-    const { resolveOperationProjectRoot, selectEngine } = await import("./engines.js");
+    const { resolveOperationProjectRoot, selectEngine, selectBoundExecutingEngine } = await import("./engines.js");
     const projectRoot = resolvedProjectRoot ?? resolveOperationProjectRoot(context, args);
     if (!projectRoot) {
         return { ok: true, classification, compatibility: null };
@@ -21,7 +21,10 @@ export async function preflightCliCompatibility(context, args, env = process.env
     // Compatibility checks the executing build/manifest identity. Routing and
     // binding validate snapshot bytes before dispatch; maintenance must not
     // rehash the dependency closure or spawn health probes on every lease ACK.
-    const selection = selectEngine(context, { projectRoot, env }, { allowCurrentInProcess: true, verifyCurrentContent: false }, classification);
+    // Read-only probes may intentionally inspect a copied RUN before its new
+    // executor is bound. Writer authority is neither required nor granted here.
+    const selection = (classification.mode === "read_only_diagnostics" ? null : selectBoundExecutingEngine(context, args, projectRoot, env))
+        ?? selectEngine(context, { projectRoot, env }, { allowCurrentInProcess: true, verifyCurrentContent: false }, classification);
     const compatibility = compatibilityReport(selection, classification);
     if (classification.mode === "read_only_diagnostics" || classification.mode === "mb_upgrade") {
         return { ok: true, classification, compatibility };

package/dist/services/controller-execution.js

@@ -4,10 +4,11 @@ import { FrozenGenericExecution } from "./generic-execution.js";
 import { resolveExecutionPolicy, resolveStageTransition, stageExecutionCwd } from "./execution-policy.js";
 import { readFlowRunExecutionBundle } from "./runs.js";
 import { hybridDigest } from "./hybrid-contracts.js";
+import { isDiagnosticFlow } from "../domain/diagnostic-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.
  */
-export function genericControllerRouting(execution) {
+export function genericControllerRouting(execution, workspaceRoot) {
     if (!(execution instanceof FrozenGenericExecution) || execution.settings.execution !== "managed") {
         throw new AppError("controller_execution_invalid", "Managed controller requires managed frozen execution", 1, { effect: "no_effect" });
     }
@@ -33,14 +34,17 @@ export function genericControllerRouting(execution) {
                 execution.stage(fromStage);
             return { ...resolveExecutionPolicy({ ddFlowHome: "", policy, profiles, stage }), session_mode: selected.session_mode };
         },
-        cwd(stage, _mergeTargetWorkspace, _currentRun) { execution.stage(stage); return path.resolve(snapshot.scope.workspace); }
+        cwd(stage, _mergeTargetWorkspace, currentRun) {
+            execution.stage(stage);
+            return path.resolve(currentRun?.workspace_root ?? workspaceRoot ?? snapshot.scope.workspace);
+        }
     };
 }
 /** Restore execution from RUN authority, never from a generic manifest copy.
  * 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)) {
+    if (manifest?.schema_id === "dd-flow/run-controller-manifest@2" || ["mb-init", "mb-upgrade"].includes(run.flow_kind) || isDiagnosticFlow(run.flow_kind)) {
         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);
@@ -51,7 +55,9 @@ export function selectControllerExecution(context, run, manifest) {
             || manifest.request?.project_root !== run.project_root || manifest.request?.run_id !== run.id)) {
             throw new AppError("controller_execution_invalid", "Controller execution binding differs from retained RUN authority", 1);
         }
-        return { ...genericControllerRouting(bundle.execution), bundle, binding, legacy: undefined };
+        // Bundle admission has already checked the current RUN workspace against
+        // its trusted relocation receipts; frozen scope remains historical input.
+        return { ...genericControllerRouting(bundle.execution, run.workspace_root), bundle, binding, legacy: undefined };
     }
     const index = JSON.parse(run.index_json);
     const legacy = manifest ? manifest.execution_profile : index.execution_profile;

package/dist/services/controller-fanout.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { AppError, errorRecord } from "../shared/errors.js";
 import { normalizeNativeChildren, safeNativeFailure } from "../harness-runtime/lib/native-children.mjs";
 import { getVnextFanoutStatus, observeVnextNativeChildren, reconcileVnextFanout, getStageFanoutCapacity, verifiedNativeWorkFailure } from "./vnext-fanout.js";
@@ -10,7 +11,9 @@ import { registerMemoryRepairBaselineFromStage, reserveMemoryRepairWriterCopyFro
 import { requireProjectByRoot } from "./projects.js";
 import { stageAttempt, stageWorkIds } from "./stage-work-graph.js";
 import { runtimeCommand } from "./runtime-command.js";
-function semanticCompletionPrompt(stage, completed) {
+import { promptDeliveryInstruction } from "./prompt-delivery.js";
+import { currentStageFinishCommand } from "./lifecycle-invocations.js";
+function semanticCompletionPrompt(stage, completed, command) {
     const task = stage === "plan-review"
         ? "Classify the reviewer findings, apply every accepted correction in the current PLAN-REVIEW Work, and write the authoritative review decision."
         : stage === "code-review"
@@ -19,7 +22,7 @@ function semanticCompletionPrompt(stage, completed) {
     return [
         `All declared ${stage} child Work has settled (${completed} completed).`,
         task,
-        "Then invoke the exact Stage finish command from the original authoritative packet.",
+        `Then invoke this exact currently issued Stage finish command:\n\n${command}\n\nRefresh the authoritative verification evidence first; an earlier rejected or successful nonterminal command only reads its retained outcome.`,
         "If that command returns either outcome = repair_required with a repair Work ID, or error.details.continuation.kind = repair_required, the repair Work is already registered. End this Turn so the controller can dispatch it. Otherwise follow the command's actual result.",
         "Do not create speculative repair Work or start a successor Stage."
     ].join(" ");
@@ -29,17 +32,20 @@ export function controllerStageEntryPrompt(stage, command) {
     return [
         `Start the assigned ${stage} Stage now. Your first tool call must be this exact standalone command:`,
         command,
-        "Read the complete authoritative packet from the command's response_file result, including worker_prompt_markdown. If a read is truncated, continue until the entire packet has been read.",
+        promptDeliveryInstruction,
         "If the returned packet has orchestration.kind = work_fanout, this Turn is only Stage entry: acknowledge the packet and end your Turn immediately. The packet describes the whole Stage, but its graph/dispatch/finish instructions belong to later controller continuations. Do not list, start, launch or finish Work, create children, change files, run checks, or finish the Stage in this entry Turn. The controller will inspect the graph and send the next assignment with exact issued commands (or dispatch external workers itself).",
         "Otherwise perform this Stage's semantic work and stop at its boundary or a declared HITL boundary. Do not start a successor Stage.",
         stageLifecycleInstruction
     ].join("\n\n");
 }
-export function controllerStageResumePrompt(pauseId, command) {
+export function controllerStageResumePrompt(packet, resumedPromptPath) {
     return [
-        `The user supplied the raw answer for pause ${pauseId}. Your first tool call must be this exact standalone command:`,
-        command,
-        "Do not alter the answer. Follow the returned packet, then stop at this Stage boundary.",
+        `The accepted canonical answer for pause ${packet.pause_id} (${packet.stage}, ${packet.work_id}) is retained at this absolute read-only path: ${JSON.stringify(packet.answer_file)} (sha256 ${packet.answer_sha256}). Do not replace it with a placeholder or ask the user to supply it again. A null pause.answer_path before resume does not mean the answer is missing.`,
+        resumedPromptPath
+            ? `This exact answer was already committed. Do not invoke stage resume again. Read the recovered authoritative continuation at ${JSON.stringify(resumedPromptPath)} and perform its current Stage instructions.`
+            : `Only while this exact pause still awaits its answer, your first tool call must be this exact standalone command. It applies the already accepted bound answer file:\n\n${packet.command}`,
+        ...(packet.resume_source_path ? [`If this pause has already resumed, do not invoke stage resume again. Read the complete recovered result.worker_prompt_markdown in ${JSON.stringify(packet.resume_source_path)} instead, and follow that authoritative continuation. The controller restores this committed packet before dispatch. A different pause requires its own accepted answer.`] : []),
+        `Do not alter the answer. ${promptDeliveryInstruction} Follow the returned packet, then stop at this Stage boundary.`,
         stageLifecycleInstruction
     ].join("\n\n");
 }
@@ -173,8 +179,8 @@ export async function nextControllerFanout(context, input) {
         throw new AppError("fanout_graph_stalled", "Created Work has no ready or running dependency path", 1);
     if (input.stage === "review") {
         const projectId = requireProjectByRoot(context, input.projectRoot).id;
-        const run = context.db.get("SELECT flow_kind FROM runs WHERE project_id=? AND id=?", [projectId, input.runId]);
-        if (run?.flow_kind === "mb-init") {
+        const run = context.db.get("SELECT flow_kind,run_root,run_dir FROM runs WHERE project_id=? AND id=?", [projectId, input.runId]);
+        if (run?.flow_kind === "mb-init" || run?.flow_kind === "mb-upgrade") {
             const attempt = stageAttempt(context, projectId, input.runId, "review");
             const repair = context.db.get(`SELECT CASE event_type WHEN 'memory.second_repair_registration' THEN 2 ELSE 1 END AS wave
         FROM audit_events WHERE project_id=? AND event_type IN ('memory.repair_registration','memory.second_repair_registration')
@@ -186,9 +192,27 @@ export async function nextControllerFanout(context, input) {
                 const args = ["--run", input.runId, "--project-root", input.projectRoot, "--wave", String(repair.wave), "--json"];
                 return prompt("semantic_completion", `Correction wave ${repair.wave} Work has settled. Before Stage finish, run ${runtimeCommand(context, ["memory", "corrections", "checks", ...args])}, then ${runtimeCommand(context, ["memory", "review", "selective-register", ...args])}. Read both complete responses, then end this Turn so the controller can dispatch the independent selective reviewers. Do not finish the Stage or treat repair Work completion as independent acceptance.`);
             }
+            const wave = repair?.wave ?? 0;
+            const runHome = run.run_root ?? run.run_dir;
+            if (!runHome || !path.isAbsolute(runHome))
+                throw new AppError("runtime_missing", "Memory review collection requires its retained absolute RUN home", 1);
+            const collectionArgs = ["--run", input.runId, "--project-root", input.projectRoot, ...(wave ? ["--wave", String(wave)] : []),
+                "--json", "--progress-jsonl", "--response-file", path.join(runHome, `memory-review-collection-wave-${wave}.json`)];
+            const collect = runtimeCommand(context, ["memory", "review", wave ? "selective-collect" : "collect", ...collectionArgs]);
+            return prompt("semantic_completion", [
+                `All declared memory review Work has settled. First run ${collect}. Read the complete canonical collection from its response_file; do not decide acceptance from a truncated preview or reviewer counts.`,
+                "Only if the collection outcome is accepted (projection.outcome = accepted), integrate its accepted results into the original Stage proposal and invoke the exact Stage finish command from the authoritative packet.",
+                wave < 2
+                    ? `If the outcome is needs_repair, use the returned canonical findings and correction_plan_binding to author substantive repair tasks with exact owned write_paths. Register that plan with the packet's issued memory corrections register command for wave ${wave + 1}, then end this Turn so the controller can dispatch it. Do not invoke Stage finish before corrections, checks and independent selective review complete.`
+                    : "If the outcome is needs_repair or blocked, the two correction waves are exhausted. Use the issued pause command for the concrete unresolved blocker; do not mark it accepted.",
+                "For blocked collection, use the issued pause command. Do not calculate finding hashes, merge or drop findings, edit project files in the coordinator, create speculative Work or start a successor Stage."
+            ].join("\n\n"));
         }
     }
-    return prompt("semantic_completion", semanticCompletionPrompt(input.stage, fanout.works.completed));
+    const finish = currentStageFinishCommand(context, input.stage);
+    if (!finish)
+        throw new AppError("controller_finish_authority_missing", "Settled child Work has no current issued Stage finish; reconcile lifecycle authority", 1, { stage: input.stage });
+    return prompt("semantic_completion", semanticCompletionPrompt(input.stage, fanout.works.completed, finish));
 }
 /** Shared pinned runtime normalization; preserve structured errors at the TS boundary. */
 export function controllerNativeChildren(receipt, rootSessionId) {

package/dist/services/controller-memory-task.js

@@ -0,0 +1,45 @@
+import { Worker } from "node:worker_threads";
+import { AppError } from "../shared/errors.js";
+/** Keep synchronous custody/copy work off the controller's lease event loop.
+ * The thread remains inside its registered process; OS-level stop owns both.
+ * Do not resolve until exit, including after cancellation or a typed failure. */
+export function runControllerMemoryTask(context, task, signal) {
+    const aborted = () => new AppError("controller_memory_task_aborted", "Memory operation was cancelled; reconcile its retained effects", 1, { effect: "unknown" });
+    if (signal?.aborted)
+        return Promise.reject(aborted());
+    return new Promise((resolve, reject) => {
+        // Both source tests and installed runtimes use the package's compiled worker.
+        const worker = new Worker(new URL("../../dist/services/controller-memory-worker.js", import.meta.url), {
+            workerData: { task, env: { ...context.env, DD_FLOW_HOME: context.ddFlowHome } }
+        });
+        let reply, failure;
+        const abort = () => worker.postMessage({ abort: true });
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        worker.on("message", (value) => {
+            const invalid = value && typeof value === "object" && ("error" in value
+                ? !value.error || typeof value.error.code !== "string" || typeof value.error.message !== "string" || !Number.isInteger(value.error.exitCode)
+                    || !value.error.details || typeof value.error.details !== "object" || Array.isArray(value.error.details) || "result" in value
+                : !("result" in value) || !value.result || typeof value.result !== "object" || Array.isArray(value.result));
+            if (reply || !value || typeof value !== "object" || invalid) {
+                failure = new AppError("controller_memory_task_invalid", "Memory worker returned an invalid terminal reply", 1, { effect: "unknown" });
+            }
+            else
+                reply = value;
+        });
+        worker.once("error", error => { failure = error; });
+        worker.once("exit", code => {
+            signal?.removeEventListener("abort", abort);
+            if (failure)
+                return reject(failure);
+            if (reply && "error" in reply)
+                return reject(new AppError(reply.error.code, reply.error.message, reply.error.exitCode, reply.error.details));
+            if (signal?.aborted)
+                return reject(aborted());
+            if (code !== 0 || !reply || !("result" in reply))
+                return reject(new AppError("controller_memory_task_failed", "Memory worker exited without its terminal result", 1, { exit_code: code, effect: "unknown" }));
+            resolve(reply.result);
+        });
+    });
+}

package/dist/services/controller-memory-worker.js

@@ -0,0 +1,49 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { createContext } from "../runtime/context.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { nextControllerFanout } from "./controller-fanout.js";
+import { launchExternalWork } from "./external-work-launch.js";
+import { requireProjectByRoot } from "./projects.js";
+import { assertControllerLeaseAllowed } from "./run-controller-process.js";
+import { assertManagedProcessLease } from "./managed-processes.js";
+import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
+if (!parentPort)
+    throw new AppError("controller_memory_task_invalid", "Memory worker requires its controller thread", 1);
+const port = parentPort, cancellation = new AbortController();
+port.on("message", message => { if (message?.abort === true)
+    cancellation.abort(); });
+const { task, env } = workerData;
+let context;
+let reply;
+try {
+    context = createContext(env, "prepared_existing");
+    const project = requireProjectByRoot(context, task.input.projectRoot);
+    const run = context.db.get("SELECT flow_kind FROM runs WHERE project_id=? AND id=?", [project.id, task.input.runId]);
+    if (!run || !["mb-init", "mb-upgrade"].includes(run.flow_kind) && !isDiagnosticFlow(run.flow_kind))
+        throw new AppError("controller_memory_task_invalid", "Worker requires the selected memory or diagnostic RUN", 1, { effect: "no_effect" });
+    if (task.operation === "external") {
+        const work = context.db.get("SELECT project_id,run_id FROM works WHERE work_id=?", [task.input.workId]);
+        if (!work || work.project_id !== project.id || work.run_id !== task.input.runId)
+            throw new AppError("controller_memory_task_invalid", "External Work belongs to another RUN", 1, { effect: "no_effect" });
+    }
+    const owner = env.DD_FLOW_CONTROLLER_TOKEN ? context.db.get("SELECT * FROM run_controllers WHERE project_id=? AND run_id=? AND owner_token=?", [project.id, task.input.runId, env.DD_FLOW_CONTROLLER_TOKEN]) : undefined;
+    if (!owner)
+        throw new AppError("controller_owner_mismatch", "Memory task lacks its managed controller owner", 1, { effect: "no_effect" });
+    assertControllerLeaseAllowed(context, owner);
+    assertManagedProcessLease(context, { id: owner.process_id, leaseToken: owner.process_lease_token, pid: process.pid });
+    cancellation.signal.throwIfAborted();
+    if (task.operation === "fanout")
+        reply = { result: await nextControllerFanout(context, task.input) };
+    else if (task.operation === "external")
+        reply = { result: await launchExternalWork(context, { ...task.input, signal: cancellation.signal }) };
+    else
+        throw new AppError("controller_memory_task_invalid", "Unknown memory worker operation", 1, { effect: "no_effect" });
+}
+catch (error) {
+    reply = { error: errorRecord(error) };
+}
+finally {
+    context?.db.close?.();
+}
+port.postMessage(reply);
+port.close();

package/dist/services/dashboard.js

@@ -216,10 +216,10 @@ export function autoRefreshDashboards(context, input) {
     if (projectRecoveryGuarded(context, project.id))
         return { ok: true, skipped: true, reason: "run_recovery_guarded" };
     const configured = readProjectConfig(context, project.id);
-    // Automatic observation must not change the source baseline owned by init.
+    // Automatic observation must not change a memory or diagnostic source baseline.
     // Keep projections in Home; do not hide runtime-created paths in Git or
     // weaken source preservation by excluding user-owned .tasks directories.
-    const initializing = context.db.get("SELECT 1 FROM runs WHERE project_id=? AND flow_kind='mb-init' AND (id=? OR status IN ('created','running','paused','waiting_for_user','blocked')) LIMIT 1", [project.id, input.runId ?? null]);
+    const initializing = context.db.get("SELECT 1 FROM runs WHERE project_id=? AND flow_kind IN ('mb-init','mb-upgrade','mb-audit','project-review') AND (id=? OR status IN ('created','running','paused','waiting_for_user','blocked')) LIMIT 1", [project.id, input.runId ?? null]);
     const config = initializing ? { ...configured, dashboard: { ...configured.dashboard,
             markdown_path: path.join(projectDashboardDir(context.ddFlowHome, project.id), "project-dashboard.md") } } : configured;
     if (!config.dashboard.auto_refresh) {

package/dist/services/descriptor-run-settlement.js

@@ -62,17 +62,19 @@ export class PreparedDescriptorRunSettlement {
         const scope = { projectId: project.id, runId: input.runId, stage: input.stage };
         const matchKeys = entityReferenceVariants(input.runId).map(reference => stageLifecycleMatchKey("stage_finish", reference, input.stage, input.projectRoot));
         const snapshot = context.db.readSnapshot(() => ({ owner: selected(context, scope, bundle, matchKeys), generation: assertRunMutationAllowed(context, scope.projectId, scope.runId) }));
-        const git = snapshot.owner.prior?.git ?? gitFacts(bundle.execution.snapshot().scope.workspace);
+        const operational = assertPreparedRunBundleSqlAuthority(context, scope, bundle);
+        const git = snapshot.owner.prior?.git ?? gitFacts(operational.workspace_root ?? operational.project_root);
         return new PreparedDescriptorRunSettlement(scope, bundle, snapshot.owner, git, snapshot.generation, matchKeys);
     }
     apply(context, assertHandlerCustody) {
         if (typeof assertHandlerCustody !== "function")
             refuse("handler_fence_required");
-        const bundle = readFlowRunExecutionBundle(context, { projectRoot: this.#bundle.execution.snapshot().scope.projectRoot, runId: this.#scope.runId });
+        const operational = assertPreparedRunBundleSqlAuthority(context, this.#scope, this.#bundle);
+        const bundle = readFlowRunExecutionBundle(context, { projectRoot: operational.project_root, runId: this.#scope.runId });
         if (!bundle || bundle.sha256 !== this.#bundle.sha256)
             refuse("bundle_changed");
         const observed = context.db.readSnapshot(() => selected(context, this.#scope, this.#bundle, this.#matchKeys));
-        if (!observed.prior && hybridDigest(gitFacts(this.#bundle.execution.snapshot().scope.workspace)) !== hybridDigest(this.#git))
+        if (!observed.prior && hybridDigest(gitFacts(operational.workspace_root ?? operational.project_root)) !== hybridDigest(this.#git))
             refuse("git_observation_changed");
         const receipt = { run_id: this.#scope.runId, work_id: this.#owner.rootId, binding: this.#owner.binding, git: this.#git };
         const changed = withStageSettlement(context, () => {