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

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

@@ -8,6 +8,11 @@ import { ObservedMemorySources } from "./memory-source-observations.js";
 import { readWorkBatchCustody } from "./work-registry.js";
 import { readMemoryCompositionRegistration, readRegisteredMemoryComposition } from "./memory-composition-registration.js";
 import { validateMemoryCompositionWorkResult } from "./memory-composition-work-results.js";
+import { readMemoryUpgradePublication } from "./memory-upgrade-publication-custody.js";
+import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-readiness.js";
+import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
+import { readAcceptedStageData } from "./stage-report-renderer.js";
+import { getProjectVersionStatus } from "./version-status.js";
 const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function refuse(reason) {
     throw new AppError("memory_composition_acceptance_invalid", "Composition lacks registered, settled and current output custody", 2, { reason, effect: "no_effect" });
@@ -77,17 +82,34 @@ export class PreparedMemoryCompositionAcceptance {
     #registrationSha256;
     #workers;
     #artifacts;
+    #semanticArtifacts;
+    #publication = null;
+    #migrationRecord = null;
+    #historicalEvidence = new Set();
     #observed;
     constructor(scope, original, registrationSha256, workers, artifacts, observed) {
         this.#scope = structuredClone(scope);
         this.#original = original;
         this.#registrationSha256 = registrationSha256;
         this.#workers = workers;
-        this.#artifacts = artifacts;
+        this.#artifacts = structuredClone(artifacts);
+        this.#semanticArtifacts = structuredClone(artifacts);
         this.#observed = observed;
         Object.freeze(this);
     }
     static prepare(context, input) {
+        return this.#prepare(context, input, true);
+    }
+    /** Restore settled semantic Work independently of today's possibly partly
+     * published marker bytes. The publication owner still checks the before view
+     * before retaining its intent; this method does not accept current artifacts.
+     */
+    static prepareForUpgradePublication(context, input) {
+        if (input.scope.stage !== "upgrade")
+            refuse("upgrade_publication_scope_required");
+        return this.#prepare(context, input, false);
+    }
+    static #prepare(context, input, observe) {
         const registration = readMemoryCompositionRegistration(context, input.scope);
         const original = readRegisteredMemoryComposition(context, input), value = original.value();
         const works = value.details.works;
@@ -137,21 +159,127 @@ export class PreparedMemoryCompositionAcceptance {
         for (const record of current.values())
             for (const id of record.units)
                 artifacts.set(id, [...(artifacts.get(id) ?? []), record.artifact]);
-        const observed = ObservedMemorySources.capture(assigned, [...current.values()].map(record => ({ root: record.artifact.root, path: record.artifact.path })));
-        const hashes = observed.hashes();
-        if ([...current.values()].some(record => hashes.get(memorySourceKey(record.artifact.root, record.artifact.path)) !== record.artifact.sha256))
-            refuse("current_output_bytes_changed");
-        const prepared = new PreparedMemoryCompositionAcceptance(input.scope, original, registrationSha256, selected.map(item => ({ id: item.id, harness: item.harness, authority: item.authority, evidence: item.evidence })), artifacts, observed);
+        const prepared = new PreparedMemoryCompositionAcceptance(input.scope, original, registrationSha256, selected.map(item => ({ id: item.id, harness: item.harness, authority: item.authority, evidence: item.evidence })), artifacts, null);
+        if (input.scope.stage === "upgrade")
+            prepared.#historicalEvidence = new Set(input.binding.historicalEvidence);
+        if (observe) {
+            if (input.scope.stage === "upgrade")
+                prepared.#includePublication(context, input.binding);
+            prepared.#observed = ObservedMemorySources.capture(assigned, prepared.outputLocations());
+            const hashes = prepared.#observed.hashes();
+            if ([...prepared.#artifacts.values()].flat().some(artifact => hashes.get(memorySourceKey(artifact.root, artifact.path)) !== artifact.sha256))
+                refuse("current_output_bytes_changed");
+        }
         prepared.assertCustody(context);
         return prepared;
     }
+    #includePublication(context, binding) {
+        const frozen = binding.execution?.snapshot().scope;
+        if (!frozen)
+            refuse("upgrade_execution_required");
+        const scope = { requestId: frozen.requestId, projectRoot: frozen.projectRoot, workspaceRoot: frozen.workspace };
+        const ready = readMemoryUpgradeBootstrapReadiness(context, scope), storage = readUpgradeStorageReadiness(context, scope);
+        if (!ready || !storage?.selection || ready.authority.binding.storage_sha256 !== storage.sha256)
+            refuse("upgrade_bootstrap_required");
+        const identity = { scope: this.#scope, selection_sha256: storage.selection.sha256, execution_sha256: binding.executionSha256,
+            registration_sha256: this.#registrationSha256, bootstrap_sha256: hybridDigest(ready.authority), work_custody_sha256: this.custodySha256() };
+        const publication = readMemoryUpgradePublication(context, identity);
+        if (!publication?.completed)
+            refuse("completed_upgrade_publication_required");
+        const state = publication.plan.classify();
+        if (state.completed !== state.total)
+            refuse("upgrade_publication_not_current");
+        const actions = new Map(publication.plan.actions().map(action => [`.memory-bank/${action.path}`, action]));
+        for (const artifacts of this.#artifacts.values())
+            for (const artifact of artifacts) {
+                const action = artifact.root === "workspace" ? actions.get(artifact.path) : undefined;
+                if (!action)
+                    continue;
+                // Only the exact CLI transition can advance a settled worker hash. No
+                // caller-provided allowlist may excuse an arbitrary changed document.
+                if (action.before?.sha256 !== artifact.sha256 || action.after?.kind !== "file")
+                    refuse("unbound_semantic_output_transition");
+                artifact.sha256 = action.after.sha256;
+            }
+        const outputs = new Map(publication.plan.outputs().map(output => [`.memory-bank/${output.path}`, output]));
+        const recordPath = `.memory-bank/archive/mb-upgrade/${identity.selection_sha256}/migration.json`, record = outputs.get(recordPath);
+        if (!record)
+            refuse("upgrade_migration_record_missing");
+        this.#migrationRecord = { path: recordPath, sha256: record.sha256 };
+        const add = (unit, path, sha256) => {
+            const values = this.#artifacts.get(unit) ?? [], artifact = { root: "workspace", path, sha256 };
+            const prior = values.find(value => value.root === artifact.root && value.path === path);
+            if (prior && prior.sha256 !== sha256)
+                refuse("conflicting_mechanical_artifact");
+            if (!prior)
+                values.push(artifact);
+            this.#artifacts.set(unit, values);
+        };
+        const diff = readAcceptedStageData(context, { projectId: this.#scope.project_id, runId: this.#scope.run_id, stage: "diff-analysis" });
+        const changes = JSON.parse(diff.bytes.toString("utf8")).details.path_map;
+        const old = new Map(storage.selection.payload.current.inventory.inventory.entries.map(entry => [`.memory-bank/${entry.path}`, entry]));
+        const final = new Map(publication.plan.beforeFiles().map(entry => [entry.path, entry]));
+        for (const action of publication.plan.actions()) {
+            if (action.after)
+                final.set(action.path, action.after);
+            else
+                final.delete(action.path);
+        }
+        for (const entry of storage.selection.payload.current.inventory.inventory.entries) {
+            const name = `.memory-bank/${entry.path}`, actual = final.get(entry.path);
+            const semantic = changes.some(change => change.to === name && change.action === "semantic-work");
+            if (entry.target && (entry.ownership === "generated" || entry.ownership === "canonical" && !semantic)
+                && (actual?.kind !== "file" || actual.sha256 !== entry.target.sha256))
+                refuse("incomplete_canonical_publication");
+            if (entry.ownership === "canonical" && entry.action === "archive" && actual)
+                refuse("obsolete_canonical_path_active");
+        }
+        const status = getProjectVersionStatus({ projectRoot: frozen.workspace, rootSource: "explicit", canon: null });
+        if (status?.memory_bank.version !== storage.selection.release.canon.version
+            || status.flow_pack.canon_version_at_source_commit !== storage.selection.release.canon.version
+            || status.flow_pack.source_commit !== storage.selection.release.canon.commit)
+            refuse("upgrade_versions_inconsistent");
+        for (const change of changes) {
+            if (change.action === "retain" && change.from) {
+                const source = old.get(change.from)?.current;
+                if (source?.kind === "file")
+                    add(change.unit_id, change.from, outputs.get(change.from)?.sha256 ?? source.sha256);
+            }
+            else if (["canonical", "generated"].includes(change.ownership) && change.action !== "semantic-work") {
+                if (change.to) {
+                    const output = outputs.get(change.to) ?? final.get(change.to.slice(13));
+                    if (!output || output.kind !== "file")
+                        refuse("missing_mechanical_artifact");
+                    add(change.unit_id, change.to, output.sha256);
+                }
+                if (change.from) {
+                    const archive = `.memory-bank/archive/mb-upgrade/${identity.selection_sha256}/files/${change.from.slice(13)}.bin`, output = outputs.get(archive);
+                    if (!output)
+                        refuse("missing_recovery_artifact");
+                    add(change.unit_id, archive, output.sha256);
+                }
+            }
+        }
+        for (const unit of this.#original.value().units)
+            if (unit.applicability === "applicable")
+                add(unit.id, recordPath, record.sha256);
+        this.#publication = { binding: identity, sha256: publication.plan.sha256 };
+    }
     /** Only these independently settled output locations may supplement baseline
      * evidence in the final result binding. The returned map is a defensive copy.
      */
-    outputHashes() { return this.#observed.hashes(); }
+    outputHashes() { if (!this.#observed)
+        refuse("current_output_observation_required"); return this.#observed.hashes(); }
+    /** SQL-settled before-publication facts, not current filesystem witnesses. */
+    settledArtifacts() {
+        return [...this.#semanticArtifacts].flatMap(([unit_id, artifacts]) => artifacts.map(artifact => ({ unit_id, artifact: structuredClone(artifact) })));
+    }
+    custodySha256() {
+        return hybridDigest({ scope: this.#scope, registration_sha256: this.#registrationSha256, workers: this.#workers, artifacts: [...this.#semanticArtifacts] });
+    }
     historicalEvidence() {
         const units = this.#original.value().units;
-        return new Set(units.flatMap(unit => unit.evidence.map(ref => `${memorySourceKey(ref.root, ref.path)}\0${ref.sha256}`)));
+        return new Set([...this.#historicalEvidence, ...units.flatMap(unit => unit.evidence.map(ref => `${memorySourceKey(ref.root, ref.path)}\0${ref.sha256}`))]);
     }
     resultEvidence() { return this.#workers.map(worker => structuredClone(worker.evidence)); }
     outputLocations() {
@@ -161,14 +289,48 @@ export class PreparedMemoryCompositionAcceptance {
                 selected.set(memorySourceKey(artifact.root, artifact.path), { root: artifact.root, path: artifact.path });
         return [...selected.values()];
     }
+    /** Runtime projection from completed SQL publication, never an agent map.
+     * Keep substantive fields and immutable graph intact. Existing invented
+     * references are rejected rather than silently overwritten by this helper.
+     */
+    projectResult(bytes) {
+        if (!this.#migrationRecord)
+            return Buffer.from(bytes);
+        const value = object(Buffer.from(bytes).toString("utf8"), "invalid_result_json");
+        const reject = (pointer) => {
+            throw new AppError("memory_stage_result_invalid", "Use the selected upgrade outputs; do not invent or rerun publication", 2, { reason: "unselected_upgrade_output", phase: "prepare", effect: "no_effect", recoverable: true, result_sha256: hash(bytes), pointer });
+        };
+        if (Array.isArray(value.units))
+            for (const [index, unit] of value.units.entries()) {
+                if (!unit || typeof unit !== "object" || typeof unit.id !== "string" || !this.#original.mechanicalUnitIds().has(unit.id) && !this.#artifacts.has(unit.id))
+                    continue;
+                const expected = this.#artifacts.get(unit.id) ?? [], before = this.#semanticArtifacts.get(unit.id) ?? [];
+                if (unit.artifacts !== undefined && !Array.isArray(unit.artifacts))
+                    continue;
+                for (const reference of unit.artifacts ?? [])
+                    if (![...expected, ...before].some(artifact => hybridDigest(artifact) === hybridDigest(reference)))
+                        reject(`/units/${index}/artifacts`);
+                unit.artifacts = structuredClone(expected);
+            }
+        if (value.details && typeof value.details === "object" && !Array.isArray(value.details)) {
+            const details = value.details, original = this.#original.value().details;
+            if (details.migration_record !== undefined && ![original.migration_record, this.#migrationRecord].some(reference => hybridDigest(reference) === hybridDigest(details.migration_record)))
+                reject("/details/migration_record");
+            details.migration_record = { ...this.#migrationRecord };
+        }
+        return Buffer.from(JSON.stringify(value));
+    }
     assertResult(result) {
         if (!(result instanceof PreparedMemoryStageResult))
             refuse("prepared_result_required");
+        if (this.#scope.stage === "upgrade" && !this.#publication)
+            refuse("completed_upgrade_publication_required");
         const original = this.#original.value(), final = result.value(), value = final;
         const identity = ["schema_id", "run_id", "input_sha256", "predecessors"];
         if (hybridDigest(identity.map(field => original[field])) !== hybridDigest(identity.map(field => final[field])))
             refuse("foreign_result_identity");
-        if (value.stage !== "compose" || value.outcome !== "accepted" || hybridDigest(value.details) !== hybridDigest(original.details)
+        const details = this.#migrationRecord ? { ...original.details, migration_record: this.#migrationRecord } : original.details;
+        if (value.stage !== this.#original.authoringStage() || value.outcome !== "accepted" || hybridDigest(value.details) !== hybridDigest(details)
             || value.findings.some(finding => finding.severity !== "minor" && finding.status !== "resolved"))
             refuse("composition_not_accepted_or_plan_changed");
         const inventory = new Map(original.units.map(unit => [unit.id, unit]));
@@ -193,7 +355,21 @@ export class PreparedMemoryCompositionAcceptance {
             for (const worker of this.#workers)
                 if (settled(context, this.#scope, worker.id, worker.harness, this.#registrationSha256, assigned).authority !== worker.authority)
                     refuse("work_settlement_changed");
+            if (this.#publication) {
+                const publication = readMemoryUpgradePublication(context, this.#publication.binding);
+                if (!publication?.completed || publication.plan.sha256 !== this.#publication.sha256)
+                    refuse("publication_custody_changed");
+            }
         });
     }
-    revalidate(context) { this.#observed.revalidate(); this.assertCustody(context); }
+    revalidate(context) {
+        if (this.#observed)
+            this.#observed.revalidate();
+        else {
+            const hashes = ObservedMemorySources.capture(roots(context, this.#scope), this.outputLocations()).hashes();
+            if (this.settledArtifacts().some(({ artifact }) => hashes.get(memorySourceKey(artifact.root, artifact.path)) !== artifact.sha256))
+                refuse("current_output_bytes_changed");
+        }
+        this.assertCustody(context);
+    }
 }

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

@@ -1,7 +1,7 @@
 import { AppError } from "../shared/errors.js";
 import { localEnvironmentAllowed } from "./workspace-files.js";
-function refuse(reason) {
-    throw new AppError("memory_stage_result_invalid", "Memory composition graph cannot be dispatched", 2, { reason, phase: "prepare", effect: "no_effect" });
+function refuse(reason, details = {}) {
+    throw new AppError("memory_stage_result_invalid", "Memory composition graph cannot be dispatched", 2, { ...details, reason, phase: "prepare", effect: "no_effect" });
 }
 // Portable scopes must remain safe on case-insensitive/normalizing filesystems.
 const physicalPath = (value) => value.normalize("NFC").toLowerCase();
@@ -9,8 +9,10 @@ const projectConfigurationPaths = [".memory-bank/dd-flow/project-execution.json"
 /** Exact project-owned defaults, never directory or case aliases of canon. */
 export function memoryProjectConfigurationPath(value) { return projectConfigurationPaths.includes(value); }
 /** Check both assigned directories and their concrete output descendants. */
-export function memoryCompositionOutputAllowed(value) {
-    if (overlaps(value, ".memory-bank/dd-flow") && !memoryProjectConfigurationPath(value))
+export function memoryCompositionOutputAllowed(value, upgradeWritePaths) {
+    if (upgradeWritePaths && !upgradeWritePaths.has(value))
+        return false;
+    if (!upgradeWritePaths && overlaps(value, ".memory-bank/dd-flow") && !memoryProjectConfigurationPath(value))
         return false;
     return value.split("/").every(part => localEnvironmentAllowed(part)
         && ![".git", "node_modules", ".dd-flow"].includes(physicalPath(part)));
@@ -23,7 +25,9 @@ function overlaps(left, right) {
  * semantic graph checks precede Work allocation, not merely worker dispatch.
  * They do not grant filesystem access or replace frozen profile/Work custody.
  */
-export function validateMemoryCompositionGraph(value) {
+export function validateMemoryCompositionGraph(value, upgradePaths, mechanicalUnits) {
+    if (mechanicalUnits && !upgradePaths)
+        refuse("missing_upgrade_authority");
     const result = value;
     const unresolved = result.units.findIndex(unit => unit.applicability === "unknown");
     if (unresolved !== -1)
@@ -49,17 +53,24 @@ export function validateMemoryCompositionGraph(value) {
             // entry, not selected canon. Never grant their enclosing directory or
             // case/normalization aliases; the installed prompt/schema pack is sealed.
             const projectConfig = memoryProjectConfigurationPath(scope.path);
-            if (scope.root === "workspace" && !projectConfig && [".memory-bank/mbb", ".memory-bank/dd-flow"].some(canonical => overlaps(scope.path, canonical)))
+            if (!upgradePaths && scope.root === "workspace" && !projectConfig && [".memory-bank/mbb", ".memory-bank/dd-flow"].some(canonical => overlaps(scope.path, canonical)))
                 refuse("canonical_composition_write");
+            const selectedPaths = upgradePaths && scope.root === "workspace" ? new Set(work.unit_ids.flatMap(id => [...upgradePaths.get(id) ?? []])) : undefined;
             // A contained semantic scope is not permission to alter credentials,
             // repository metadata, installed dependencies or runtime state.
-            if (!memoryCompositionOutputAllowed(scope.path))
-                refuse("private_composition_write");
+            if (!memoryCompositionOutputAllowed(scope.path, selectedPaths))
+                refuse("private_composition_write", {
+                    work_key: work.key, scope: { ...scope },
+                    hint: selectedPaths && work.unit_ids.every(id => mechanicalUnits?.has(id))
+                        ? "These units are mechanical: remove their agent Work and use memory upgrade publish after graph registration. Do not change accepted predecessor or ownership files."
+                        : selectedPaths ? "This path is outside this Work's accepted upgrade authoring paths. Mechanical canonical/generated changes use memory upgrade publish, not agent workspace writes. Correct only the proposed scopes; keep accepted predecessor and ownership files unchanged."
+                            : "Remove the private filesystem scope from the proposed Work; credentials, repository metadata and runtime state are not semantic outputs."
+                });
             if (scope.root === "run" && ["execution-bundle", "run.json"].some(authority => overlaps(scope.path, authority)))
                 refuse("authority_composition_write");
             // Mechanical RUN files and another Work's evidence are never semantic outputs.
             if (scope.root === "run") {
-                const namespace = `memory-artifacts/compose/${work.key}`;
+                const namespace = `memory-artifacts/${upgradePaths ? "upgrade" : "compose"}/${work.key}`;
                 if (scope.path !== namespace && !scope.path.startsWith(`${namespace}/`))
                     refuse("foreign_composition_run_write");
             }
@@ -107,15 +118,35 @@ export function validateMemoryCompositionGraph(value) {
         || assemblies.some(work => !declared.has(work.key)))
         refuse("invalid_assembly_membership");
     const applicable = new Set(result.units.filter(unit => unit.applicability !== "not-applicable").map(unit => unit.id));
+    for (const unit of mechanicalUnits ?? []) {
+        if (!applicable.has(unit) || upgradePaths?.has(unit))
+            refuse("invalid_mechanical_unit");
+        const assigned = works.filter(work => work.unit_ids.includes(unit));
+        if (assigned.length)
+            refuse("mechanical_unit_cannot_allocate_agent_work", {
+                unit_id: unit, work_keys: assigned.map(work => work.key).slice(0, 8),
+                hint: "Remove this unit from agent Work assignments, but keep the unit in the result inventory. CLI owns its mechanical publication through memory upgrade publish."
+            });
+    }
     for (const work of works)
         if (work.unit_ids.some(id => !applicable.has(id)))
             refuse("inapplicable_composition_work");
     for (const unit of applicable) {
+        if (mechanicalUnits?.has(unit))
+            continue;
         const authors = works.filter(work => work.unit_ids.includes(unit));
         const writers = authors.filter(work => work.role === "writer");
         const collectors = assemblies.filter(work => work.unit_ids.includes(unit));
-        if (!authors.length || !collectors.length)
-            refuse("incomplete_composition_coverage");
+        // Init assembles a new knowledge shelf. Upgrade may reconcile one existing
+        // document without changing its navigation; do not invent a collector Work.
+        // Explicit collectors still depend on every writer, in either flow.
+        if (!authors.length || !upgradePaths && !collectors.length)
+            refuse("incomplete_composition_coverage", {
+                unit_id: unit,
+                hint: upgradePaths
+                    ? "Assign this applicable non-mechanical unit to Work. For preservation evidence only, group it into an existing evidence Work with its RUN-local output; keep accepted unit identities and workspace write scopes unchanged."
+                    : "Assign this applicable unit to composition Work and its index-assembly collector. Keep accepted unit identities unchanged."
+            });
         if (collectors.some(collector => writers.some(writer => !dependsOn(collector.key, writer.key))))
             refuse("assembly_precedes_unit_writers");
     }

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 });
         }