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

package/dist/schemas/memory-repair-work-result.schema.json

@@ -9,7 +9,7 @@
     "work_id": { "type": "string", "minLength": 1, "maxLength": 256 },
     "packet_sha256": { "$ref": "#/$defs/hash" },
     "wave": { "type": "integer", "minimum": 1, "maximum": 2 },
-    "outcome": { "enum": ["accepted", "blocked"] },
+    "outcome": { "enum": ["accepted", "reconciled", "blocked"] },
     "summary": { "type": "string", "minLength": 1, "maxLength": 16384 },
     "changes": {
       "type": "array", "maxItems": 512,
@@ -29,12 +29,19 @@
         "properties": {
           "finding_id": { "type": "string", "minLength": 1, "maxLength": 128 },
           "summary": { "type": "string", "minLength": 1, "maxLength": 16384 },
-          "delta_paths": { "type": "array", "minItems": 1, "maxItems": 512, "uniqueItems": true, "items": { "type": "string", "minLength": 1, "maxLength": 4096 } },
+          "delta_paths": { "type": "array", "maxItems": 512, "uniqueItems": true, "items": { "type": "string", "minLength": 1, "maxLength": 4096 } },
           "evidence": { "type": "array", "minItems": 1, "maxItems": 256, "items": { "$ref": "#/$defs/reference" } }
         }
       }
     }
   },
+  "allOf": [
+    { "if": { "properties": { "outcome": { "const": "accepted" } } },
+      "then": { "properties": { "changes": { "type": "array", "minItems": 1 }, "resolutions": { "type": "array", "minItems": 1, "items": { "type": "object", "properties": { "delta_paths": { "type": "array", "minItems": 1 } } } } } } },
+    { "if": { "properties": { "outcome": { "const": "reconciled" } } },
+      "then": { "properties": { "changes": { "type": "array", "maxItems": 0 }, "resolutions": { "type": "array", "minItems": 1,
+        "items": { "type": "object", "properties": { "delta_paths": { "type": "array", "maxItems": 0 } } } } } } }
+  ],
   "$defs": {
     "hash": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
     "reference": {

package/dist/schemas/release-impact.schema.json

@@ -7,10 +7,10 @@
   "required": ["schema_id", "from_version", "to_version", "minimum_upgrade_mode", "domains", "path_migration", "runtime_migration", "required_checks"],
   "properties": {
     "schema_id": {"const": "dd-flow/release-impact@1"},
-    "from_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
-    "to_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"},
+    "from_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:-[A-Za-z0-9.-]+)?$"},
+    "to_version": {"type": "string", "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+(?:-[A-Za-z0-9.-]+)?$"},
     "minimum_upgrade_mode": {"enum": ["patch", "targeted_minor", "full_migration"]},
-    "domains": {"type": "array", "items": {"enum": ["canonical_layer", "root_structure", "product", "system", "engineering", "operations", "adr", "plans", "scenarios", "ui", "guides", "protocol_evidence", "skills", "archive", "code_traceability"]}, "uniqueItems": true},
+    "domains": {"type": "array", "items": {"enum": ["canonical_layer", "flow_contracts", "root_structure", "product", "system", "engineering", "operations", "adr", "plans", "scenarios", "ui", "guides", "protocol_evidence", "skills", "archive", "code_traceability"]}, "uniqueItems": true},
     "path_migration": {"type": "boolean"},
     "runtime_migration": {"type": "boolean"},
     "required_checks": {"type": "array", "items": {"type": "string"}, "minItems": 1},

package/dist/schemas/stage-start-response.schema.json

@@ -19,6 +19,10 @@
     "stage_root": {"type": "string", "minLength": 1},
     "archive_path": {"type": ["string", "null"]},
     "prompt_path": {"type": "string", "minLength": 1},
+    "prompt_delivery": {
+      "type": "object", "additionalProperties": false, "required": ["path", "sha256"],
+      "properties": {"path": {"type": "string", "minLength": 1}, "sha256": {"type": "string", "pattern": "^[a-f0-9]{64}$"}}
+    },
     "aliases": {"type": "object", "additionalProperties": {"type": "string"}},
     "resolved_context": {"type": "object", "additionalProperties": true},
     "plan_ref": {"type": "string", "pattern": "^\\.memory-bank/protocol/[^/]+/plan\\.json$"},

package/dist/services/accepted-intent.js

@@ -15,12 +15,24 @@ export function acceptedIntentReviewFingerprint(sources) {
  * clarification may use the existing coordinator correction, explicitly named
  * as such; it never retroactively expands the independent review's coverage. */
 export function validateAcceptedIntentReview(context, scope, reviewedSources, contextFingerprint, acknowledgement) {
+    // Keep file validation outside callers' SQL writer; the prepared validator
+    // below consumes only accepted bytes/ordered SQL events.
     const reviewed = acceptedIntentReviewFingerprint(reviewedSources);
     if (!reviewed)
-        return null; // Historical source contract has no new authority.
+        return null;
     if (contextFingerprint !== reviewed)
         throw new AppError("accepted_intent_review_stale", "Review context does not bind the retained accepted inputs", 1, { stage: scope.stage });
     const currentSources = prepareAcceptedIntentSources(context, { ...scope, stageDirectory: "intake", marked: true }).sources;
+    return validatePreparedAcceptedIntentReview(context, scope, reviewedSources, contextFingerprint, currentSources, acknowledgement);
+}
+export function validatePreparedAcceptedIntentReview(context, scope, reviewedSources, contextFingerprint, currentSources, acknowledgement) {
+    const reviewed = acceptedIntentReviewFingerprint(reviewedSources);
+    if (!reviewed)
+        return null; // Historical source contract has no new authority.
+    if (contextFingerprint !== reviewed)
+        throw new AppError("accepted_intent_review_stale", "Review context does not bind the retained accepted inputs", 1, { stage: scope.stage });
+    if (currentSources.length > 256)
+        throw new AppError("accepted_intent_source_invalid", "Accepted intent source count exceeds its bound", 1);
     const current = acceptedIntentReviewFingerprint(currentSources);
     const reviewedEvent = Math.max(0, ...(reviewedSources ?? []).filter(source => source.role.startsWith("accepted_hitl:")).map(source => Number(source.role.split(":")[1])));
     const rows = context.db.all("SELECT id, payload_json FROM audit_events WHERE project_id = ? AND event_type = 'flow_run.stage_resumed' AND json_extract(payload_json, '$.run_id') = ? AND id > ? ORDER BY id LIMIT 256", [scope.projectId, scope.runId, reviewedEvent]);

package/dist/services/canon.js

@@ -3,6 +3,8 @@ import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { AppError } from "../shared/errors.js";
 import { prepareError } from "../cli/input-preparation.js";
+import { resolveDdFlowHome } from "../storage/paths.js";
+import { readSetupStatus } from "./setup.js";
 const canonRootKey = "canon.root";
 export function prepareCanonRegistration(context, input) {
     if (typeof input.root !== "string" || !input.root.trim())
@@ -41,16 +43,21 @@ export function getCanonStatus(context, input = {}) {
 export function resolveCanonRoot(context, input = {}) {
     return resolveCanonCandidates(canonCandidates(context, input));
 }
-/** Read only: resolve an explicit/environment/nearby canon without opening DD_FLOW_HOME. */
+/** Read only: resolve canonical data without opening SQLite or running migrations. */
 export function resolveCanonRootBeforeContext(env, input = {}) {
     const candidates = [];
     if (input.explicitRoot)
         candidates.push(validateCanonCandidate("explicit", input.explicitRoot));
     else if (env.DD_MEMORYBANK)
         candidates.push(validateCanonCandidate("env", env.DD_MEMORYBANK));
-    else
-        for (const known of knownCanonRoots())
-            candidates.push(validateCanonCandidate("known", known));
+    else {
+        const installed = installedCanonCandidate(resolveDdFlowHome(env));
+        if (installed)
+            candidates.push(installed);
+        else
+            for (const known of knownCanonRoots())
+                candidates.push(validateCanonCandidate("known", known));
+    }
     return resolveCanonCandidates(uniqueBy(candidates, (candidate) => `${candidate.source}:${candidate.root}`));
 }
 function resolveCanonCandidates(candidates) {
@@ -67,7 +74,7 @@ function resolveCanonCandidates(candidates) {
         const memorybankRoot = candidate.memorybank_root ?? root;
         const mbbRoot = candidate.mbb_root ?? path.join(memorybankRoot, "mbb");
         const layout = candidate.layout ?? "legacy_root";
-        const metadata = readCanonMetadata(root, flowRoot);
+        const metadata = candidate.metadata ?? readCanonMetadata(root, flowRoot);
         return {
             ok: true,
             canon: {
@@ -114,6 +121,30 @@ function resolveCanonCandidates(candidates) {
         ]
     };
 }
+/** Archive provenance belongs to the selected release, not an ancestor Git
+ * checkout. A damaged installation is not permission to select nearby code. */
+function installedCanonCandidate(home) {
+    if (!fs.existsSync(path.join(home, "installation.json")))
+        return null;
+    const status = readSetupStatus(home), installation = status.installation;
+    const invalid = (root, reason) => ({
+        source: "installed", root, realpath: null, valid: false, blockers: [reason]
+    });
+    if (!installation || status.installation_readiness !== "installed")
+        return invalid(home, "Installed canonical release is degraded; reconcile setup before selecting its canon.");
+    const roots = fs.readdirSync(installation.canon_root);
+    if (roots.length !== 1)
+        return invalid(installation.canon_root, "Installed canonical archive has no unique root.");
+    const candidate = validateCanonCandidate("installed", path.join(installation.canon_root, roots[0]));
+    if (!candidate.valid)
+        return candidate;
+    const version = readTrimmed(path.join(candidate.root, "VERSION"));
+    const flowContract = readFlowContractId(candidate.flow_root);
+    if (version !== installation.manifest.canon.version || !flowContract)
+        return invalid(candidate.root, "Installed canonical metadata differs from its release selection.");
+    return { ...candidate, metadata: { version, commit: installation.manifest.canon.commit,
+            flow_contract: flowContract, status: "present", diagnostics: [] } };
+}
 function canonCandidates(context, input) {
     const candidates = [];
     if (input.explicitRoot) {
@@ -129,8 +160,13 @@ function canonCandidates(context, input) {
             candidates.push(validateCanonCandidate("registered", registered.root));
         }
     }
-    for (const known of knownCanonRoots()) {
-        candidates.push(validateCanonCandidate("known", known));
+    if (!candidates.length) {
+        const installed = installedCanonCandidate(context.ddFlowHome);
+        if (installed)
+            return [installed];
+        for (const known of knownCanonRoots()) {
+            candidates.push(validateCanonCandidate("known", known));
+        }
     }
     return uniqueBy(candidates, (candidate) => `${candidate.source}:${candidate.root}`);
 }

package/dist/services/cli-operation-classifier.js

@@ -32,7 +32,7 @@ export function isMbUpgradeCliOperation(args, env = process.env) {
 export function requiresExplicitUpgradeAuthorization(args) {
     const positional = positionalArgs(args);
     const [family, command] = positional;
-    if (family === "migration" && command === "apply")
+    if (family === "migration" && ["apply", "readiness"].includes(command ?? ""))
         return true;
     if (family === "run" && command === "start" && optionValue(args, "flow-kind") === "mb-upgrade")
         return true;

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

@@ -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)
@@ -1008,7 +1014,7 @@ export function workspaceFingerprint(root) { return workspaceState(root).fingerp
 /** 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 +1047,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,9 +1156,10 @@ 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)))

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-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,6 +11,7 @@ import { registerMemoryRepairBaselineFromStage, reserveMemoryRepairWriterCopyFro
 import { requireProjectByRoot } from "./projects.js";
 import { stageAttempt, stageWorkIds } from "./stage-work-graph.js";
 import { runtimeCommand } from "./runtime-command.js";
+import { promptDeliveryInstruction } from "./prompt-delivery.js";
 function semanticCompletionPrompt(stage, completed) {
     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."
@@ -29,7 +31,7 @@ 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
@@ -39,7 +41,7 @@ export function controllerStageResumePrompt(pauseId, command) {
     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.",
+        `Do not alter the answer. ${promptDeliveryInstruction} Follow the returned packet, then stop at this Stage boundary.`,
         stageLifecycleInstruction
     ].join("\n\n");
 }
@@ -173,8 +175,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,6 +188,21 @@ 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));

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,48 @@
+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";
+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))
+        throw new AppError("controller_memory_task_invalid", "Memory worker requires the selected memory 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 either memory flow's 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') 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-start.js

@@ -15,9 +15,11 @@ import { resolveExecutionPolicy } from "./execution-policy.js";
 import { prepareFlowRunStart, publishRunProjections, readFlowRunExecutionBundle, assertPreparedRunBundleSqlAuthority, runBundleAuthorityMetadata } from "./runs.js";
 import { readRunStartRequest, refuseRunStart, runStartBytesSha256, runStartPayloadLimit } from "./run-start-custody.js";
 import { readMemoryInitBootstrapReadiness } from "./memory-init-bootstrap-readiness.js";
+import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-readiness.js";
 import { allocateDescriptorRootWork, readDescriptorRootWork } from "./descriptor-root-work.js";
 import { nextRunId } from "./ids.js";
 import { readMemoryInitRunAllocation } from "./memory-init-run-allocation.js";
+import { readMemoryUpgradeEvidence, readMemoryUpgradeTargetEvidence, upgradeEvidenceFilePath, upgradeEvidenceIndexPath, upgradeTargetIndexPath } from "./memory-upgrade-evidence.js";
 const encode = (value) => Buffer.from(JSON.stringify(value));
 const owner = (directory) => {
     const stat = fs.lstatSync(directory);
@@ -25,10 +27,10 @@ const owner = (directory) => {
         refuseRunStart("linked_or_missing_directory");
     return { dev: stat.dev, ino: stat.ino };
 };
-function git(context, projectRoot, workspaceRoot) {
+export function observeDescriptorWorkspace(context, projectRoot, workspaceRoot, gitExecutable = "git") {
     const env = Object.fromEntries(Object.entries({ ...process.env, ...context.env }).filter(([key]) => !key.startsWith("GIT_")));
     const read = (root, args, optional = false) => {
-        const result = spawnSync("git", ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false", "-C", root, ...args], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 1024 * 1024, shell: false, windowsHide: true });
+        const result = spawnSync(gitExecutable, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false", "-C", root, ...args], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 1024 * 1024, shell: false, windowsHide: true });
         if (result.error || result.signal || !optional && result.status !== 0)
             refuseRunStart("git_observation_failed");
         return result.status === 0 ? result.stdout : null;
@@ -100,19 +102,15 @@ function memoryBootstrap(context, projectId, bundle) {
             refuseRunStart("memory_bootstrap_authority_changed");
         return;
     }
-    const receipts = context.db.all("SELECT payload_json FROM audit_events WHERE project_id = ? AND event_type = 'memory.bootstrap_ready' AND json_extract(payload_json, '$.request_id') = ? LIMIT 2", [projectId, scope.requestId]);
-    if (receipts.length !== 1 || bundle.manifest.bootstrap_receipts.length !== 1)
-        refuseRunStart("memory_bootstrap_authority_missing");
-    let retained;
-    try {
-        retained = JSON.parse(receipts[0].payload_json);
-    }
-    catch {
-        return refuseRunStart("memory_bootstrap_authority_invalid");
-    }
-    if (!retained || retained.schema_id !== "dd-flow/memory-bootstrap-authority@1" || retained.project_root !== scope.projectRoot
-        || retained.workspace_root !== scope.workspace || retained.flow_id !== bundle.manifest.flow_id || retained.readiness !== "ready"
-        || retained.bootstrap_sha256 !== bundle.manifest.bootstrap_receipts[0].sha256)
+    if (bundle.descriptor.descriptor.id !== "mb-upgrade")
+        refuseRunStart("unsupported_memory_bootstrap");
+    const retained = readMemoryUpgradeBootstrapReadiness(context, { requestId: scope.requestId, projectRoot: scope.projectRoot, workspaceRoot: scope.workspace });
+    const reference = bundle.manifest.bootstrap_receipts[0];
+    if (!retained || !retained.hasPreservationBaseline || !retained.hasLintCapability || !retained.hasGitPolicy || !retained.hasFlowCapability || retained.projectId !== projectId || bundle.manifest.bootstrap_receipts.length !== 1 || !reference
+        || retained.authority.binding.execution_sha256 !== bundle.execution.sha256
+        || !bundle.blob(bundle.manifest.engine_manifest.path).equals(Buffer.from(retained.authority.binding.engine_manifest_base64, "base64"))
+        || retained.authority.bootstrap_sha256 !== reference.sha256
+        || !bundle.blob(reference.path).equals(encode(retained.authority.receipt)))
         refuseRunStart("memory_bootstrap_authority_changed");
 }
 /** RUN allocation and SQL bundle authority are one request-owned transaction.
@@ -166,12 +164,16 @@ export class PreparedDescriptorRunStart {
         const home = fs.realpathSync(context.ddFlowHome), runRoot = projectRunHome(home, selected.id, bundle.manifest.run_id);
         if (fs.existsSync(runRoot))
             refuseRunStart("foreign_run_root");
-        const facts = git(context, scope.projectRoot, scope.workspace), now = context.now(), artifacts = [
+        const facts = observeDescriptorWorkspace(context, scope.projectRoot, scope.workspace), now = context.now(), artifacts = [
             { path: "engine-binding.json", base64: bundle.blob(bundle.manifest.engine_binding.path).toString("base64") }
         ];
         const isSdlc = bundle.descriptor.descriptor.id === "sdlc", flowKind = isSdlc ? "vnext_specify" : bundle.descriptor.descriptor.id;
         if (!["vnext_specify", "mb-init", "mb-upgrade"].includes(flowKind))
             refuseRunStart("unsupported_flow_kind");
+        if (flowKind === "mb-upgrade") {
+            const upgradeScope = { requestId: scope.requestId, projectRoot: scope.projectRoot, workspaceRoot: scope.workspace };
+            artifacts.push(...readMemoryUpgradeEvidence(context, upgradeScope).artifacts, ...readMemoryUpgradeTargetEvidence(context, upgradeScope).artifacts);
+        }
         const legacy = isSdlc ? prepareFlowRunStart(context, { projectRoot: scope.projectRoot, workspaceRoot: scope.workspace,
             flowKind, subjectId, subjectType, slug: parsedId.slug }) : undefined;
         const profile = legacy?.executionProfile;
@@ -248,7 +250,7 @@ export class PreparedDescriptorRunStart {
     revalidatePhysical(context) {
         this.revalidateDirectoryOwners(context);
         const p = this.#payload;
-        if (hybridDigest(git(context, p.project_root, p.workspace_root)) !== hybridDigest(p.git))
+        if (hybridDigest(observeDescriptorWorkspace(context, p.project_root, p.workspace_root)) !== hybridDigest(p.git))
             refuseRunStart("physical_scope_changed");
         this.#bundle.engine();
     }
@@ -381,7 +383,9 @@ export class PreparedDescriptorRunStart {
         }
         checkpoint?.("root_owned");
         const assertPhysicalOwner = () => {
-            this.revalidatePhysical(context);
+            // Every write needs path custody, not another whole-workspace Git probe.
+            // Git/engine are fenced around the batch and before SQL acceptance.
+            this.revalidateDirectoryOwners(context);
             let ancestor = p.home_root;
             for (const part of path.relative(p.home_root, p.run_root).split(path.sep)) {
                 ancestor = path.join(ancestor, part);
@@ -397,19 +401,22 @@ export class PreparedDescriptorRunStart {
             assertPhysicalOwner();
             const file = path.join(p.run_root, artifact.path), bytes = Buffer.from(artifact.base64, "base64");
             if (fs.existsSync(file)) {
-                if (fs.lstatSync(file).nlink !== 1 || !readBoundedReleaseFile(file, 1024 * 1024).equals(bytes))
+                const limit = [upgradeEvidenceIndexPath, upgradeTargetIndexPath, upgradeEvidenceFilePath(runStartBytesSha256(bytes))].includes(artifact.path) ? 16 * 1024 * 1024 : 1024 * 1024;
+                if (fs.lstatSync(file).nlink !== 1 || !readBoundedReleaseFile(file, limit).equals(bytes))
                     refuseRunStart("start_artifact_changed");
             }
             else
                 fs.writeFileSync(file, bytes, { flag: "wx", mode: 0o600 });
         }
         assertPhysicalOwner();
+        this.revalidatePhysical(context);
         this.#bundle.materialize(p.run_root);
         checkpoint?.("bundle_published");
         const physical = readFlowRunExecutionBundle(context, { projectRoot: p.project_root, runId: p.run_id });
         if (physical?.sha256 !== p.bundle_sha256)
             refuseRunStart("bundle_changed");
         assertPhysicalOwner();
+        this.revalidatePhysical(context);
         context.db.writeTransaction(() => {
             this.#storage.assertCompatibility(context);
             const retained = readRunStartRequest(context, p.project_id, p.request_id);