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

package/dist/services/memory-git-integration.js

@@ -12,6 +12,31 @@ import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { ObservedMemorySources } from "./memory-source-observations.js";
 import { memorySourceKey } from "./memory-stage-results.js";
+export function isReviewedMemoryGitFile(ref) {
+    return !!ref && ref.root === "workspace" && typeof ref.path === "string"
+        && (ref.path.startsWith(".memory-bank/") || ref.path === ".mb-lint.json") && ref.path.length <= 4096 && !/[\\\0]/.test(ref.path)
+        && !ref.path.split("/").some(segment => !segment || segment === "." || segment === "..")
+        && typeof ref.sha256 === "string" && /^[a-f0-9]{64}$/.test(ref.sha256)
+        && (Object.keys(ref).sort().join() === "path,root,sha256"
+            || Object.keys(ref).sort().join() === "git_mode,path,root,sha256" && ["100644", "100755"].includes(ref.git_mode));
+}
+/** A removed file is absent, not a directory or a path through a symlink. */
+export function assertMemoryGitRemovalSources(directory, removals) {
+    for (const ref of removals) {
+        let current = directory;
+        const segments = ref.path.split("/");
+        for (const [index, segment] of segments.entries()) {
+            current = path.join(current, segment);
+            const stat = fs.lstatSync(current, { throwIfNoEntry: false });
+            if (!stat)
+                break;
+            if (index === segments.length - 1)
+                refuse("removed_memory_file_present");
+            if (!stat.isDirectory())
+                refuse("unsafe_removal_parent");
+        }
+    }
+}
 function refuse(reason) {
     throw new AppError("memory_git_integration_invalid", "Memory finish lacks observed Git integration", 2, { reason, effect: "no_effect" });
 }
@@ -39,7 +64,7 @@ export function observeMemoryGitIntegration(input, env) {
         || !path.isAbsolute(input.gitExecutable))
         refuse("explicit_git_selection_required");
     const projectRoot = root(input.projectRoot), workspaceRoot = root(input.workspaceRoot);
-    const cleanEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
+    const cleanEnv = { ...Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_"))), GIT_LITERAL_PATHSPECS: "1" };
     const git = (directory, args, expectedStatus = 0) => {
         const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false",
             "-C", directory, ...args], { env: { ...cleanEnv, GIT_OPTIONAL_LOCKS: "0" }, encoding: "utf8",
@@ -91,39 +116,82 @@ export function observeMemoryGitIntegration(input, env) {
 /** Exact reviewed MB/owned root lint bytes in the physical workspace and integrated Git
  * tree. References must be selected by the accepted review owner; this helper
  * validates physical correspondence only and grants no semantic authority. */
-export function observeReviewedMemoryGitIntegration(input, env, references) {
+export function observeReviewedMemoryGitIntegration(input, env, references, removals = []) {
     if (!Array.isArray(references) || !references.length || references.length > 4096
-        || references.some(ref => !ref || ref.root !== "workspace" || typeof ref.path !== "string"
-            || !(ref.path.startsWith(".memory-bank/") || ref.path === ".mb-lint.json") || ref.path.length > 4096 || ref.path.includes("\\") || ref.path.includes("\0")
-            || ref.path.split("/").some((segment) => !segment || segment === "." || segment === "..")
-            || typeof ref.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(ref.sha256)
-            || Object.keys(ref).sort().join() !== "path,root,sha256")
-        || new Set(references.map(ref => ref.path)).size !== references.length
+        || references.some(ref => !isReviewedMemoryGitFile(ref))
+        || !Array.isArray(removals) || references.length + removals.length > 4096
+        || removals.some(ref => !isReviewedMemoryGitFile(ref) || !ref.path.startsWith(".memory-bank/") || ref.path === ".memory-bank/index.md")
+        || new Set([...references, ...removals].map(ref => ref.path)).size !== references.length + removals.length
         || !references.some(ref => ref.path === ".memory-bank/index.md"))
         refuse("invalid_reviewed_memory_inventory");
     const selected = structuredClone([...references]).sort((a, b) => a.path.localeCompare(b.path, "en"));
+    const removed = structuredClone([...removals]).sort((a, b) => a.path.localeCompare(b.path, "en"));
     const integration = observeMemoryGitIntegration(input, env);
     const observed = ObservedMemorySources.capture({ workspace: integration.workspace_root }, selected.map(({ root, path }) => ({ root, path })));
     const hashes = observed.hashes();
-    const cleanEnv = Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_")));
-    const git = (args, directory = integration.workspace_root) => {
+    const cleanEnv = { ...Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith("GIT_"))), GIT_LITERAL_PATHSPECS: "1" };
+    const git = (args, directory = integration.workspace_root, stdin) => {
         const result = spawnSync(input.gitExecutable, ["-c", "core.fsmonitor=false", "-c", "core.untrackedCache=false",
             "-C", directory, ...args], { env: { ...cleanEnv, GIT_OPTIONAL_LOCKS: "0" },
-            timeout: 10000, maxBuffer: 16 * 1024 * 1024, windowsHide: true, shell: false });
+            input: stdin, timeout: 10000, maxBuffer: (stdin === undefined ? 16 : 65) * 1024 * 1024, windowsHide: true, shell: false });
         if (result.error || result.signal || result.status !== 0)
             refuse("reviewed_git_blob_unavailable");
         return result.stdout;
     };
     let total = 0;
+    const entries = new Map();
+    const listing = git(["ls-tree", "-r", "-t", "-z", integration.workspace_head, "--", ".memory-bank", ".mb-lint.json"]).toString("utf8");
+    if (listing && !listing.endsWith("\0"))
+        refuse("reviewed_regular_git_blob_required");
+    for (const entry of listing.split("\0").filter(Boolean)) {
+        const match = /^([0-7]{6}) (blob|tree|commit) ([a-f0-9]{40,64})\t([\s\S]+)$/.exec(entry);
+        if (!match || entries.has(match[4]))
+            refuse("reviewed_regular_git_blob_required");
+        entries.set(match[4], { mode: match[1], type: match[2], oid: match[3] });
+    }
+    for (const directory of new Set([integration.workspace_root, integration.project_root]))
+        assertMemoryGitRemovalSources(directory, removed);
+    for (const ref of removed) {
+        if (entries.has(ref.path))
+            refuse("removed_memory_file_still_committed");
+    }
+    const oids = [...new Set(selected.map(ref => {
+            const entry = entries.get(ref.path);
+            if (!entry || entry.mode !== (ref.git_mode ?? "100644") || entry.type !== "blob")
+                refuse("reviewed_regular_git_blob_required");
+            return entry.oid;
+        }))];
+    const batch = git(["cat-file", "--batch"], integration.workspace_root, `${oids.join("\n")}\n`);
+    const contents = new Map();
+    let offset = 0;
+    for (const oid of oids) {
+        const end = batch.indexOf(10, offset);
+        if (end < 0)
+            refuse("reviewed_git_blob_unavailable");
+        const header = /^([a-f0-9]{40,64}) blob (0|[1-9][0-9]*)$/.exec(batch.subarray(offset, end).toString("ascii"));
+        const size = Number(header?.[2]);
+        if (!header || header[1] !== oid || !Number.isSafeInteger(size) || size > 16 * 1024 * 1024
+            || end + 1 + size >= batch.length || batch[end + 1 + size] !== 10)
+            refuse("reviewed_git_blob_unavailable");
+        contents.set(oid, batch.subarray(end + 1, end + 1 + size));
+        offset = end + size + 2;
+    }
+    if (offset !== batch.length)
+        refuse("reviewed_git_blob_unavailable");
     for (const ref of selected) {
         if (hashes.get(memorySourceKey("workspace", ref.path)) !== ref.sha256)
             refuse("reviewed_workspace_bytes_changed");
-        const entry = git(["ls-tree", "-z", integration.workspace_head, "--", ref.path]).toString("utf8");
-        const separator = entry.indexOf("\t");
-        if (separator < 0 || !/^100644 blob [a-f0-9]{40,64}$/.test(entry.slice(0, separator))
-            || entry.slice(separator + 1) !== `${ref.path}\0`)
-            refuse("reviewed_regular_git_blob_required");
-        const content = git(["cat-file", "blob", `${integration.workspace_head}:${ref.path}`]);
+        const expectedMode = ref.git_mode ?? "100644";
+        // Git may ignore chmod when core.filemode=false. Bytes and clean status
+        // alone do not prove that a preserved executable still is executable.
+        if (process.platform !== "win32") {
+            for (const directory of new Set([integration.workspace_root, integration.project_root])) {
+                const executable = (fs.lstatSync(path.join(directory, ref.path)).mode & 0o111) !== 0;
+                if (executable !== (expectedMode === "100755"))
+                    refuse("reviewed_workspace_mode_changed");
+            }
+        }
+        const content = contents.get(entries.get(ref.path).oid);
         total += content.length;
         if (total > 64 * 1024 * 1024)
             refuse("reviewed_git_bytes_exceed_bound");
@@ -147,5 +215,6 @@ export function observeReviewedMemoryGitIntegration(input, env, references) {
     observed.revalidate();
     if (hybridDigest(observeMemoryGitIntegration(input, env)) !== hybridDigest(integration))
         refuse("integration_changed_during_observation");
-    return { ...integration, reviewed_files_sha256: hybridDigest(selected) };
+    return { ...integration, reviewed_files_sha256: hybridDigest(selected),
+        ...(removed.length ? { removed_files_sha256: hybridDigest(removed) } : {}) };
 }

package/dist/services/memory-historical-corrected-review.js

@@ -1,3 +1,4 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedHistoricalOriginalMemoryReview } from "./memory-historical-original-review.js";
@@ -33,7 +34,7 @@ export function assertHistoricalMemoryReviewSources(histories, paths, runInputs,
     for (const history of retainedHistories) {
         if (!prefixes.has(hybridDigest(history.before().entries())))
             refuse("historical_input_prefix_changed");
-        baseline = baseline.composeSettledDelta(history.before(), history.after());
+        baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
         prefixes.add(hybridDigest(baseline.entries()));
         const before = new Map(history.before().entries().map(entry => [entry.path, entry]));
         for (const entry of history.after().entries())
@@ -57,6 +58,7 @@ export function assertHistoricalMemoryReviewSources(histories, paths, runInputs,
  * input/check hashes must be selected from the independent accepted receipt.
  * Current workspace/copies/policy are never adopted or used for re-admission. */
 export class PreparedHistoricalCorrectedMemoryReview {
+    #custodyKey = {};
     static isPrepared(value) {
         return typeof value === "object" && value !== null && #original in value;
     }
@@ -104,7 +106,7 @@ export class PreparedHistoricalCorrectedMemoryReview {
         assertHistoricalMemoryReviewSources(histories, paths, view.run_inputs);
         const repairResults = histories.map(history => ({ work_id: history.workId, result: history.result(), reference: history.reference(), authority_sha256: history.sha256,
             unit_ids: repairBatch.works.find(item => repairReceipt.work_ids[item.key] === history.workId).payload.memory_repair.unit_ids }));
-        const compose = readAcceptedStageData(context, { projectId: scope.project_id, runId: scope.run_id, stage: "compose" });
+        const compose = readAcceptedStageData(context, { projectId: scope.project_id, runId: scope.run_id, stage: bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose" });
         const affected = memoryCorrectionAffectedUnits(initial.view.unit_inventory, repairResults, JSON.parse(compose.bytes.toString("utf8")).details.works);
         const assignments = correctedMemoryReviewAssignments({ units: initial.view.unit_inventory, initialAssignments: initial.view.assignments, affected,
             files: view.run_inputs.filter(ref => ref.root === "workspace"), repairs: repairResults });
@@ -112,6 +114,7 @@ export class PreparedHistoricalCorrectedMemoryReview {
             || view.original_review_sha256 !== original.reviewSha256() || view.base !== initial.view.base
             || hybridDigest(view.unit_inventory) !== hybridDigest(initial.view.unit_inventory)
             || hybridDigest(view.instruction) !== hybridDigest(initial.view.instruction)
+            || hybridDigest([view.upgrade_baseline, view.preservation_invariants]) !== hybridDigest([initial.view.upgrade_baseline, initial.view.preservation_invariants])
             || hybridDigest(view.affected_unit_ids) !== hybridDigest(affected) || hybridDigest(view.assignments) !== hybridDigest(assignments)
             || hybridDigest(view.repairs) !== hybridDigest(repairResults.map(repair => ({ work_id: repair.work_id, authority_sha256: repair.authority_sha256, result: repair.reference }))))
             refuse("historical_correction_projection_changed");
@@ -155,7 +158,7 @@ export class PreparedHistoricalCorrectedMemoryReview {
         for (const history of this.#histories) {
             if (!prefixes.has(hybridDigest(history.before().entries())))
                 refuse("historical_input_prefix_changed");
-            baseline = baseline.composeSettledDelta(history.before(), history.after());
+            baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
             prefixes.add(hybridDigest(baseline.entries()));
         }
         return baseline;
@@ -169,7 +172,7 @@ export class PreparedHistoricalCorrectedMemoryReview {
         return structuredClone(this.#effective);
     }
     bundle() { return this.#original.bundle(); }
-    verificationProfileHash(context) { this.assertCustody(context); return this.#original.verificationProfileHash(context); }
+    verificationProfileHash(context) { this.assertCustody(context); return this.#checks.value(context).profile_sha256; }
     /** Exact live fan-in identity reconstructed from retained settlements.
      * A digest is an identity, not independent plan or Stage acceptance. */
     reviewSha256() {
@@ -182,17 +185,20 @@ export class PreparedHistoricalCorrectedMemoryReview {
                 authority_sha256: worker.authority, result: { ...worker.result } })) };
     }
     assertCustody(context) {
-        this.#original.assertCustody(context);
-        this.#repairs.assertCustody(context);
-        this.#checks.assertCustody(context);
-        if (hybridDigest(readRetainedCorrectedMemoryReviewRegistration(context, this.#registration.scope, this.#registration.input_sha256, this.#registration.check_receipt_sha256)) !== hybridDigest(this.#registration))
-            refuse("historical_registration_changed");
-        for (const history of this.#histories)
-            history.assertCustody(context);
-        const harness = runtimeHarness(this.#original.bundle().execution.work("review").worker);
-        for (const worker of this.#workers)
-            if (readMemoryReviewWorkSettlement(context, this.#registration, worker.workId, harness).authority !== worker.authority)
-                refuse("historical_reviewer_settlement_changed");
+        const original = this.#original;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            original.assertCustody(context);
+            this.#repairs.assertCustody(context);
+            this.#checks.assertCustody(context);
+            if (hybridDigest(readRetainedCorrectedMemoryReviewRegistration(context, this.#registration.scope, this.#registration.input_sha256, this.#registration.check_receipt_sha256)) !== hybridDigest(this.#registration))
+                refuse("historical_registration_changed");
+            for (const history of this.#histories)
+                history.assertCustody(context);
+            const harness = runtimeHarness(this.#original.bundle().execution.work("review").worker);
+            for (const worker of this.#workers)
+                if (readMemoryReviewWorkSettlement(context, this.#registration, worker.workId, harness).authority !== worker.authority)
+                    refuse("historical_reviewer_settlement_changed");
+        });
     }
     revalidate(context) {
         this.#original.revalidate(context);

package/dist/services/memory-historical-original-review.js

@@ -1,3 +1,4 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { RetainedExecutionBundle } from "./execution-bundles.js";
@@ -27,13 +28,14 @@ function selected(context, scope, bundle, mode) {
     const phase = { project_id: scope.projectId, run_id: scope.runId, stage: "review", attempt: stage.attempt,
         input_sha256: stage.input_sha256, parent_work_id: root.workId, execution_sha256: bundle.execution.sha256, bundle_sha256: bundle.sha256 };
     const registration = readRegisteredMemoryReview(context, phase, 0), view = registration.view;
-    const compose = readAcceptedStageData(context, { ...scope, stage: "compose" }), verify = readAcceptedStageData(context, { ...scope, stage: "verify" });
+    const upgrade = bundle.descriptor.descriptor.id === "mb-upgrade", authoring = upgrade ? "upgrade" : "compose";
+    const compose = readAcceptedStageData(context, { ...scope, stage: authoring }), verify = readAcceptedStageData(context, { ...scope, stage: "verify" });
     const review = mode === "closed" ? readAcceptedStageData(context, { ...scope, stage: "review" }) : null;
     const composed = JSON.parse(compose.bytes.toString("utf8"));
-    if (compose.data_schema_id !== "dd-flow/mb-init-compose-result@1" || composed.schema_id !== compose.data_schema_id
-        || composed.stage !== "compose" || composed.run_id !== scope.runId || composed.outcome !== "accepted"
+    if (compose.data_schema_id !== (upgrade ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-compose-result@1") || composed.schema_id !== compose.data_schema_id
+        || composed.stage !== authoring || composed.run_id !== scope.runId || composed.outcome !== "accepted"
         || composed.input_sha256 !== compose.input_sha256 || hybridDigest(composed.units) !== hybridDigest(view.unit_inventory)
-        || (review !== null && (review.data_schema_id !== "dd-flow/mb-init-review-result@1" || review.input_sha256 !== phase.input_sha256))
+        || (review !== null && (review.data_schema_id !== (upgrade ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-review-result@1") || review.input_sha256 !== phase.input_sha256))
         || view.source_policy !== "review-inputs@1" || hybridDigest(view.instruction) !== hybridDigest({
         sha256: bundle.descriptor.stage("review").instruction.sha256, base64: bundle.descriptor.stageBlob("review", "instruction").toString("base64")
     }))
@@ -47,11 +49,19 @@ function selected(context, scope, bundle, mode) {
     const workers = batch.works.map(item => readMemoryReviewWorkSettlement(context, registration, registration.work_ids[item.key], harness));
     return { mode, registration, batch, workers, compose, verify, review, runRoot: run.run_root ?? run.run_dir };
 }
+// Private comparison only: retain every byte without expanding Buffers into
+// numerically keyed JSON objects. SQL and physical custody are still reread.
+function authority(value) {
+    const stage = (data) => ({ ...data, bytes: data.bytes.toString("base64") });
+    return hybridDigest({ ...value, compose: stage(value.compose), verify: stage(value.verify), review: value.review && stage(value.review),
+        workers: value.workers.map(worker => ({ ...worker, bytes: worker.bytes.toString("base64") })) });
+}
 /** Original wave proof after Stage closure, not accepted corrected-review or
  * repair authority. Never reused by fresh Work allocation or current-view
  * admission. Only retained RUN files and scoped SQL are observed; no active
  * coordinator Session or obsolete workspace copy is required. */
 export class PreparedHistoricalOriginalMemoryReview {
+    #custodyKey = {};
     static isPrepared(value) {
         return typeof value === "object" && value !== null && #scope in value;
     }
@@ -71,7 +81,7 @@ export class PreparedHistoricalOriginalMemoryReview {
         this.#verification = verification;
         this.#observed = observed;
         this.#results = structuredClone(results);
-        this.#authority = hybridDigest(value);
+        this.#authority = authority(value);
         Object.freeze(this);
     }
     static prepare(context, input) {
@@ -84,7 +94,7 @@ export class PreparedHistoricalOriginalMemoryReview {
         return this.#prepare(context, input, "open");
     }
     static #prepare(context, input, mode) {
-        if (!(input.bundle instanceof RetainedExecutionBundle) || input.bundle.descriptor.descriptor.id !== "mb-init")
+        if (!(input.bundle instanceof RetainedExecutionBundle) || !["mb-init", "mb-upgrade"].includes(input.bundle.descriptor.descriptor.id))
             refuse("registered_memory_bundle_required");
         if (context.db.isOwnedWriteTransaction?.())
             refuse("preparation_outside_writer_required");
@@ -122,9 +132,12 @@ export class PreparedHistoricalOriginalMemoryReview {
             result: { ...worker.result }, unit_ids: [results[index].unit_id] }));
     }
     assertCustody(context) {
-        this.#verification.assertCustody(context);
-        if (hybridDigest(selected(context, this.#scope, this.#bundle, this.#value.mode)) !== this.#authority)
-            refuse("historical_original_custody_changed");
+        const verification = this.#verification;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            verification.assertCustody(context);
+            if (authority(selected(context, this.#scope, this.#bundle, this.#value.mode)) !== this.#authority)
+                refuse("historical_original_custody_changed");
+        });
     }
     revalidate(context) { this.#verification.revalidate(context); this.#observed.revalidate(); this.assertCustody(context); }
 }

package/dist/services/memory-historical-repair-registration.js

@@ -1,8 +1,9 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedHistoricalOriginalMemoryReview } from "./memory-historical-original-review.js";
 import { readRetainedMemoryRepairRegistration, assertRetainedMemoryRepairAllocation, memoryRepairBatch, memoryRepairWorkerSchema } from "./memory-repair-registration.js";
-import { validateMemoryReviewCorrectionPlan } from "./memory-review-correction-plan.js";
+import { validateMemoryReviewCorrectionPlan, memoryRepairCanonicalPaths } from "./memory-review-correction-plan.js";
 import { memoryReviewWaveProjection } from "./memory-review-acceptance.js";
 const token = Symbol("historical-memory-repair-registration");
 function refuse(reason) {
@@ -18,6 +19,7 @@ function selected(context, original) {
     const engine = bundle.engine();
     const plan = validateMemoryReviewCorrectionPlan(Buffer.from(receipt.plan_base64, "base64"), engine, {
         runId: registration.run_id, wave: 1, reviewSha256: original.reviewSha256(), units: registration.view.unit_inventory,
+        canonicalPaths: memoryRepairCanonicalPaths(context, bundle),
         findings: memoryReviewWaveProjection(results, registration.view.diagnostic_findings).findings
     });
     for (const item of plan.works)
@@ -34,6 +36,7 @@ function selected(context, original) {
  * type: fresh repair baseline/copy/start/allocation APIs do not accept it.
  * Settled-history validation may consume it without requiring live review. */
 export class PreparedHistoricalMemoryRepairRegistration {
+    #custodyKey = {};
     static isPrepared(value) {
         return typeof value === "object" && value !== null && #original in value;
     }
@@ -87,13 +90,16 @@ export class PreparedHistoricalMemoryRepairRegistration {
         return rows.map(row => row.work_id);
     }
     assertCustody(context) {
-        this.#original.assertCustody(context);
-        const receipt = readRetainedMemoryRepairRegistration(context, this.#receipt.scope);
-        if (hybridDigest(receipt) !== this.sha256)
-            refuse("historical_repair_registration_changed");
-        // The immutable plan/batch was admitted by prepare. Custody checks reread
-        // scoped SQL allocation, not the same frozen engine and plan again.
-        assertRetainedMemoryRepairAllocation(context, receipt, this.#batch);
+        const original = this.#original;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            original.assertCustody(context);
+            const receipt = readRetainedMemoryRepairRegistration(context, this.#receipt.scope);
+            if (hybridDigest(receipt) !== this.sha256)
+                refuse("historical_repair_registration_changed");
+            // The immutable plan/batch was admitted by prepare. Custody checks reread
+            // scoped SQL allocation, not the same frozen engine and plan again.
+            assertRetainedMemoryRepairAllocation(context, receipt, this.#batch);
+        });
     }
     revalidate(context) { this.#original.revalidate(context); this.assertCustody(context); }
 }

package/dist/services/memory-historical-second-review.js

@@ -1,3 +1,4 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedHistoricalSecondMemoryCorrectionWave } from "./memory-completed-correction-wave.js";
@@ -22,6 +23,7 @@ function refuse(reason) {
  * come from an independently accepted receipt, not current workspace policy.
  * This owner alone neither accepts a Stage nor admits another correction. */
 export class PreparedHistoricalSecondMemoryReview {
+    #custodyKey = {};
     static isPrepared(value) {
         return typeof value === "object" && value !== null && #wave in value;
     }
@@ -64,6 +66,7 @@ export class PreparedHistoricalSecondMemoryReview {
             || view.first_check_receipt_sha256 !== receipt.first_check_receipt_sha256
             || view.first_review_registration_sha256 !== receipt.first_review_registration_sha256
             || hybridDigest(view.instruction) !== hybridDigest(first.instruction)
+            || hybridDigest([view.upgrade_baseline, view.preservation_invariants]) !== hybridDigest([first.upgrade_baseline, first.preservation_invariants])
             || hybridDigest(view.unit_inventory) !== hybridDigest(projected.units)
             || hybridDigest(view.assignments) !== hybridDigest(projected.assignments)
             || hybridDigest(view.affected_unit_ids) !== hybridDigest(wave.affectedUnitIds())
@@ -98,6 +101,19 @@ export class PreparedHistoricalSecondMemoryReview {
         return prepared;
     }
     projection() { return structuredClone(this.#projection); }
+    settledDocumentBaseline() {
+        const registration = this.#wave.registration();
+        const paths = [...new Set(registration.plan().works.flatMap(work => work.write_paths))].sort();
+        let baseline = registration.initialDocumentBaseline().withWritePaths(paths);
+        const prefixes = new Set([hybridDigest(baseline.entries())]);
+        for (const history of this.#wave.histories()) {
+            if (!prefixes.has(hybridDigest(history.before().entries())))
+                refuse("historical_input_prefix_changed");
+            baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
+            prefixes.add(hybridDigest(baseline.entries()));
+        }
+        return baseline;
+    }
     retainedInputView() { return structuredClone(this.#registration.view); }
     finalChecks(context) { this.assertCustody(context); return this.#checks.value(context).checks; }
     settlementProof(context) {
@@ -107,17 +123,20 @@ export class PreparedHistoricalSecondMemoryReview {
             workers: this.#workers.map(worker => ({ work_id: worker.workId, authority_sha256: worker.authority, result: { ...worker.result } })) };
     }
     assertCustody(context) {
-        this.#wave.assertCustody(context);
-        this.#checks.assertCustody(context);
-        const receipt = this.#registration;
-        if (hybridDigest(readRetainedSecondCorrectedMemoryReviewRegistration(context, receipt.scope, receipt.input_sha256, receipt.check_receipt_sha256)) !== hybridDigest(receipt))
-            refuse("historical_second_registration_changed");
-        if (hybridDigest(this.#wave.registration().firstEffectiveReviewProof(context)) !== hybridDigest(this.#previous))
-            refuse("first_review_history_changed");
-        const harness = runtimeHarness(this.#wave.registration().bundle().execution.work("review").worker);
-        for (const worker of this.#workers)
-            if (readMemoryReviewWorkSettlement(context, receipt, worker.workId, harness).authority !== worker.authority)
-                refuse("historical_second_reviewer_settlement_changed");
+        const wave = this.#wave;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            wave.assertCustody(context);
+            this.#checks.assertCustody(context);
+            const receipt = this.#registration;
+            if (hybridDigest(readRetainedSecondCorrectedMemoryReviewRegistration(context, receipt.scope, receipt.input_sha256, receipt.check_receipt_sha256)) !== hybridDigest(receipt))
+                refuse("historical_second_registration_changed");
+            if (hybridDigest(this.#wave.registration().firstEffectiveReviewProof(context)) !== hybridDigest(this.#previous))
+                refuse("first_review_history_changed");
+            const harness = runtimeHarness(this.#wave.registration().bundle().execution.work("review").worker);
+            for (const worker of this.#workers)
+                if (readMemoryReviewWorkSettlement(context, receipt, worker.workId, harness).authority !== worker.authority)
+                    refuse("historical_second_reviewer_settlement_changed");
+        });
     }
     revalidate(context) {
         this.#wave.revalidate(context);

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

@@ -6,6 +6,39 @@ import { RetainedExecutionBundle } from "./execution-bundles.js";
 import { publishImmutableInput } from "../storage/immutable-input.js";
 import { readBoundedReleaseFile } from "./release-source.js";
 import { readMemoryInitStartupInput } from "./memory-init-startup-custody.js";
+import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
+import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
+import { readDiagnosticRequest } from "./diagnostic-start.js";
+export function prepareDiagnosticContextsFromRequest(context, bundle, directory) {
+    const scope = bundle.execution.snapshot().scope, flowId = bundle.manifest.flow_id;
+    if (!isDiagnosticFlow(flowId))
+        throw new AppError("diagnostic_context_invalid", "Diagnostic bundle required", 2, { effect: "no_effect" });
+    const request = readDiagnosticRequest(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, flowId });
+    if (!request || request.execution_sha256 !== bundle.execution.sha256)
+        throw new AppError("diagnostic_context_invalid", "Original diagnostic objective required", 2, { effect: "no_effect" });
+    return { ...prepareMemoryContexts(bundle, request.objective, directory, flowId), objective: request.objective };
+}
+export function publishDiagnosticContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
+    if (!isDiagnosticFlow(bundle.manifest.flow_id))
+        throw new AppError("diagnostic_context_invalid", "Diagnostic bundle required", 2, { effect: "no_effect" });
+    return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, bundle.manifest.flow_id);
+}
+/** Original upgrade intake comes from the independently retained storage
+ * selection, including after project publication changes the old tree. */
+export function prepareMemoryUpgradeContextsFromStartup(context, bundle, directory) {
+    if (!(bundle instanceof RetainedExecutionBundle) || bundle.manifest.flow_id !== "mb-upgrade") {
+        throw new AppError("memory_upgrade_context_invalid", "Upgrade contexts require a retained upgrade bundle", 2, { effect: "no_effect" });
+    }
+    const scope = bundle.execution.snapshot().scope;
+    const retained = readUpgradeStorageReadiness(context, { requestId: scope.requestId, projectRoot: scope.projectRoot, workspaceRoot: scope.workspace });
+    if (!retained?.receipt.selection || !retained.selection
+        || retained.selection.payload.execution.sha256 !== bundle.execution.sha256
+        || retained.selection.payload.engine.manifest_sha256 !== bundle.manifest.engine_manifest.sha256) {
+        throw new AppError("memory_upgrade_context_invalid", "Upgrade contexts require the original request selection", 1, { effect: "no_effect" });
+    }
+    const objective = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(Buffer.from(retained.receipt.selection.request_input.intake_base64, "base64"));
+    return { ...prepareMemoryContexts(bundle, objective, directory, "mb-upgrade"), objective };
+}
 /** Public init consumes the independently retained intake, never a newly
  * inferred objective. Historical v1 SDK requests must not invent one. */
 export function prepareMemoryInitContextsFromStartup(context, bundle, directory) {
@@ -24,7 +57,10 @@ export function prepareMemoryInitContextsFromStartup(context, bundle, directory)
 /** Prepare bytes only. Immutable publication and the controller retain their
  * existing ownership; this does not create directories, Sessions or RUNs. */
 export function prepareMemoryInitContexts(bundle, objective, directory) {
-    if (!(bundle instanceof RetainedExecutionBundle) || bundle.manifest.flow_id !== "mb-init"
+    return prepareMemoryContexts(bundle, objective, directory, "mb-init");
+}
+function prepareMemoryContexts(bundle, objective, directory, flowId) {
+    if (!(bundle instanceof RetainedExecutionBundle) || bundle.manifest.flow_id !== flowId
         || typeof objective !== "string" || !objective.trim() || Buffer.byteLength(objective) > 64 * 1024
         || !path.isAbsolute(directory) || path.resolve(directory) !== directory) {
         throw new AppError("memory_init_context_invalid", "Init contexts require a retained memory bundle, bounded objective and absolute directory", 2, { effect: "no_effect" });
@@ -45,7 +81,13 @@ export function prepareMemoryInitContexts(bundle, objective, directory) {
  * their execution authority. The caller supplies an already owned directory
  * and independently retained package digest. Never replaces conflicting files. */
 export function publishMemoryInitContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
-    const prepared = prepareMemoryInitContexts(bundle, objective, directory);
+    return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, "mb-init");
+}
+export function publishMemoryUpgradeContexts(bundle, objective, directory, expectedSha256, expectedOwner) {
+    return publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, "mb-upgrade");
+}
+function publishMemoryContexts(bundle, objective, directory, expectedSha256, expectedOwner, flowId) {
+    const prepared = prepareMemoryContexts(bundle, objective, directory, flowId);
     if (prepared.sha256 !== expectedSha256)
         throw new AppError("memory_init_context_invalid", "Context package selection changed", 1, { effect: "no_effect" });
     const owner = fs.lstatSync(directory);

package/dist/services/memory-init-controller-start.js

@@ -3,13 +3,17 @@ import path from "node:path";
 import { AppError, errorRecord } from "../shared/errors.js";
 import { validateMemoryInitStartupScope, readMemoryInitStartupInput } from "./memory-init-startup-custody.js";
 import { startMemoryInitRun } from "./memory-init-start.js";
+import { startMemoryUpgradeRun } from "./memory-upgrade-start.js";
 import { requireProjectByRoot } from "./projects.js";
 import { readRunStartRequest } from "./run-start-custody.js";
 import { readFlowRunExecutionBundle } from "./runs.js";
 import { requireRun } from "./run-controller-state.js";
 import { prepareRunControllerLaunch } from "./run-controller.js";
-import { prepareMemoryInitContextsFromStartup, publishMemoryInitContexts } from "./memory-init-contexts.js";
+import { prepareMemoryInitContextsFromStartup, publishMemoryInitContexts, prepareMemoryUpgradeContextsFromStartup, publishMemoryUpgradeContexts } from "./memory-init-contexts.js";
 import { parseRuntimeBudget } from "./runtime-budget.js";
+import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
+import { startDiagnosticRun } from "./diagnostic-start.js";
+import { prepareDiagnosticContextsFromRequest, publishDiagnosticContexts } from "./memory-init-contexts.js";
 function refuse(reason) {
     throw new AppError("memory_init_controller_start_invalid", "Init controller requires its exact published startup request", 1, { reason, effect: "no_effect", next_action: "reconcile_exact_request" });
 }
@@ -18,28 +22,42 @@ function refuse(reason) {
  * An existing controller replays before candidate publication, so missing
  * productive inputs are never reconstructed here. No process is launched. */
 export function prepareMemoryInitControllerStart(context, scope) {
+    return prepareMemoryControllerStart(context, scope, "mb-init");
+}
+export function prepareMemoryUpgradeControllerStart(context, scope) {
+    return prepareMemoryControllerStart(context, scope, "mb-upgrade");
+}
+export function prepareDiagnosticControllerStart(context, scope, flowId) {
+    return prepareMemoryControllerStart(context, scope, flowId);
+}
+function prepareMemoryControllerStart(context, scope, flowId) {
     validateMemoryInitStartupScope(scope);
     if (context.db.isOwnedWriteTransaction?.())
         refuse("preparation_outside_writer_required");
     parseRuntimeBudget(context.env.DD_FLOW_RUNTIME_BUDGET);
-    const startup = readMemoryInitStartupInput(context, scope);
-    if (!startup || !["dd-flow/memory-init-startup-input@2", "dd-flow/memory-init-startup-input@3"].includes(startup.payload.schema_id))
-        refuse("retained_objective_required");
+    if (flowId === "mb-init") {
+        const startup = readMemoryInitStartupInput(context, scope);
+        if (!startup || !["dd-flow/memory-init-startup-input@2", "dd-flow/memory-init-startup-input@3"].includes(startup.payload.schema_id))
+            refuse("retained_objective_required");
+    }
     const project = requireProjectByRoot(context, scope.projectRoot);
     const request = readRunStartRequest(context, project.id, scope.requestId);
-    if (!request?.published || request.payload.initial_index.flow_kind !== "mb-init"
+    if (!request?.published || request.payload.initial_index.flow_kind !== flowId
         || request.payload.workspace_root !== scope.workspaceRoot)
         refuse("published_run_required");
     // Restores the exact request and verifies independent SQL/physical root
     // ownership without consulting current canon/profiles or creating a RUN.
-    const started = startMemoryInitRun(context, scope);
+    const started = isDiagnosticFlow(flowId) ? startDiagnosticRun(context, { projectRoot: scope.projectRoot, requestId: scope.requestId, flowId })
+        : flowId === "mb-init" ? startMemoryInitRun(context, scope) : startMemoryUpgradeRun(context, scope);
     const run = requireRun(context, project.id, started.runId);
     const bundle = readFlowRunExecutionBundle(context, { projectRoot: scope.projectRoot, runId: run.id });
     if (!bundle || bundle.sha256 !== started.bundleSha256)
         refuse("retained_bundle_required");
     if (bundle.execution.settings.execution !== "managed")
         refuse("managed_execution_required");
-    const contexts = prepareMemoryInitContextsFromStartup(context, bundle, run.run_root);
+    const contexts = isDiagnosticFlow(flowId) ? prepareDiagnosticContextsFromRequest(context, bundle, run.run_root)
+        : flowId === "mb-init" ? prepareMemoryInitContextsFromStartup(context, bundle, run.run_root)
+            : prepareMemoryUpgradeContextsFromStartup(context, bundle, run.run_root);
     const input = { projectRoot: scope.projectRoot, runId: run.id, requestId: scope.requestId,
         contextFile: contexts.file, contextSha256: contexts.sha256 };
     const controllers = context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='run_controllers'")
@@ -73,7 +91,8 @@ export function prepareMemoryInitControllerStart(context, scope) {
     });
     if (!rootOwner || !Number.isSafeInteger(rootOwner.dev) || !Number.isSafeInteger(rootOwner.ino))
         refuse("root_owner_changed");
-    publishMemoryInitContexts(bundle, contexts.objective, run.run_root, contexts.sha256, rootOwner);
+    const publish = isDiagnosticFlow(flowId) ? publishDiagnosticContexts : flowId === "mb-init" ? publishMemoryInitContexts : publishMemoryUpgradeContexts;
+    publish(bundle, contexts.objective, run.run_root, contexts.sha256, rootOwner);
     try {
         return { input, prepared: prepareRunControllerLaunch(context, input) };
     }