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

package/dist/services/memory-composition-registration.js

@@ -23,7 +23,7 @@ function readReceipt(context, scope) {
             || receipt.run_id !== scope.run_id || hybridDigest(receipt.scope) !== requestSha256 || receipt.result_schema !== workerSchema
             || [receipt.batch_sha256, receipt.compose_result_sha256, receipt.input_sha256, receipt.execution_sha256].some(hash => typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))
             || typeof receipt.result_base64 !== "string" || !receipt.work_ids || Array.isArray(receipt.work_ids)
-            || typeof receipt.work_ids !== "object" || !Object.keys(receipt.work_ids).length || Object.keys(receipt.work_ids).length > 4096
+            || typeof receipt.work_ids !== "object" || !Object.keys(receipt.work_ids).length && scope.stage !== "upgrade" || Object.keys(receipt.work_ids).length > 4096
             || Object.values(receipt.work_ids).some(id => typeof id !== "string")
             || new Set(Object.values(receipt.work_ids)).size !== Object.keys(receipt.work_ids).length)
             refuse("foreign_receipt_binding");
@@ -37,6 +37,15 @@ function readReceipt(context, scope) {
                 || hybridDigest(custody.work_ids) !== hybridDigest(receipt.work_ids) || hybridDigest(custody.scope) !== requestSha256)
                 refuse("changed_work_custody");
         }
+        if (!Object.keys(receipt.work_ids).length) {
+            // No invented worker for deterministic-only upgrade. Its empty batch
+            // still has the same independent allocator receipt and active scope.
+            const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type='work.batch_registration' AND json_extract(payload_json,'$.request_sha256')=? LIMIT 2", [scope.project_id, requestSha256]);
+            if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 32768 || hybridDigest(JSON.parse(rows[0].payload_json)) !== hybridDigest({
+                run_id: scope.run_id, scope, request_sha256: requestSha256, batch_sha256: hybridDigest([]), work_ids: {}, work_sha256: {}
+            }) || receipt.batch_sha256 !== hybridDigest([]))
+                refuse("changed_empty_batch_custody");
+        }
         return receipt;
     }
     catch (error) {
@@ -85,24 +94,28 @@ export function selectMemoryCompositionRegistration(context, scope) {
 export function registerMemoryComposition(context, input, assertHandlerCustody) {
     if (!(input.composition instanceof PreparedMemoryStageResult))
         refuse("foreign_prepared_result");
+    const stage = input.composition.authoringStage();
     const value = input.composition.compositionBatch({ ...input.binding, resultSchema: workerSchema });
     const bytes = input.composition.bytes();
-    const batchInput = { parentWorkId: input.parentWorkId, requestKey: input.requestKey, stage: "compose", value };
-    const prepared = prepareWorkBatch(context, batchInput);
+    const batchInput = { parentWorkId: input.parentWorkId, requestKey: input.requestKey, stage, value };
+    // Generic CLI batches remain non-empty. The admitted upgrade graph alone
+    // may register zero agent tasks; addWorkBatch still checks parent/run/stage
+    // and records exact batch custody in the existing writer transaction.
+    const prepared = stage === "upgrade" && !value.works.length ? [] : prepareWorkBatch(context, batchInput);
     return context.db.writeTransaction(() => {
         assertHandlerCustody?.(context);
         const parent = context.db.get("SELECT project_id, run_id FROM works WHERE work_id = ?", [input.parentWorkId]);
         if (!parent || parent.run_id !== input.binding.runId)
             refuse("foreign_coordinator");
-        const scope = { ...stageGraphScope(context, parent.project_id, parent.run_id, "compose"),
-            stage: "compose", parent_work_id: input.parentWorkId, request_key: input.requestKey };
+        const scope = { ...stageGraphScope(context, parent.project_id, parent.run_id, stage),
+            stage, parent_work_id: input.parentWorkId, request_key: input.requestKey };
         // One immutable blueprint per coordinator/attempt. A different request key
         // cannot create another productive graph or bypass a lost original receipt.
-        const originals = context.db.all("SELECT json_extract(payload_json,'$.request_sha256') AS request_sha256 FROM audit_events WHERE project_id=? AND event_type='memory.composition_registration' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.stage')='compose' AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.cycle')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? LIMIT 2", [scope.project_id, scope.run_id, scope.attempt, scope.cycle, scope.parent_work_id]);
+        const originals = context.db.all("SELECT json_extract(payload_json,'$.request_sha256') AS request_sha256 FROM audit_events WHERE project_id=? AND event_type='memory.composition_registration' AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.stage')=? AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.cycle')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? LIMIT 2", [scope.project_id, scope.run_id, stage, scope.attempt, scope.cycle, scope.parent_work_id]);
         if (originals.length > 1 || originals.length === 1 && originals[0].request_sha256 !== hybridDigest(scope))
             refuse("original_composition_already_registered");
         const prior = readReceipt(context, scope);
-        if (!prior && context.db.get("SELECT 1 FROM works w JOIN stage_work_memberships m ON m.work_id=w.work_id AND m.project_id=w.project_id AND m.run_id=w.run_id WHERE w.project_id=? AND w.run_id=? AND w.parent_work_id=? AND w.result_schema=? AND m.stage='compose' AND m.attempt=? AND m.cycle=? LIMIT 1", [scope.project_id, scope.run_id, scope.parent_work_id, workerSchema, scope.attempt, scope.cycle]))
+        if (!prior && context.db.get("SELECT 1 FROM works w JOIN stage_work_memberships m ON m.work_id=w.work_id AND m.project_id=w.project_id AND m.run_id=w.run_id WHERE w.project_id=? AND w.run_id=? AND w.parent_work_id=? AND w.result_schema=? AND m.stage=? AND m.attempt=? AND m.cycle=? LIMIT 1", [scope.project_id, scope.run_id, scope.parent_work_id, workerSchema, stage, scope.attempt, scope.cycle]))
             refuse("composition_receipt_missing");
         if (prior && (prior.compose_result_sha256 !== input.composition.sha256 || prior.batch_sha256 !== hybridDigest(value.works)
             || prior.input_sha256 !== input.binding.inputSha256 || prior.execution_sha256 !== input.binding.executionSha256))
@@ -133,10 +146,12 @@ export function readRegisteredMemoryComposition(context, input) {
     const receipt = readReceipt(context, input.scope);
     if (!receipt)
         refuse("composition_receipt_missing");
-    if (input.binding.runId !== input.scope.run_id || input.binding.stage !== "compose"
+    if (input.binding.runId !== input.scope.run_id || input.binding.stage !== input.scope.stage
         || input.binding.inputSha256 !== receipt.input_sha256 || input.binding.executionSha256 !== receipt.execution_sha256)
         refuse("foreign_restore_binding");
     const result = PreparedMemoryStageResult.prepare(Buffer.from(receipt.result_base64, "base64"), input.flow, input.binding);
+    if (result.authoringStage() !== input.scope.stage)
+        refuse("foreign_restore_binding");
     const batch = result.compositionBatch({ runId: input.binding.runId, inputSha256: receipt.input_sha256,
         executionSha256: receipt.execution_sha256, resultSchema: workerSchema });
     if (result.sha256 !== receipt.compose_result_sha256 || hybridDigest(batch.works) !== receipt.batch_sha256

package/dist/services/memory-composition-work-custody.js

@@ -46,10 +46,11 @@ export class PreparedRegisteredMemoryCompositionWorkResult {
      */
     static prepareFromStageCustody(context, input, engine, binding) {
         const custody = readWorkBatchCustody(context, binding.workId);
+        const stage = binding.flow.descriptor.id === "mb-init" ? "compose" : binding.flow.descriptor.id === "mb-upgrade" ? "upgrade" : refuse();
         const selected = binding.bundle ? PreparedMemoryResultBinding.prepareRegisteredComposition(context, { ...binding, bundle: binding.bundle,
-            registrationScope: { project_id: binding.projectId, run_id: binding.runId, stage: "compose", attempt: custody.scope.attempt, cycle: custody.scope.cycle,
+            registrationScope: { project_id: binding.projectId, run_id: binding.runId, stage, attempt: custody.scope.attempt, cycle: custody.scope.cycle,
                 parent_work_id: binding.coordinatorWorkId, request_key: binding.requestKey } })
-            : binding.sources ? PreparedMemoryResultBinding.prepare(context, { ...binding, sources: binding.sources, stage: "compose" }) : refuse();
+            : binding.sources ? PreparedMemoryResultBinding.prepare(context, { ...binding, sources: binding.sources, stage }) : refuse();
         const prepared = this.prepareFromRegistration(context, input, engine, { ...binding, resultBinding: selected.binding() });
         prepared.#stageBinding = selected;
         prepared.assertCustody(context);
@@ -57,11 +58,12 @@ export class PreparedRegisteredMemoryCompositionWorkResult {
     }
     static prepareFromRegistration(context, input, engine, binding) {
         const custody = readWorkBatchCustody(context, binding.workId);
-        if (custody.scope.stage !== "compose" || custody.scope.parent_work_id !== binding.coordinatorWorkId
+        const stage = binding.flow.descriptor.id === "mb-init" ? "compose" : binding.flow.descriptor.id === "mb-upgrade" ? "upgrade" : refuse();
+        if (custody.scope.stage !== stage || custody.scope.parent_work_id !== binding.coordinatorWorkId
             || custody.scope.request_key !== binding.requestKey || !binding.resultBinding.executionSha256)
             refuse();
         const scope = { project_id: custody.scope.project_id, run_id: custody.scope.run_id,
-            stage: "compose", attempt: custody.scope.attempt, cycle: custody.scope.cycle,
+            stage, attempt: custody.scope.attempt, cycle: custody.scope.cycle,
             parent_work_id: binding.coordinatorWorkId, request_key: binding.requestKey };
         const registrationSha256 = memoryCompositionRegistrationDigest(context, scope);
         const composition = readRegisteredMemoryComposition(context, { scope, flow: binding.flow, binding: binding.resultBinding });
@@ -75,7 +77,7 @@ export class PreparedRegisteredMemoryCompositionWorkResult {
     static prepare(context, input, engine, binding) {
         const custody = readWorkBatchCustody(context, binding.workId);
         if (!(binding.composition instanceof PreparedMemoryStageResult) || binding.composition.sha256 !== binding.compositionSha256
-            || custody.scope.run_id !== binding.runId || custody.scope.stage !== "compose"
+            || custody.scope.run_id !== binding.runId || custody.scope.stage !== binding.composition.authoringStage()
             || custody.scope.parent_work_id !== binding.coordinatorWorkId || custody.scope.request_key !== binding.requestKey)
             refuse();
         const batch = binding.composition.compositionBatch({ ...binding, resultSchema: "dd-flow/memory-composition-work-result@1" });
@@ -116,11 +118,14 @@ export class PreparedRegisteredMemoryCompositionWorkResult {
         const scope = this.#custody.scope;
         const run = context.db.get("SELECT index_json FROM runs WHERE project_id = ? AND id = ?", [scope.project_id, scope.run_id]);
         const index = run ? JSON.parse(run.index_json) : null;
+        const authoringStage = scope.stage;
+        if (!["compose", "upgrade"].includes(authoringStage))
+            refuse();
         assertRunBundleSqlAuthority(context, { projectId: scope.project_id, runId: scope.run_id }, index?.execution_bundle);
-        const stage = index?.stage_runs?.findLast((item) => item.stage === "compose" && item.status === "running");
-        if (!this.#registration || !this.#stageBinding || index?.current_stage !== "compose" || !stage || (stage.attempt ?? "try-001") !== scope.attempt
-            || !stageWorkIds(context, scope.project_id, scope.run_id, "compose").has(this.workId)
-            || !stageWorkIds(context, scope.project_id, scope.run_id, "compose").has(scope.parent_work_id)
+        const stage = index?.stage_runs?.findLast((item) => item.stage === authoringStage && item.status === "running");
+        if (!this.#registration || !this.#stageBinding || index?.current_stage !== authoringStage || !stage || (stage.attempt ?? "try-001") !== scope.attempt
+            || !stageWorkIds(context, scope.project_id, scope.run_id, authoringStage).has(this.workId)
+            || !stageWorkIds(context, scope.project_id, scope.run_id, authoringStage).has(scope.parent_work_id)
             || !context.db.get("SELECT 1 FROM work_sessions WHERE id = ? AND work_id = ? AND session_id = ? AND status = 'running'", [workSessionId, this.workId, sessionId])
             || !context.db.get("SELECT 1 FROM works WHERE work_id = ? AND project_id = ? AND run_id = ? AND status = 'running'", [scope.parent_work_id, scope.project_id, scope.run_id])
             || !context.db.get("SELECT 1 FROM sessions s JOIN runs r ON r.project_id = s.project_id AND r.id = s.run_id WHERE s.project_id = ? AND s.session_id = ? AND s.run_id = ? AND s.worker_id = ? AND s.harness = ? AND s.status = 'active' AND s.current_stage = 'work' AND s.project_root = r.project_root AND s.workspace_path = r.workspace_root", [scope.project_id, sessionId, scope.run_id, this.workId, this.#harness])) {

package/dist/services/memory-composition-work-results.js

@@ -5,7 +5,7 @@ import { AdmittedFrozenEngine } from "./frozen-engine.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedMemoryStageResult, memorySourceKey } from "./memory-stage-results.js";
 import { ObservedMemorySources } from "./memory-source-observations.js";
-import { memoryCompositionOutputAllowed } from "./memory-composition-graph.js";
+import { parseMemoryWorkResultProposal } from "./memory-work-result-json.js";
 const schemaId = "dd-flow/memory-composition-work-result@1";
 function refuse(reason) {
     throw new AppError("memory_composition_work_result_invalid", "Composition Work result lacks assigned output proof", 2, { reason, phase: "prepare", effect: "no_effect" });
@@ -20,7 +20,7 @@ export function validateMemoryCompositionWorkResult(input, engine, binding) {
             || !(engine instanceof AdmittedFrozenEngine) || !(binding.composition instanceof PreparedMemoryStageResult)
             || binding.composition.sha256 !== binding.compositionSha256)
             refuse("foreign_preparation_binding");
-        const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input));
+        const value = parseMemoryWorkResultProposal(input, "memory_composition_work_result_invalid");
         const schema = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(engine.schema("memory-composition-work-result")));
         if (schema.$id !== schemaId || !new Ajv2020({ strict: true, validateFormats: false }).compile(schema)(value))
             refuse("invalid_result_schema");
@@ -43,7 +43,7 @@ export function validateMemoryCompositionWorkResult(input, engine, binding) {
                     refuse("unsafe_artifact_path");
                 if (!packet.write_scopes.some(scope => scope.root === artifact.root && (logical === scope.path || logical.startsWith(`${scope.path}/`))))
                     refuse("artifact_outside_write_scope");
-                if (!memoryCompositionOutputAllowed(logical))
+                if (!binding.composition.allowsCompositionOutput(artifact.root, logical))
                     refuse("private_composition_artifact");
                 const alias = memorySourceKey(artifact.root, logical.normalize("NFC").toLowerCase());
                 const identity = hybridDigest({ path: logical, sha256: artifact.sha256 });
@@ -80,6 +80,18 @@ export class PreparedMemoryCompositionWorkResult {
             for (const artifact of artifacts) {
                 selected.set(memorySourceKey(artifact.root, artifact.path), { root: artifact.root, path: artifact.path });
             }
+            // Upgrade scopes are exact admitted file paths, not init-style output
+            // directories. Retain their output hashes while this Work is still
+            // correctable; publication cannot repair an already settled omission.
+            if (binding.composition.authoringStage() === "upgrade") {
+                const work = binding.composition.compositionBatch({ ...binding, resultSchema: schemaId }).works.find(item => item.key === binding.workKey);
+                const missing = work.payload.memory_composition.write_scopes
+                    .filter(scope => scope.root === "workspace" && !selected.has(memorySourceKey(scope.root, scope.path)))
+                    .map(scope => scope.path);
+                if (missing.length)
+                    throw new AppError("memory_composition_work_result_invalid", "Include every assigned upgrade workspace file with its current hash in this Work result; correct only the result proposal, not settled peer Work or retained inputs", 2, { reason: "missing_workspace_outputs", phase: "prepare", effect: "no_effect", recoverable: true,
+                        missing_count: missing.length, missing_paths: missing.slice(0, 32), result_sha256: createHash("sha256").update(bytes).digest("hex") });
+            }
             const observed = ObservedMemorySources.capture(binding.roots, [...selected.values()]), hashes = observed.hashes();
             if (artifacts.some(artifact => hashes.get(memorySourceKey(artifact.root, artifact.path)) !== artifact.sha256))
                 refuse("changed_artifact_bytes");

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

@@ -1,6 +1,7 @@
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { memoryReviewWorkerSchema } from "./memory-review-registration.js";
+import { memoryReviewWaveByteLimit } from "./memory-review-limits.js";
 /** Payload projection only. Fresh check, registered input/copy/Session and
  * independent Work settlement are not supplied by a coordinator's JSON. */
 export function memoryCorrectedReviewBatch(view) {
@@ -10,20 +11,26 @@ export function memoryCorrectedReviewBatch(view) {
         throw new AppError("memory_corrected_review_batch_invalid", "Corrected reviewer batch lacks bounded current assignments", 2, { effect: "no_effect" });
     }
     let total = 0;
+    const inputSha256 = hybridDigest(view);
     return { works: view.assignments.map((assignment, index) => {
             const key = `review-${String(index + 1).padStart(3, "0")}`;
+            const inputPaths = view.upgrade_baseline ? new Set(assignment.inputs.map(ref => `${ref.root}\0${ref.path}`)) : null;
             const packet = { schema_id: "dd-flow/memory-review-work-packet@2", run_id: view.scope.run_id,
                 stage: "review", wave: view.wave, key, unit: structuredClone(assignment.unit), unit_inputs: structuredClone(assignment.inputs),
                 original_unit_sha256: assignment.original_unit_sha256, deleted_references: structuredClone(assignment.deleted_references),
                 completed_correction_sha256: view.completed_correction_sha256, repairs: structuredClone(view.repairs),
-                review_input_sha256: hybridDigest(view), result_schema: memoryReviewWorkerSchema,
-                instruction: structuredClone(view.instruction) };
+                review_input_sha256: inputSha256, result_schema: memoryReviewWorkerSchema,
+                instruction: structuredClone(view.instruction),
+                ...(view.upgrade_baseline ? {
+                    historical_inputs: view.upgrade_baseline.entries.filter(entry => inputPaths.has(`${entry.retained.root}\0${entry.retained.path}`)),
+                    preservation_invariants: (view.preservation_invariants ?? []).filter(item => item.unit_id === assignment.unit.id)
+                } : {}) };
             const work = { key, task: `Independently review the assigned knowledge unit ${JSON.stringify(assignment.unit.id)}. Read the frozen review instruction in memory_review as review criteria, not permission to coordinate or repair. Check grounding, evidence, coverage and cross-file consistency using the registered wave inputs. Assigned unit.evidence may retain historical source versions; cite those exact versions only as historical context, never as bytes read from or current in this copy. Direct assessment and findings must still cite the assigned current unit.artifacts/unit_inputs. Do not edit project documents, allocate Work or repair findings. Report concrete material defects with unit/source evidence; do not block on taste. Return only the assigned memory-review-work-result JSON; do not claim other units or Stage completion.`,
                 depends_on: [], launch_policy: "fresh_agent_required", result_schema: memoryReviewWorkerSchema,
                 payload: { kind: "memory-review", read_only: true, memory_review: { ...packet, packet_sha256: hybridDigest(packet) } } };
             const size = Buffer.byteLength(JSON.stringify(work));
             total += size;
-            if (size > 1024 * 1024 || total > 64 * 1024 * 1024)
+            if (size > 1024 * 1024 || total > memoryReviewWaveByteLimit)
                 throw new AppError("memory_corrected_review_batch_invalid", "Corrected reviewer batch exceeds its bound", 2, { effect: "no_effect" });
             return work;
         }) };

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

@@ -1,6 +1,7 @@
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { memoryReviewWaveProjection } from "./memory-review-acceptance.js";
+import { isCompletedMemoryRepairClaim } from "./memory-repair-work-results.js";
 function refuse(reason) {
     throw new AppError("memory_corrected_review_findings_invalid", "Finding resolution lacks causal repair and independent re-review references", 2, { reason, effect: "no_effect" });
 }
@@ -71,12 +72,13 @@ export function correctedMemoryReviewFindings(input) {
     const previousIds = new Set(previous.findings.map(finding => finding.id)), claims = new Map();
     for (const repair of input.repairs) {
         const reference = ref(repair.reference);
-        if (repair.result.outcome !== "accepted" || !repair.result.changes.length || !repair.unit_ids.length)
+        if (!isCompletedMemoryRepairClaim(repair.result) || !repair.unit_ids.length)
             refuse("unsettled_repair_claim");
         for (const resolution of repair.result.resolutions) {
             const finding = previous.findings.find(finding => finding.id === resolution.finding_id);
             if (!finding || finding.status !== "open" || !repair.unit_ids.includes(finding.unit_id) || claims.has(finding.id)
-                || !resolution.delta_paths.length || resolution.delta_paths.some(path => !repair.result.changes.some(change => change.path === path && change.before_sha256 !== change.after_sha256)))
+                || repair.result.outcome !== "reconciled" && !resolution.delta_paths.length
+                || resolution.delta_paths.some(path => !repair.result.changes.some(change => change.path === path && change.before_sha256 !== change.after_sha256)))
                 refuse("foreign_or_noncausal_resolution");
             claims.set(finding.id, { repair, reference });
         }

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

@@ -1,6 +1,7 @@
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedCompletedMemoryCorrectionWave } from "./memory-completed-correction-wave.js";
+import { isCompletedMemoryRepairClaim } from "./memory-repair-work-results.js";
 import { ObservedMemorySources } from "./memory-source-observations.js";
 import { memorySourceKey } from "./memory-stage-results.js";
 import { assertPreparedRunBundleSqlAuthority } from "./runs.js";
@@ -9,6 +10,7 @@ import { RetainedExecutionBundle } from "./execution-bundles.js";
 import { PreparedRetainedMemoryReviewAuthority } from "./memory-retained-review-authority.js";
 import { PreparedRetainedMemoryReviewResults } from "./memory-retained-review-results.js";
 import { PreparedRegisteredMemoryCorrections } from "./memory-repair-registration.js";
+import { memoryReviewViewWithinLimit } from "./memory-review-limits.js";
 const token = Symbol("corrected-memory-review-inputs");
 function refuse(reason) {
     throw new AppError("memory_corrected_review_input_invalid", "Re-review inputs lack settled corrections and current source custody", 2, { reason, effect: "no_effect" });
@@ -46,9 +48,8 @@ export function correctedMemoryReviewAssignments(input) {
     const finalProof = new Map();
     for (const repair of input.repairs) {
         reference(repair.reference.path, repair.reference.sha256, "run");
-        if (repair.result.outcome !== "accepted" || !Array.isArray(repair.unit_ids) || !repair.unit_ids.length
-            || repair.unit_ids.some((id) => !input.units.some(unit => unit.id === id && unit.applicability === "applicable"))
-            || !Array.isArray(repair.result.changes) || !repair.result.changes.length)
+        if (!isCompletedMemoryRepairClaim(repair.result) || !Array.isArray(repair.unit_ids) || !repair.unit_ids.length
+            || repair.unit_ids.some((id) => !input.units.some(unit => unit.id === id && unit.applicability === "applicable")))
             refuse("invalid_repair_projection");
         for (const change of repair.result.changes) {
             reference(change.path, change.after_sha256 ?? change.before_sha256);
@@ -97,6 +98,9 @@ export function correctedMemoryReviewAssignments(input) {
                     unit.artifacts.push({ ...current });
             }
         const inputs = new Map();
+        for (const ref of input.initialAssignments?.find(item => item.unit.id === original.id)?.inputs ?? [])
+            if (ref.root === "run" && /^upgrade-baseline-[a-f0-9]{64}\.bin$/.test(ref.path))
+                inputs.set(memorySourceKey(ref.root, ref.path), { ...ref });
         for (const ref of [...unit.evidence, ...unit.artifacts, ...input.repairs.map(repair => reference(repair.reference.path, repair.reference.sha256, "run"))]) {
             const physical = reference(ref.root === "canon" ? `.memory-bank/${ref.path}` : ref.path, ref.sha256, ref.root === "run" ? "run" : "workspace");
             const key = memorySourceKey(physical.root, physical.path), prior = inputs.get(key);
@@ -151,7 +155,7 @@ export class PreparedCorrectedMemoryReviewInputs {
         return prepared;
     }
     static prepareFromBundle(context, input) {
-        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");
         const original = PreparedRetainedMemoryReviewAuthority.prepare(context, input.scope, input.bundle);
         const review = PreparedRetainedMemoryReviewResults.prepare(context, original);
@@ -203,8 +207,9 @@ function prepareView(wave) {
         completed_correction_sha256: wave.sha256, original_review_sha256: review.sha256,
         source_policy: "review-inputs@1", source_sha256: source, base: original.base, run_inputs: runInputs,
         unit_inventory: structuredClone(original.unit_inventory), affected_unit_ids: wave.affectedUnitIds(), assignments,
+        ...(original.upgrade_baseline ? { upgrade_baseline: structuredClone(original.upgrade_baseline), preservation_invariants: structuredClone(original.preservation_invariants ?? []) } : {}),
         instruction: structuredClone(original.instruction), repairs: repairs.map(repair => ({ work_id: repair.work_id, authority_sha256: repair.authority_sha256, result: repair.reference })) };
-    if (Buffer.byteLength(JSON.stringify(view)) > 1024 * 1024)
+    if (!memoryReviewViewWithinLimit(view))
         refuse("unbounded_corrected_view");
     return view;
 }

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

@@ -1,3 +1,4 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { appendAudit } from "./audit.js";
 import { hybridDigest } from "./hybrid-contracts.js";
@@ -81,7 +82,7 @@ export class PreparedMemoryCorrectedReviewReceipt {
             refuse("receipt_readback_failed");
     }
 }
-function acceptedReceipt(context, scope) {
+function acceptedReceipt(context, scope, flowId) {
     const data = readAcceptedStageData(context, { ...scope, stage: "review" }), rows = records(context, scope);
     if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
         refuse("accepted_receipt_missing");
@@ -99,7 +100,7 @@ function acceptedReceipt(context, scope) {
             || !/^[a-f0-9]{64}$/.test(retained.first_review_proof_sha256)))
         || typeof retained.corrected_input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(retained.corrected_input_sha256)
         || typeof retained.check_receipt_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(retained.check_receipt_sha256)
-        || data.data_schema_id !== "dd-flow/mb-init-review-result@1" || retained.result_sha256 !== data.result.sha256
+        || data.data_schema_id !== (flowId === "mb-upgrade" ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-review-result@1") || retained.result_sha256 !== data.result.sha256
         || retained.input_sha256 !== data.input_sha256)
         refuse("accepted_receipt_changed");
     return { data, retained, authority: hybridDigest({ data: data.authority_sha256, receipt: retained }) };
@@ -109,24 +110,27 @@ function acceptedReceipt(context, scope) {
  * commit: generic settlement restores it; reviewers/checks/repairs may not be
  * substituted or re-admitted from today's project policy or documents. */
 export class PreparedAcceptedMemoryCorrectedReview {
+    #custodyKey = {};
     #scope;
     #authority;
     #history;
-    constructor(key, scope, authority, history) {
+    #flowId;
+    constructor(key, scope, authority, history, flowId) {
         if (key !== token)
             refuse("receipt_token_required");
         this.#scope = { ...scope };
         this.#authority = authority;
         this.#history = history;
+        this.#flowId = flowId;
         Object.freeze(this);
     }
     static prepare(context, input) {
-        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)
             || !(input.bytes instanceof Uint8Array) || !input.bytes.length || input.bytes.length > 1024 * 1024)
             refuse("registered_memory_result_required");
         if (context.db.isOwnedWriteTransaction?.())
             refuse("preparation_outside_writer_required");
-        const accepted = context.db.readSnapshot(() => acceptedReceipt(context, input.scope));
+        const accepted = context.db.readSnapshot(() => acceptedReceipt(context, input.scope, input.bundle.descriptor.descriptor.id));
         if (!accepted.data.bytes.equals(Buffer.from(input.bytes)))
             refuse("accepted_result_bytes_changed");
         const hashes = { correctedInputSha256: accepted.retained.corrected_input_sha256, checkReceiptSha256: accepted.retained.check_receipt_sha256 };
@@ -151,20 +155,24 @@ export class PreparedAcceptedMemoryCorrectedReview {
         const schema = JSON.parse(input.bundle.descriptor.stageBlob("review", "result_schema").toString("utf8"));
         if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(value))
             refuse("accepted_result_schema_changed");
-        const prepared = new PreparedAcceptedMemoryCorrectedReview(token, input.scope, accepted.authority, history);
+        const prepared = new PreparedAcceptedMemoryCorrectedReview(token, input.scope, accepted.authority, history, input.bundle.descriptor.descriptor.id);
         prepared.revalidate(context);
         return prepared;
     }
     assertCustody(context) {
-        this.#history.assertCustody(context);
-        if (acceptedReceipt(context, this.#scope).authority !== this.#authority)
-            refuse("accepted_review_custody_changed");
+        const history = this.#history;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            history.assertCustody(context);
+            if (acceptedReceipt(context, this.#scope, this.#flowId).authority !== this.#authority)
+                refuse("accepted_review_custody_changed");
+        });
     }
     /** Final wave inputs selected by the independently accepted receipt. */
     reviewedSources(context) {
         this.assertCustody(context);
         return this.#history.retainedInputView().run_inputs;
     }
+    settledDocumentBaseline(context) { this.assertCustody(context); return this.#history.settledDocumentBaseline(); }
     finalChecks(context) { this.assertCustody(context); return this.#history.finalChecks(context); }
     revalidate(context) { this.#history.revalidate(context); this.assertCustody(context); }
 }

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

@@ -6,6 +6,7 @@ import { isMemoryCorrectionInputOwner } from "./memory-correction-input-owner.js
 import { PreparedMemoryCorrectionCheckReceipt } from "./memory-correction-check-receipt.js";
 import { memoryCorrectedReviewBatch } from "./memory-corrected-review-batch.js";
 import { addWorkBatch, prepareWorkBatch, readWorkBatchCustody } from "./work-registry.js";
+import { memoryReviewRegistrationByteLimit } from "./memory-review-limits.js";
 const token = Symbol("registered-corrected-memory-review");
 const event = "memory.corrected_review_registration";
 function refuse(reason) {
@@ -40,7 +41,7 @@ function readRetainedRegistration(context, scope, inputSha256, checkReceiptSha25
     const rows = context.db.all("SELECT payload_json FROM audit_events WHERE project_id=? AND event_type=? AND json_extract(payload_json,'$.run_id')=? AND json_extract(payload_json,'$.scope.attempt')=? AND json_extract(payload_json,'$.scope.parent_work_id')=? AND json_extract(payload_json,'$.wave')=? LIMIT 2", [scope.project_id, event, scope.run_id, scope.attempt, scope.parent_work_id, wave]);
     if (!rows.length)
         return null;
-    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > 2 * 1024 * 1024)
+    if (rows.length !== 1 || Buffer.byteLength(rows[0].payload_json) > memoryReviewRegistrationByteLimit)
         refuse("ambiguous_or_unbounded_registration");
     let receipt;
     try {
@@ -171,7 +172,7 @@ export function registerCorrectedMemoryReview(context, inputs, checks) {
                 refuse("review_registration_missing");
             const receipt = { schema_id: "dd-flow/memory-corrected-review-registration@1", run_id: scope.run_id, scope: view.scope, wave: view.wave,
                 input_sha256: inputs.sha256, view, check_receipt_sha256: checks.sha256, batch_sha256: hybridDigest(batch.works), work_ids: ids };
-            if (Buffer.byteLength(JSON.stringify(receipt)) > 2 * 1024 * 1024)
+            if (Buffer.byteLength(JSON.stringify(receipt)) > memoryReviewRegistrationByteLimit)
                 refuse("unbounded_registration");
             appendAudit(context, { projectId: scope.project_id, eventType: event, payload: receipt });
         }

package/dist/services/memory-correction-check-receipt.js

@@ -65,7 +65,7 @@ export class PreparedMemoryCorrectionCheckReceipt {
         evidence.assertOwner({ projectId: view.scope.project_id, runId: view.scope.run_id, scope: "aggregate" });
         const receipt = { schema_id: "dd-flow/memory-correction-checks@1", project_id: view.scope.project_id, run_id: view.scope.run_id,
             wave: view.wave, review_input_sha256: view.scope.input_sha256, corrected_input_sha256: corrected.sha256,
-            completed_correction_sha256: view.completed_correction_sha256, profile_sha256: corrected.verificationProfileHash(context),
+            completed_correction_sha256: view.completed_correction_sha256, profile_sha256: policy.profileHash(),
             declarations_sha256: hybridDigest(policy.declarations()), checks: evidence.retainedReferences(context) };
         if (!receipt.checks.length || receipt.checks.length > 4096 || Buffer.byteLength(JSON.stringify(receipt)) > 2 * 1024 * 1024)
             refuse("unbounded_check_receipt");
@@ -81,7 +81,8 @@ export class PreparedMemoryCorrectionCheckReceipt {
             refuse("prepared_check_owners_required");
         if (context.db.isOwnedWriteTransaction?.())
             refuse("preparation_outside_writer_required");
-        if (!context.db.readSnapshot(() => stored(context, corrected))) {
+        const existing = context.db.readSnapshot(() => stored(context, corrected));
+        if (!existing) {
             const view = corrected.value(), projectRoot = corrected.bundle().execution.snapshot().scope.projectRoot;
             const args = ["--run", view.scope.run_id, "--project-root", projectRoot, "--wave", String(view.wave), "--json"];
             throw new AppError("memory_correction_checks_invalid", "Correction checks have not been registered for the settled corrected view", 2, { reason: "registered_check_receipt_required", phase: "prepare", effect: "no_effect", recoverable: true,
@@ -90,7 +91,22 @@ export class PreparedMemoryCorrectionCheckReceipt {
         const bundle = corrected.bundle(), scope = corrected.value().scope;
         const policy = PreparedMemoryVerificationChecks.prepare(context, { projectId: scope.project_id, runId: scope.run_id,
             execution: bundle.execution, flow: bundle.descriptor, corrected });
-        return PreparedMemoryCorrectionCheckReceipt.prepare(context, corrected, policy);
+        // Registered execution belongs to its original environment, not the
+        // controller/reviewer's current shell. Keep exact current document and
+        // policy custody, then restore the sealed execution instead of selecting
+        // fresh evidence using the observer's environment.
+        const view = corrected.value(), receipt = historicalReceipt(context, { projectId: scope.project_id, runId: scope.run_id,
+            wave: view.wave, receiptSha256: hybridDigest(existing), correctedInputSha256: corrected.sha256 });
+        const expected = { schema_id: "dd-flow/memory-correction-checks@1", project_id: scope.project_id, run_id: scope.run_id,
+            wave: view.wave, review_input_sha256: scope.input_sha256, corrected_input_sha256: corrected.sha256,
+            completed_correction_sha256: view.completed_correction_sha256, profile_sha256: policy.profileHash(),
+            declarations_sha256: hybridDigest(policy.declarations()), checks: receipt.checks };
+        if (hybridDigest(receipt) !== hybridDigest(expected))
+            refuse("registered_check_receipt_changed");
+        const evidence = PreparedRetainedCheckEvidence.prepare(context, { projectId: scope.project_id, runId: scope.run_id, references: receipt.checks });
+        const prepared = new PreparedMemoryCorrectionCheckReceipt(token, corrected, policy, evidence, receipt, true);
+        prepared.revalidate(context);
+        return prepared;
     }
     value() {
         return structuredClone(this.#receipt);
@@ -111,7 +127,7 @@ export class PreparedMemoryCorrectionCheckReceipt {
         const existing = stored(context, this.#corrected);
         if ((this.#registered && !existing) || (existing && hybridDigest(existing) !== this.sha256))
             refuse("registered_check_receipt_changed");
-        if (hybridDigest(this.#evidence.retainedReferences(context)) !== hybridDigest(this.#receipt.checks))
+        if ("retainedReferences" in this.#evidence && hybridDigest(this.#evidence.retainedReferences(context)) !== hybridDigest(this.#receipt.checks))
             refuse("selected_check_evidence_changed");
     }
     revalidate(context) {

package/dist/services/memory-custody-snapshot.js

@@ -0,0 +1,36 @@
+import { AppError } from "../shared/errors.js";
+const snapshots = new WeakMap();
+function synchronous(read) {
+    const value = read();
+    if (value && typeof value.then === "function") {
+        void Promise.resolve(value).catch(() => { });
+        throw new AppError("read_snapshot_async", "Memory custody traversal must be synchronous", 1);
+    }
+    return value;
+}
+export function withMemoryCustodySnapshot(context, read) {
+    if (snapshots.has(context))
+        return synchronous(read);
+    return context.db.readSnapshot(() => {
+        snapshots.set(context, new Set());
+        try {
+            return synchronous(read);
+        }
+        finally {
+            snapshots.delete(context);
+        }
+    });
+}
+/** Only SQL custody may share a completed proof within this synchronous
+ * snapshot. Physical revalidation stays outside this memo, and the next
+ * traversal always rereads SQL. Failed checks never become reusable proof.
+ * Prepared owners supply private keys, never their externally visible object. */
+export function assertMemorySqlCustody(context, owner, validate) {
+    withMemoryCustodySnapshot(context, () => {
+        const checked = snapshots.get(context);
+        if (checked.has(owner))
+            return;
+        synchronous(validate);
+        checked.add(owner);
+    });
+}