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

package/dist/services/memory-init-git-policy.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import fs from "node:fs";
 import { spawnSync } from "node:child_process";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
@@ -15,6 +16,51 @@ function validScope(scope) {
         || Object.keys(scope).sort().join() !== "projectRoot,requestId,workspaceRoot")
         refuse("invalid_request_scope");
 }
+/** Shared read-only policy observation for init and upgrade. The caller owns
+ * retained input custody; these facts grant neither dispatch nor push. */
+export function observeMemoryGitPolicySelection(environment, input) {
+    validScope(input.scope);
+    const { scope, selection } = input;
+    if (!selection || Object.keys(selection).sort().join() !== "integrationBranch,route"
+        || !["integration_branch_direct", "feature_worktree"].includes(selection.route)
+        || typeof selection.integrationBranch !== "string" || !selection.integrationBranch || selection.integrationBranch.startsWith("-") || selection.integrationBranch.length > 1024
+        || [...selection.integrationBranch].some(character => character.charCodeAt(0) <= 32 || character.charCodeAt(0) === 127))
+        refuse("explicit_policy_required");
+    if (typeof input.gitExecutable !== "string" || !path.isAbsolute(input.gitExecutable))
+        refuse("explicit_git_required");
+    const env = Object.fromEntries(Object.entries(environment).filter(([key]) => !key.startsWith("GIT_")));
+    const git = (directory, args, optional = false) => {
+        const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-C", directory, ...args], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 64 * 1024, shell: false, windowsHide: true });
+        if (result.error || result.signal || !optional && result.status !== 0)
+            refuse("git_policy_observation_failed");
+        return result.status === 0 ? result.stdout.trim() : null;
+    };
+    const valid = spawnSync(input.gitExecutable, ["check-ref-format", `refs/heads/${selection.integrationBranch}`], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, timeout: 5000, maxBuffer: 64 * 1024, shell: false, windowsHide: true });
+    if (valid.error || valid.signal || valid.status !== 0)
+        refuse("invalid_integration_branch");
+    const common = (directory) => {
+        if (git(directory, ["rev-parse", "--is-bare-repository"]) !== "false"
+            || fs.realpathSync(git(directory, ["rev-parse", "--show-toplevel"])) !== directory)
+            refuse("not_repository_root");
+        return fs.realpathSync(path.resolve(directory, git(directory, ["rev-parse", "--git-common-dir"])));
+    };
+    const repository = common(scope.projectRoot);
+    if (common(scope.workspaceRoot) !== repository)
+        refuse("foreign_workspace_repository");
+    const branch = git(scope.workspaceRoot, ["symbolic-ref", "--short", "HEAD"]);
+    if (!branch)
+        refuse("workspace_branch_unavailable");
+    if (selection.route === "integration_branch_direct"
+        ? scope.projectRoot !== scope.workspaceRoot || branch !== selection.integrationBranch
+        : scope.projectRoot === scope.workspaceRoot || branch === selection.integrationBranch)
+        refuse("route_workspace_mismatch");
+    if (selection.route === "feature_worktree"
+        && !/^[a-f0-9]{40,64}$/.test(git(scope.projectRoot, ["rev-parse", "--verify", `refs/heads/${selection.integrationBranch}^{commit}`], true) ?? ""))
+        refuse("integration_branch_unavailable");
+    const head = git(scope.workspaceRoot, ["rev-parse", "--verify", "HEAD"], true);
+    return { repository, workspace_branch: branch, initial_head: head, source: "explicit_request",
+        route: selection.route, integration_branch: selection.integrationBranch, push_authorized: false };
+}
 /** SQL preservation, not fresh policy inference, Git execution or permission. */
 export function readMemoryInitGitPolicy(context, scope) {
     validScope(scope);
@@ -75,32 +121,15 @@ export class PreparedMemoryInitGitPolicy {
     static prepareFresh(environment, input) {
         if (!(input.target instanceof PreparedMemoryInitTarget))
             refuse("prepared_target_required");
-        const selection = input.selection;
-        if (!selection || Object.keys(selection).sort().join() !== "integrationBranch,route"
-            || !["integration_branch_direct", "feature_worktree"].includes(selection.route)
-            || typeof selection.integrationBranch !== "string" || !selection.integrationBranch || selection.integrationBranch.startsWith("-") || selection.integrationBranch.length > 1024
-            || [...selection.integrationBranch].some(character => character.charCodeAt(0) <= 32 || character.charCodeAt(0) === 127))
-            refuse("explicit_policy_required");
         input.target.revalidate();
         const facts = input.target.facts(), scope = { requestId: facts.request_id, projectRoot: facts.project_root, workspaceRoot: facts.workspace_root };
         if (!facts.tool_probes)
             refuse("fresh_target_required");
-        const env = Object.fromEntries(Object.entries(environment).filter(([key]) => !key.startsWith("GIT_")));
-        const result = spawnSync(facts.tools.git, ["check-ref-format", `refs/heads/${selection.integrationBranch}`], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 64 * 1024, shell: false, windowsHide: true });
-        if (result.error || result.signal || result.status !== 0)
-            refuse("invalid_integration_branch");
-        if (selection.route === "integration_branch_direct"
-            ? scope.projectRoot !== scope.workspaceRoot || facts.branch !== selection.integrationBranch
-            : scope.projectRoot === scope.workspaceRoot || facts.branch === selection.integrationBranch)
-            refuse("route_workspace_mismatch");
-        if (selection.route === "feature_worktree") {
-            const branch = spawnSync(facts.tools.git, ["-C", scope.projectRoot, "rev-parse", "--verify", `refs/heads/${selection.integrationBranch}^{commit}`], { env: { ...env, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8", timeout: 5000, maxBuffer: 64 * 1024, shell: false, windowsHide: true });
-            if (branch.error || branch.signal || branch.status !== 0 || !/^[a-f0-9]{40,64}$/.test(branch.stdout.trim()))
-                refuse("integration_branch_unavailable");
-        }
+        const policy = observeMemoryGitPolicySelection(environment, { scope, gitExecutable: facts.tools.git, selection: input.selection });
+        if (policy.repository !== facts.repository || policy.workspace_branch !== facts.branch || policy.initial_head !== facts.head)
+            refuse("target_changed_after_preparation");
         const receipt = { schema_id: "dd-flow/memory-init-git-policy@1", scope, target_sha256: input.target.sha256,
-            repository: facts.repository, workspace_branch: facts.branch, initial_head: facts.head, source: "explicit_request",
-            route: selection.route, integration_branch: selection.integrationBranch, push_authorized: false };
+            ...policy };
         return new PreparedMemoryInitGitPolicy(token, input.target, receipt);
     }
     value() { return structuredClone(this.#receipt); }

package/dist/services/memory-init-lint-capability.js

@@ -54,6 +54,12 @@ export class PreparedMemoryInitLintCapability {
         const selected = target.facts(), executable = selected.tools["mb-lint"], probe = selected.tool_probes?.["mb-lint"];
         if (!probe)
             refuse("missing_selected_tool_probe");
+        return PreparedMemoryInitLintCapability.prepareExecutable(executable, probe, env);
+    }
+    static prepareExecutable(executable, probe, env, options = {}) {
+        if (!path.isAbsolute(executable) || !probe || !/^[a-f0-9]{64}$/.test(probe.executable_sha256)
+            || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(probe.version))
+            refuse("invalid_selected_tool");
         const checksum = () => {
             try {
                 return hash(readBoundedReleaseFile(executable, 64 * 1024 * 1024));
@@ -97,11 +103,11 @@ export class PreparedMemoryInitLintCapability {
                 }
             };
             const probeEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
-            const run = (status, rule) => {
+            const run = (status, rule, config) => {
                 ownDirectories();
-                const result = spawnSync(executable, ["--root", scratch, "--files", logical, "--format", "json"], { cwd: scratch, env: { ...probeEnv, GIT_OPTIONAL_LOCKS: "0" }, shell: false, windowsHide: true, timeout: 5000, maxBuffer: 256 * 1024 });
+                const result = spawnSync(executable, ["--root", scratch, "--files", logical, "--format", "json", ...(config ? ["--config", config] : [])], { cwd: scratch, env: { ...probeEnv, GIT_OPTIONAL_LOCKS: "0" }, shell: false, windowsHide: true, timeout: 5000, maxBuffer: 256 * 1024 });
                 if (result.error || result.signal || result.status !== status)
-                    refuse("lint_probe_execution_failed");
+                    refuse(config ? "temporary_configuration_not_supported" : "lint_probe_execution_failed");
                 ownDirectories();
                 const actual = fs.lstatSync(file);
                 if (!actual.isFile() || actual.nlink !== 1 || !same(actual, fileOwner)
@@ -136,6 +142,15 @@ export class PreparedMemoryInitLintCapability {
             const fields = run(1, "frontmatter/required-fields");
             writeProbe(`${validDocument}\n[Missing target](missing-probe-target.md)\n`);
             const links = run(1, "links/markdown-target-exists");
+            if (options.temporaryConfiguration) {
+                // Upgrade's active-document profile needs an external config with exact
+                // finding exclusions; a version response or basic JSON lint is insufficient.
+                const config = path.join(scratch, "upgrade-lint.json");
+                fs.writeFileSync(config, JSON.stringify({ ignoreFindings: [{
+                            ruleId: "links/markdown-target-exists", file: logical, target: "missing-probe-target.md"
+                        }] }), { flag: "wx", mode: 0o600 });
+                run(0, undefined, config);
+            }
             if (checksum() !== probe.executable_sha256)
                 refuse("selected_executable_changed");
             prepared = new PreparedMemoryInitLintCapability({ schema_id: "dd-flow/memory-init-lint-capability@1",
@@ -170,6 +185,9 @@ export class PreparedMemoryInitLintCapability {
         if (!probe || selected.tools["mb-lint"] !== this.#facts.executable
             || probe.version !== this.#facts.version || probe.executable_sha256 !== this.#facts.executable_sha256)
             refuse("lint_capability_changed");
+        this.revalidateExecutable();
+    }
+    revalidateExecutable() {
         // This instance already passed the functional probes. Publication checks
         // preserve its selected executable, not repeat qualification after effects.
         let checksum;

package/dist/services/memory-init-native-capacity.js

@@ -12,6 +12,7 @@ import { readBoundedReleaseFile } from "./release-source.js";
 import { acquireInstallationLock } from "./installation-lock.js";
 import { inspectDaemonOperation } from "../harness-runtime/lib/daemon-operations.mjs";
 import { nativeCommandFingerprint } from "../harness-runtime/lib/native-request-proof.mjs";
+import { validateMemoryInitStartupScope } from "./memory-init-startup-custody.js";
 import { continueProviderCapacity } from "./provider-capacity.js";
 import { CAPACITY_POLICY, MAX_OVERLOAD_RETRIES, refusalObservation, terminalProviderOverload } from "../harness-runtime/lib/provider-overload-policy.mjs";
 const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
@@ -127,6 +128,8 @@ export async function produceMemoryInitNativeCapacity(input) {
         };
         if (result)
             return await publish(result);
+        if (input.restoreOnly)
+            refuse("completed_probe_required", "unknown");
         // An independent bounded technical workspace cannot modify the target.
         const workspace = path.join(root, "project"), stateDir = path.join(root, "daemon");
         fs.mkdirSync(workspace, { recursive: true, mode: 0o700 });
@@ -294,3 +297,13 @@ export async function produceMemoryInitNativeCapacity(input) {
         lease.release();
     }
 }
+/** Recover exact completed probe bytes for a retained raw request whose
+ * resolved selection was not published. Never starts or repairs a probe. */
+export async function restoreCompletedMemoryNativeCapacity(input) {
+    validateMemoryInitStartupScope(input.scope);
+    const prior = read(path.join(input.home, "memory-init-native-probes", hybridDigest(input.scope), "input.json"));
+    if (!prior || hybridDigest(prior.scope) !== hybridDigest(input.scope))
+        refuse("original_probe_required", "unknown");
+    return produceMemoryInitNativeCapacity({ ...input, profile: prior.profile, maximum: Number(prior.maximum),
+        nativeConfigHome: String(prior.native_config_home), requestSha256: String(prior.request_sha256), allowLiveProbe: true, restoreOnly: true });
+}

package/dist/services/memory-init-preflight.js

@@ -55,7 +55,7 @@ function noMemoryBank(directory) {
 function probeTools(tools, env) {
     const facts = Object.create(null);
     const probeEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
-    for (const name of ["git", "wt", "mb-lint"]) {
+    for (const name of Object.keys(tools)) {
         const diagnostics = { name, executable: tools[name], args: ["--version"], timeout_ms: 5000, phase: "executable_read" };
         try {
             const digest = () => createHash("sha256").update(readBoundedReleaseFile(tools[name], 64 * 1024 * 1024)).digest("hex");
@@ -90,6 +90,16 @@ function probeTools(tools, env) {
     }
     return facts;
 }
+/** Shared deterministic executable selection; no project initialization or
+ * tool installation. Upgrade freezes this before content synchronization. */
+export function inspectMemoryLintExecutable(env) {
+    const selected = executable("mb-lint", env);
+    return { executable: selected, probe: probeTools({ "mb-lint": selected }, env)["mb-lint"] };
+}
+export function inspectMemoryGitExecutable(env) {
+    const selected = executable("git", env);
+    return { executable: selected, probe: probeTools({ git: selected }, env).git };
+}
 function inspect(input, env, ownedPublication = false, qualifyTools = true, observe, lintReservation, sourceTools) {
     if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(input.requestId))
         refuse("invalid_request_id");

package/dist/services/memory-init-request-candidate.js

@@ -7,15 +7,21 @@ import { assertImportAdmission } from "../storage/import-guard.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { readBoundedReleaseFile } from "./release-source.js";
 import { validateMemoryInitObjective, validateMemoryInitStartupScope } from "./memory-init-startup-custody.js";
-import { prepareMemoryInitRequestInput } from "./memory-init-request-input.js";
+import { prepareMemoryInitRequestInput, prepareMemoryUpgradeRequestInput } from "./memory-init-request-input.js";
 const preparedCandidates = new WeakMap();
 /** Only a genuinely retained candidate can supply fresh startup input. Copied
  * objects and caller-authored snapshots never acquire candidate authority. */
 export function captureMemoryInitRequestCandidate(candidate, home, scope, objective) {
-    const capture = candidate && typeof candidate === "object" ? preparedCandidates.get(candidate) : undefined;
-    if (!capture)
+    const witness = candidate && typeof candidate === "object" ? preparedCandidates.get(candidate) : undefined;
+    if (!witness || witness.operation !== "memory-init")
         refuse("unprepared_request_candidate");
-    return capture(home, scope, objective);
+    return witness.capture(home, scope, objective);
+}
+export function captureMemoryUpgradeRequestCandidate(candidate, home, scope, objective) {
+    const witness = candidate && typeof candidate === "object" ? preparedCandidates.get(candidate) : undefined;
+    if (!witness || witness.operation !== "memory-upgrade")
+        refuse("unprepared_request_candidate");
+    return witness.capture(home, scope, objective);
 }
 const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function refuse(reason) {
@@ -47,10 +53,42 @@ function syncDirectory(file) {
         fs.closeSync(fd);
     }
 }
+const candidateKey = (scope, operation) => hybridDigest(operation === "memory-upgrade"
+    ? { projectRoot: scope.projectRoot, requestId: scope.requestId } : scope);
 /** Read-only preparation and exact byte capture. A candidate is not startup,
  * storage, engine or dispatch authority. Retain only after prerequisite checks;
  * no missing candidate component is reconstructed from ambient selections. */
 export function prepareMemoryInitRequestCandidate(home, scope, selection, intake) {
+    return prepareMemoryRequestCandidate(home, scope, selection, intake, "memory-init");
+}
+export function prepareMemoryUpgradeRequestCandidate(home, scope, selection, intake) {
+    return prepareMemoryRequestCandidate(home, scope, selection, intake, "memory-upgrade");
+}
+/** Exact original input recovery before an incompatible SQLite store is opened.
+ * No profile, installed release, model, provider or missing component is chosen. */
+export function readMemoryUpgradeRequestCandidate(home, scope) {
+    validateMemoryInitStartupScope(scope);
+    directory(home);
+    const namespace = path.join(home, "memory-upgrade-request-candidates"), key = candidateKey(scope, "memory-upgrade");
+    if (!exists(namespace))
+        return null;
+    directory(namespace);
+    const root = path.join(namespace, key), marker = path.join(namespace, `${key}.json`);
+    if (!exists(root) && !exists(marker))
+        return null;
+    if (!exists(root) || !exists(marker))
+        refuse("candidate_custody_missing");
+    directory(root);
+    const selection = readBoundedReleaseFile(path.join(root, "selection.json"), 256 * 1024);
+    const intake = readBoundedReleaseFile(path.join(root, "intake.txt"), 64 * 1024);
+    const candidate = prepareMemoryUpgradeRequestCandidate(home, scope, selection, intake);
+    // Existing-candidate retain verifies only; it cannot fill partial publication.
+    if (candidate.retain().created)
+        refuse("candidate_custody_missing");
+    return { candidate, objective: candidate.objective,
+        input: captureMemoryUpgradeRequestCandidate(candidate, home, scope, candidate.objective) };
+}
+function prepareMemoryRequestCandidate(home, scope, selection, intake, operation) {
     validateMemoryInitStartupScope(scope);
     scope = structuredClone(scope);
     const selectionBytes = Buffer.from(selection), intakeBytes = Buffer.from(intake);
@@ -64,17 +102,21 @@ export function prepareMemoryInitRequestCandidate(home, scope, selection, intake
         return refuse("invalid_intake_utf8");
     }
     validateMemoryInitObjective(objective);
+    // Original-input validity is not installed-target or storage admission.
+    if (operation === "memory-upgrade")
+        prepareMemoryUpgradeRequestInput(scope, selectionBytes, intakeBytes, objective);
     const homeOwner = directory(home);
     if ([scope.projectRoot, scope.workspaceRoot].some(root => {
         const relative = path.relative(root, home);
         return relative === "" || !path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`);
     }))
         refuse("candidate_home_inside_project");
-    assertImportAdmission(home);
-    const namespace = path.join(home, "memory-init-request-candidates"), key = hybridDigest(scope);
+    if (operation === "memory-init")
+        assertImportAdmission(home);
+    const namespace = path.join(home, `${operation}-request-candidates`), key = candidateKey(scope, operation);
     const root = path.join(namespace, key), marker = path.join(namespace, `${key}.json`);
     const inputFile = path.join(root, "intake.txt"), selectionFile = path.join(root, "selection.json");
-    const facts = { schema_id: "dd-flow/memory-init-request-candidate@1", home, home_owner: homeOwner, scope,
+    const facts = { schema_id: `dd-flow/${operation}-request-candidate@1`, home, home_owner: homeOwner, scope,
         selection_sha256: sha(selectionBytes), intake_sha256: sha(intakeBytes) };
     const verify = () => {
         if (hybridDigest(directory(home)) !== hybridDigest(homeOwner))
@@ -84,7 +126,16 @@ export function prepareMemoryInitRequestCandidate(home, scope, selection, intake
             refuse("candidate_custody_missing");
         const expected = { ...facts, owner: directory(root) };
         const bytes = readBoundedReleaseFile(marker, 16 * 1024);
-        if (!bytes.equals(Buffer.from(JSON.stringify(expected))))
+        let observed;
+        try {
+            observed = JSON.parse(bytes.toString("utf8"));
+        }
+        catch {
+            return refuse("candidate_request_changed");
+        }
+        // Metadata key order is not request identity. Original intake/selection
+        // remain byte-bound below; a reader must not rewrite their marker.
+        if (hybridDigest(observed) !== hybridDigest(expected))
             refuse("candidate_request_changed");
         if (!exists(inputFile) || !exists(selectionFile))
             refuse("candidate_input_missing");
@@ -95,6 +146,10 @@ export function prepareMemoryInitRequestCandidate(home, scope, selection, intake
     if (exists(namespace))
         directory(namespace);
     const found = exists(root) || exists(marker);
+    // Migration reconciliation must be able to read its original upgrade input
+    // while ordinary writers are fenced. It gains no permit or fresh write.
+    if (!found && operation === "memory-upgrade")
+        assertImportAdmission(home);
     if (found)
         verify();
     let retained = false;
@@ -102,7 +157,7 @@ export function prepareMemoryInitRequestCandidate(home, scope, selection, intake
     const candidate = {
         objective,
         retain: () => {
-            if (found) {
+            if (found || operation === "memory-upgrade" && retained) {
                 verify();
                 return complete(false);
             }
@@ -145,13 +200,14 @@ export function prepareMemoryInitRequestCandidate(home, scope, selection, intake
             }
         }
     };
-    preparedCandidates.set(candidate, (expectedHome, expectedScope, expectedObjective) => {
-        if (!retained)
-            refuse("request_candidate_not_retained");
-        if (home !== expectedHome || hybridDigest(scope) !== hybridDigest(expectedScope) || objective !== expectedObjective)
-            refuse("foreign_request_candidate");
-        verify();
-        return prepareMemoryInitRequestInput(scope, selectionBytes, intakeBytes, objective);
-    });
+    preparedCandidates.set(candidate, { operation, capture: (expectedHome, expectedScope, expectedObjective) => {
+            if (!retained)
+                refuse("request_candidate_not_retained");
+            if (home !== expectedHome || hybridDigest(scope) !== hybridDigest(expectedScope) || objective !== expectedObjective)
+                refuse("foreign_request_candidate");
+            verify();
+            return operation === "memory-upgrade" ? prepareMemoryUpgradeRequestInput(scope, selectionBytes, intakeBytes, objective)
+                : prepareMemoryInitRequestInput(scope, selectionBytes, intakeBytes, objective);
+        } });
     return Object.freeze(candidate);
 }

package/dist/services/memory-init-request-input.js

@@ -26,9 +26,9 @@ function text(bytes) {
 }
 /** Data-only decoding for SQL custody/recovery. No Home, files, engine registry,
  * installed canon, current profiles or provider is consulted. */
-export function readMemoryInitRequestInput(value, scope, objective) {
+function readMemoryRequestInput(value, scope, objective, operation) {
     if (!exact(value, ["schema_id", "scope", "intake_base64", "intake_sha256", "selection_base64", "selection_sha256"])
-        || !object(value) || value.schema_id !== "dd-flow/memory-init-request-input@1"
+        || !object(value) || value.schema_id !== `dd-flow/${operation}-request-input@1`
         || hybridDigest(value.scope) !== hybridDigest(scope))
         refuse("invalid_input_scope");
     const intake = decode(value.intake_base64, value.intake_sha256, 64 * 1024);
@@ -44,8 +44,10 @@ export function readMemoryInitRequestInput(value, scope, objective) {
             throw error;
         return refuse("invalid_selection_json");
     }
-    if (!exact(selection, ["schema_id", "scope", "execution", "git_policy", "objective", "engine_checksum", "receipts"])
-        || !object(selection) || selection.schema_id !== "dd-flow/memory-init-request-selection@1"
+    if (!exact(selection, ["schema_id", "scope", "execution", "git_policy", "objective", "engine_checksum", "receipts",
+        ...(operation === "memory-upgrade" ? ["target_installation_sha256"] : [])])
+        || !object(selection) || selection.schema_id !== `dd-flow/${operation}-request-selection@1`
+        || operation === "memory-upgrade" && !digest(selection.target_installation_sha256)
         || hybridDigest(selection.scope) !== hybridDigest(scope) || selection.objective !== objective
         || !object(selection.execution) || !exact(selection.git_policy, ["route", "integrationBranch"])
         || !object(selection.git_policy) || !["integration_branch_direct", "feature_worktree"].includes(String(selection.git_policy.route))
@@ -55,12 +57,26 @@ export function readMemoryInitRequestInput(value, scope, objective) {
         refuse("invalid_original_selection");
     return { intake, selectionBytes, selection: selection };
 }
-export function prepareMemoryInitRequestInput(scope, selection, intake, objective) {
+function prepareMemoryRequestInput(scope, selection, intake, objective, operation) {
     if (!selection.byteLength || selection.byteLength > 256 * 1024 || !intake.byteLength || intake.byteLength > 64 * 1024)
         refuse("unbounded_original_input");
-    const value = { schema_id: "dd-flow/memory-init-request-input@1", scope: structuredClone(scope),
+    const value = { schema_id: `dd-flow/${operation}-request-input@1`, scope: structuredClone(scope),
         intake_base64: Buffer.from(intake).toString("base64"), intake_sha256: sha(intake),
         selection_base64: Buffer.from(selection).toString("base64"), selection_sha256: sha(selection) };
-    readMemoryInitRequestInput(value, scope, objective);
+    readMemoryRequestInput(value, scope, objective, operation);
     return value;
 }
+export function readMemoryInitRequestInput(value, scope, objective) {
+    const read = readMemoryRequestInput(value, scope, objective, "memory-init");
+    return { ...read, selection: read.selection };
+}
+export function readMemoryUpgradeRequestInput(value, scope, objective) {
+    const read = readMemoryRequestInput(value, scope, objective, "memory-upgrade");
+    return { ...read, selection: read.selection };
+}
+export function prepareMemoryInitRequestInput(scope, selection, intake, objective) {
+    return prepareMemoryRequestInput(scope, selection, intake, objective, "memory-init");
+}
+export function prepareMemoryUpgradeRequestInput(scope, selection, intake, objective) {
+    return prepareMemoryRequestInput(scope, selection, intake, objective, "memory-upgrade");
+}

package/dist/services/memory-init-run-bundle.js

@@ -9,6 +9,9 @@ import { readMemoryInitRunAllocation } from "./memory-init-run-allocation.js";
 import { readMemoryInitProjectBootstrap } from "./memory-init-project-bootstrap.js";
 import { bundledHandlerContext } from "./stage-handlers.js";
 import { hybridDigest } from "./hybrid-contracts.js";
+import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-readiness.js";
+import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
+import { nextDescriptorRunId } from "./descriptor-run-start.js";
 const bytes = (value) => Buffer.from(JSON.stringify(value));
 const hash = (value) => createHash("sha256").update(value).digest("hex");
 function refuse(reason) {
@@ -29,6 +32,48 @@ export function prepareMemoryInitRunBundle(context, input) {
     if (!ready || !allocation || !bootstrap || allocation.project_id !== ready.projectId
         || ready.authority.binding.execution_sha256 !== input.execution.sha256)
         refuse("bootstrap_selection_changed");
+    input.source.revalidate();
+    const flow = input.source.resolveRegisteredFlow(), canon = input.source.canonProvenance();
+    const release = JSON.parse(Buffer.from(ready.authority.binding.installation_manifest_base64, "base64").toString("utf8"));
+    if (input.source.installationSha256() !== ready.authority.binding.installation_manifest_sha256
+        || flow.sha256 !== snapshot.settings.descriptor_sha256 || snapshot.settings.flow_id !== "mb-init"
+        || canon.version !== release.canon.version || canon.commit !== release.canon.commit
+        || canon.archive_sha256 !== release.canon.archive.sha256
+        || !input.engine.manifestBytes().equals(Buffer.from(ready.authority.binding.engine_manifest_base64, "base64")))
+        refuse("frozen_source_changed");
+    return prepareMemoryRunBundle(input, ready, { runId: allocation.run_id, boundAt: bootstrap.receipt.created_at,
+        flowId: "mb-init", projectPack: { sha256: ready.authority.binding.pack_sha256, source_commit: canon.commit } });
+}
+/** Upgrade executes the target canon but starts with the original project pack.
+ * It must not claim that publication has already happened at RUN allocation. */
+export function prepareMemoryUpgradeRunBundle(context, input) {
+    if (!(input.source instanceof PreparedInstalledFlowSource) || !(input.execution instanceof FrozenGenericExecution)
+        || !(input.engine instanceof AdmittedFrozenEngine))
+        refuse("unprepared_selection");
+    const snapshot = input.execution.snapshot(), scope = { requestId: snapshot.scope.requestId,
+        projectRoot: snapshot.scope.projectRoot, workspaceRoot: snapshot.scope.workspace };
+    const ready = readMemoryUpgradeBootstrapReadiness(context, scope), storage = readUpgradeStorageReadiness(context, scope);
+    if (!ready || !storage?.selection || !ready.hasFlowCapability || !ready.hasGitPolicy || !ready.hasLintCapability
+        || !ready.hasPreservationBaseline || ready.authority.binding.execution_sha256 !== input.execution.sha256
+        || ready.authority.binding.selection_sha256 !== storage.selection.sha256)
+        refuse("bootstrap_selection_changed");
+    const p = storage.selection.payload, canon = input.source.canonProvenance();
+    input.source.revalidate();
+    if (input.source.sha256 !== p.source.sha256 || input.source.installationSha256() !== p.release.manifest_sha256
+        || snapshot.settings.flow_id !== "mb-upgrade" || input.source.resolveRegisteredFlow().sha256 !== snapshot.settings.descriptor_sha256
+        || canon.version !== storage.selection.release.canon.version || canon.commit !== storage.selection.release.canon.commit
+        || canon.archive_sha256 !== storage.selection.release.canon.archive.sha256
+        || !input.engine.manifestBytes().equals(Buffer.from(ready.authority.binding.engine_manifest_base64, "base64")))
+        refuse("frozen_source_changed");
+    return prepareMemoryRunBundle(input, ready, {
+        runId: nextDescriptorRunId(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, slug: "mb-upgrade" }),
+        boundAt: ready.createdAt, flowId: "mb-upgrade",
+        projectPack: { sha256: ready.authority.receipt.project_current.pack_sha256, source_commit: p.current.source_commit }
+    });
+}
+function prepareMemoryRunBundle(input, ready, selected) {
+    const snapshot = input.execution.snapshot(), scope = { requestId: snapshot.scope.requestId,
+        projectRoot: snapshot.scope.projectRoot, workspaceRoot: snapshot.scope.workspace };
     const { bootstrapIdentity, receipts: bootstrapReceipts } = ready.admission;
     if (!bootstrapIdentity || !bootstrapReceipts)
         refuse("bootstrap_admission_missing");
@@ -43,22 +88,14 @@ export function prepareMemoryInitRunBundle(context, input) {
             refuse("execution_receipt_collision");
         receipts.set(reference.sha256, structuredClone(fact));
     }
-    input.source.revalidate();
     const flow = input.source.resolveRegisteredFlow(), canon = input.source.canonProvenance();
-    const release = JSON.parse(Buffer.from(ready.authority.binding.installation_manifest_base64, "base64").toString("utf8"));
-    if (input.source.installationSha256() !== ready.authority.binding.installation_manifest_sha256
-        || flow.sha256 !== snapshot.settings.descriptor_sha256 || snapshot.settings.flow_id !== "mb-init"
-        || canon.version !== release.canon.version || canon.commit !== release.canon.commit
-        || canon.archive_sha256 !== release.canon.archive.sha256
-        || !input.engine.manifestBytes().equals(Buffer.from(ready.authority.binding.engine_manifest_base64, "base64")))
-        refuse("frozen_source_changed");
-    const manifest = input.engine.manifest(), runId = allocation.run_id;
+    const manifest = input.engine.manifest(), runId = selected.runId;
     if (typeof manifest.integrity.checksum !== "string")
         refuse("missing_engine_checksum");
     // The accepted bootstrap timestamp makes reconstruction stable after a lost
     // reply. Current time is not a new selector for this request's engine binding.
     const binding = { schema_id: "dd-flow/run-engine-binding@1", run_id: runId, project_root: scope.projectRoot,
-        bound_at: bootstrap.receipt.created_at, source: "run_creation", reason: "Request-bound memory init bootstrap",
+        bound_at: selected.boundAt, source: "run_creation", reason: selected.flowId === "mb-init" ? "Request-bound memory init bootstrap" : "Request-bound memory upgrade bootstrap",
         engine: { package_name: manifest.package_name, package_version: manifest.package_version, engine_version: manifest.engine_version,
             integrity_checksum: manifest.integrity.checksum, snapshot_root: manifest.snapshot_root }, probe: { status: "not_required", command: null } };
     const blobs = input.source.blobs();
@@ -84,8 +121,8 @@ export function prepareMemoryInitRunBundle(context, input) {
     for (const evidence of ready.authority.evidence)
         put(evidence.path, Buffer.from(evidence.base64, "base64"));
     const receipt = put("receipts/bootstrap.json", bytes(ready.authority.receipt));
-    const provenance = { canon, project_pack: { sha256: ready.authority.binding.pack_sha256, source_commit: canon.commit } };
-    const bundle = { schema_id: "dd-flow/execution-bundle@1", run_id: runId, flow_id: "mb-init",
+    const provenance = { canon, project_pack: selected.projectPack };
+    const bundle = { schema_id: "dd-flow/execution-bundle@1", run_id: runId, flow_id: selected.flowId,
         descriptor: input.source.descriptorReference(), execution_settings: execution, profile_settings: profile,
         engine_binding: engineBinding, engine_manifest: engineManifest, bootstrap_receipts: [receipt], ...provenance,
         inventory: [...blobs].map(([logical, content]) => ({ path: logical, sha256: hash(content) })) };

package/dist/services/memory-init-storage.js

@@ -18,7 +18,7 @@ const primaryKeys = {
 };
 function refuse(reason) { throw new AppError("memory_init_storage_incompatible", "Executing CLI cannot admit memory-init runtime storage without migration or repair", 1, { reason, effect: "no_effect" }); }
 const normalize = (sql) => sql.replace(/\s+/g, " ").trim().replace(/;$/, "");
-function inspect(context) {
+function inspect(context, upgrade = false) {
     if (!context.db.writable || !path.isAbsolute(context.ddFlowHome) || path.resolve(context.db.path) !== path.join(path.resolve(context.ddFlowHome), "db.sqlite"))
         refuse("foreign_or_readonly_store");
     const contract = context.db.all("SELECT id, version FROM dd_flow_writer_contract");
@@ -26,14 +26,15 @@ function inspect(context) {
         || context.db.get("SELECT dd_flow_writer_version() AS version")?.version !== STORE_WRITER_VERSION)
         refuse("writer_contract_mismatch");
     const schema = {};
-    for (const [table, required] of Object.entries(footprint)) {
+    const selectedFootprint = upgrade ? { ...footprint, runtime_config: ["key", "value_json", "created_at", "updated_at"] } : footprint;
+    for (const [table, required] of Object.entries(selectedFootprint)) {
         const columns = context.db.all(`PRAGMA table_info("${table}")`);
         if (required.some(name => !columns.some(column => column.name === name)))
             refuse(`missing_operation_column:${table}`);
         if (required.some(name => columns.find(column => column.name === name)?.type.toUpperCase() !== (table === "audit_events" && ["id", "forced"].includes(name) ? "INTEGER" : "TEXT")))
             refuse(`operation_column_type_mismatch:${table}`);
         const key = columns.filter(column => column.pk > 0).sort((a, b) => a.pk - b.pk).map(column => column.name);
-        if (JSON.stringify(key) !== JSON.stringify(primaryKeys[table]))
+        if (JSON.stringify(key) !== JSON.stringify(table === "runtime_config" ? ["key"] : primaryKeys[table]))
             refuse(`operation_primary_key_mismatch:${table}`);
         const fences = [];
         for (const action of ["INSERT", "UPDATE", "DELETE"]) {
@@ -56,14 +57,23 @@ function inspect(context) {
 export class PreparedMemoryInitRuntimeStorage {
     sha256;
     #facts;
-    constructor(facts) { this.#facts = facts; this.sha256 = hybridDigest(facts); Object.freeze(this); }
+    #upgrade;
+    constructor(facts, upgrade) { this.#facts = facts; this.#upgrade = upgrade; this.sha256 = hybridDigest(facts); Object.freeze(this); }
     static prepare(context) {
+        return this.prepareFor(context, false);
+    }
+    /** Upgrade reuses the RUN/Work footprint and additionally needs retained
+     * request custody. This remains a non-migrating connection observation. */
+    static prepareUpgrade(context) {
+        return this.prepareFor(context, true);
+    }
+    static prepareFor(context, upgrade) {
         try {
             return context.db.readSnapshot(() => {
-                const facts = inspect(context), integrity = context.db.all("PRAGMA quick_check");
+                const facts = inspect(context, upgrade), integrity = context.db.all("PRAGMA quick_check");
                 if (integrity.length !== 1 || integrity[0]?.quick_check !== "ok" || context.db.all("PRAGMA foreign_key_check").length)
                     refuse("storage_integrity_failed");
-                return new PreparedMemoryInitRuntimeStorage(facts);
+                return new PreparedMemoryInitRuntimeStorage(facts, upgrade);
             });
         }
         catch (error) {
@@ -75,7 +85,7 @@ export class PreparedMemoryInitRuntimeStorage {
     facts() { return { ...this.#facts }; }
     /** Writer-safe metadata fence; expensive integrity scan remains preparation. */
     assertCompatibility(context) {
-        if (hybridDigest(inspect(context)) !== this.sha256)
+        if (hybridDigest(inspect(context, this.#upgrade)) !== this.sha256)
             refuse("storage_changed_after_preparation");
     }
 }