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

package/dist/services/memory-verification-checks.js

@@ -14,21 +14,46 @@ import { PreparedMemoryBaselinePreservation } from "./memory-baseline-preservati
 import { readBoundedReleaseFile } from "./release-source.js";
 import { codeCheckProfileHash, projectPolicyCheckDeclarationsFromProfile, readCodeCheckProfile, runCodeChecks, PreparedCheckEvidence } from "./code-checks.js";
 import { ObservedMemorySources } from "./memory-source-observations.js";
-import { memoryVerificationActivePaths, validateMemoryLintConfig } from "./memory-lint-config.js";
+import { memoryVerificationActivePaths, memoryUpgradeLintGuidance, memoryVerificationSupplementalLintFiles, memoryCanonicalLintExceptions, memoryCanonicalTemplatePaths } from "./memory-lint-config.js";
 import { isMemoryCorrectionInputOwner } from "./memory-correction-input-owner.js";
+import { readMemoryUpgradeBootstrapReadiness } from "./memory-upgrade-bootstrap-readiness.js";
+import { readUpgradeStorageReadiness } from "./memory-upgrade-storage-readiness.js";
+import { PreparedAcceptedMemoryComposition } from "./memory-accepted-composition.js";
+import { RetainedExecutionBundle } from "./execution-bundles.js";
+import { retainedBrowserEnvironment, validateCheckEnvironment } from "./check-environment.js";
 const token = Symbol("memory-verification-checks");
 const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
 const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 const profilePath = ".memory-bank/spec/engineering/code-check-profile.json";
+export function memorySupplementalLintCommand(executable, workspace, files, exceptions = []) {
+    const config = JSON.stringify(exceptions.length ? { ignoreFindings: exceptions } : {});
+    return `printf '%s\\n' ${quote(config)} > "$DD_FLOW_EVIDENCE_DIR/mb-lint-active-config.json" && ${quote(executable)} --root ${quote(workspace)} --config "$DD_FLOW_EVIDENCE_DIR/mb-lint-active-config.json" --files ${files.map(quote).join(" ")} --format json > "$DD_FLOW_EVIDENCE_DIR/mb-lint-active.json"`;
+}
 function refuse(reason) {
     throw new AppError("memory_verification_checks_invalid", "Verification checks lack admitted tool, policy or accepted composition custody", 2, { reason, effect: "no_effect" });
 }
+/** First introduction adds obligations to mandatory lint; an existing policy
+ * remains immutable, including in the next correction wave. */
+export function assertRetainedMemoryVerificationPolicy(previous, current) {
+    if (previous !== null && current !== previous)
+        refuse("correction_policy_requires_readmission");
+}
 /** Finite project checks use the original Codex home, never a temporary
  * provider Session overlay. Keep every other application environment input. */
 export function memoryCheckEnvironment(context, projectId, runId) {
+    let browser = retainedBrowserEnvironment(context.env);
     if (!context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='run_controllers'"))
-        return undefined;
-    const controllers = context.db.all("SELECT state_json FROM run_controllers WHERE project_id=? AND run_id=?", [projectId, runId]);
+        return browser;
+    const controllers = context.db.all("SELECT state_json,manifest_json FROM run_controllers WHERE project_id=? AND run_id=?", [projectId, runId]);
+    const retained = new Set(controllers.flatMap(controller => {
+        const manifest = JSON.parse(controller.manifest_json);
+        const value = validateCheckEnvironment(manifest.check_environment)?.PLAYWRIGHT_BROWSERS_PATH;
+        return value === undefined ? [] : [value];
+    }));
+    if (retained.size > 1)
+        refuse("ambiguous_check_browser_resource");
+    if (retained.size)
+        browser = { PLAYWRIGHT_BROWSERS_PATH: [...retained][0] };
     const targets = new Set();
     for (const controller of controllers) {
         const state = JSON.parse(controller.state_json);
@@ -37,7 +62,7 @@ export function memoryCheckEnvironment(context, projectId, runId) {
             targets.add(session.codex_home);
     }
     if (!targets.size)
-        return undefined;
+        return browser;
     const current = process.env.CODEX_HOME;
     if (current && !targets.has(current) && context.db.get("SELECT 1 FROM sqlite_schema WHERE type='table' AND name='work_launches'")) {
         const launches = context.db.all("SELECT l.state_dir FROM work_launches l JOIN works w ON w.work_id=l.work_id WHERE w.project_id=? AND w.run_id=?", [projectId, runId]);
@@ -60,7 +85,7 @@ export function memoryCheckEnvironment(context, projectId, runId) {
     const base = [...sources][0];
     if (current === undefined ? base !== path.join(os.homedir(), ".codex") : current !== base && !targets.has(current))
         refuse("foreign_check_home");
-    return { CODEX_HOME: base };
+    return { ...browser, CODEX_HOME: base };
 }
 function lintConfig(workspace) {
     const file = path.join(workspace, ".mb-lint.json");
@@ -86,19 +111,29 @@ function accepted(context, input) {
     }
     const frozen = input.execution.snapshot(), scope = { requestId: frozen.scope.requestId, projectRoot: frozen.scope.projectRoot, workspaceRoot: frozen.scope.workspace };
     const run = context.db.get("SELECT workspace_root,project_root,run_root,run_dir,index_json FROM runs WHERE project_id=? AND id=?", [input.projectId, input.runId]);
-    const bootstrap = readMemoryInitBootstrapReadiness(context, scope), lint = readMemoryInitProjectBootstrapLintCapability(context, scope);
+    const upgrade = input.flow.descriptor.id === "mb-upgrade";
+    const init = upgrade ? null : readMemoryInitBootstrapReadiness(context, scope);
+    const updated = upgrade ? readMemoryUpgradeBootstrapReadiness(context, scope) : null;
+    const bootstrap = init ?? updated;
+    const lint = upgrade ? updated?.authority.binding.lint ? { facts: updated.authority.binding.lint, sha256: hybridDigest(updated.authority.binding.lint) } : null
+        : readMemoryInitProjectBootstrapLintCapability(context, scope);
     if (!run || run.project_root !== scope.projectRoot || run.workspace_root !== scope.workspaceRoot || !bootstrap || !lint
         || bootstrap.projectId !== input.projectId || bootstrap.authority.binding.execution_sha256 !== input.execution.sha256)
         refuse("accepted_bootstrap_scope_required");
-    const compose = readAcceptedStageData(context, { projectId: input.projectId, runId: input.runId, stage: "compose" });
-    if (compose.data_schema_id !== "dd-flow/mb-init-compose-result@1")
+    const authoring = upgrade ? "upgrade" : "compose";
+    const compose = readAcceptedStageData(context, { projectId: input.projectId, runId: input.runId, stage: authoring });
+    if (compose.data_schema_id !== (upgrade ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-compose-result@1"))
         refuse("accepted_composition_required");
+    const baselineProfile = upgrade ? readUpgradeStorageReadiness(context, scope)?.selection?.payload.current.inventory.inventory.entries
+        .find(entry => entry.path === profilePath.slice(13))?.current?.sha256 ?? null : null;
     const active = input.corrected ? "review" : "verify";
     const { index_json, ...roots } = run, index = JSON.parse(index_json), stage = index.stage_runs.find((stage) => stage.stage === active);
     if (index.current_stage !== active || stage?.status !== "running" || typeof stage.input_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(stage.input_sha256))
         refuse(input.corrected ? "active_corrected_review_required" : "active_verification_required");
     const phase = { attempt: stage.attempt ?? null, cycle: stage.cycle ?? null, input_sha256: stage.input_sha256 };
-    return { run: roots, bootstrap, lint, compose, scope, authority: hybridDigest({ run: roots, phase, bootstrap: bootstrap.authority, lint, compose: compose.authority_sha256,
+    const probe = init?.authority.binding.target.tool_probes?.["mb-lint"] ?? updated?.authority.binding.lint;
+    const executable = init?.authority.binding.target.tools["mb-lint"] ?? updated?.authority.binding.lint?.executable;
+    return { run: roots, bootstrap, lint, compose, scope, probe, executable, baselineProfile, authority: hybridDigest({ run: roots, phase, bootstrap: bootstrap.authority, lint, compose: compose.authority_sha256,
             ...(input.corrected ? { corrected_sha256: input.corrected.sha256 } : {}) }) };
 }
 /** Owning CLI policy, not agent-proposed commands. The bootstrap-selected
@@ -147,30 +182,52 @@ export class PreparedMemoryVerificationChecks {
         if (context.db.isOwnedWriteTransaction?.())
             refuse("preparation_outside_writer_required");
         if (!(input.execution instanceof FrozenGenericExecution) || !(input.flow instanceof ResolvedFlowDescriptor)
-            || input.flow.descriptor.id !== "mb-init" || input.execution.settings.flow_id !== "mb-init"
+            || !["mb-init", "mb-upgrade"].includes(input.flow.descriptor.id) || input.execution.settings.flow_id !== input.flow.descriptor.id
             || input.execution.settings.descriptor_sha256 !== input.flow.sha256)
             refuse("frozen_memory_selection_required");
         input.corrected?.revalidate(context);
         const selected = context.db.readSnapshot(() => accepted(context, input)), value = JSON.parse(selected.compose.bytes.toString("utf8"));
-        const schema = JSON.parse(input.flow.stageBlob("compose", "result_schema").toString("utf8"));
+        const upgrade = input.flow.descriptor.id === "mb-upgrade", authoring = upgrade ? "upgrade" : "compose";
+        const schema = JSON.parse(input.flow.stageBlob(authoring, "result_schema").toString("utf8"));
         if (!new Ajv2020({ strict: true, strictRequired: false, validateFormats: false }).compile(schema)(value))
             refuse("accepted_composition_required");
         const compose = value;
-        if (compose.run_id !== input.runId || compose.stage !== "compose" || compose.outcome !== "accepted")
+        if (compose.run_id !== input.runId || compose.stage !== authoring || compose.outcome !== "accepted")
             refuse("accepted_composition_required");
-        const probe = selected.bootstrap.authority.binding.target.tool_probes?.["mb-lint"];
-        if (!probe || selected.bootstrap.authority.binding.target.tools["mb-lint"] !== selected.lint.facts.executable
+        const probe = selected.probe;
+        if (!probe || selected.executable !== selected.lint.facts.executable
             || probe.executable_sha256 !== selected.lint.facts.executable_sha256 || probe.version !== selected.lint.facts.version
             || hash(readBoundedReleaseFile(selected.lint.facts.executable, 64 * 1024 * 1024)) !== probe.executable_sha256)
             refuse("selected_linter_changed");
-        const preservation = PreparedMemoryBaselinePreservation.prepare(context, input.execution);
+        const bundle = input.bundle ?? input.corrected?.bundle();
+        if (upgrade && (!(bundle instanceof RetainedExecutionBundle) || bundle.execution.sha256 !== input.execution.sha256 || bundle.descriptor.sha256 !== input.flow.sha256))
+            refuse("registered_upgrade_bundle_required");
+        if (input.composition && (!(input.composition instanceof PreparedAcceptedMemoryComposition) || input.composition.result().sha256 !== selected.compose.result.sha256))
+            refuse("foreign_accepted_composition");
+        const preservation = upgrade ? input.corrected ?? input.composition ?? PreparedAcceptedMemoryComposition.prepare(context, { scope: input, bundle: bundle }) : PreparedMemoryBaselinePreservation.prepare(context, input.execution);
         const workspace = selected.run.workspace_root;
         const config = lintConfig(workspace);
         const corrected = input.corrected?.value();
-        if (config)
-            validateMemoryLintConfig(config, corrected
-                ? memoryVerificationActivePaths(corrected.unit_inventory, corrected.assignments)
-                : memoryVerificationActivePaths(compose.units));
+        let guidance;
+        let canonicalEntries = [];
+        let canonicalFiles = new Map();
+        let templates;
+        if (upgrade) {
+            const storage = readUpgradeStorageReadiness(context, selected.scope);
+            if (!storage?.selection)
+                refuse("retained_upgrade_inventory_required");
+            const diff = readAcceptedStageData(context, { projectId: input.projectId, runId: input.runId, stage: "diff-analysis" });
+            guidance = memoryUpgradeLintGuidance(storage.selection.payload.current.inventory.inventory.entries, JSON.parse(diff.bytes.toString("utf8")).details.path_map);
+            canonicalEntries = storage.selection.payload.current.inventory.inventory.entries;
+            canonicalFiles = new Map(storage.selection.payload.layer.files.map(file => [file.path, Buffer.from(file.base64, "base64")]));
+            const current = new Map(canonicalEntries.filter(entry => /^mbb\/templates\/.+\.(?:md|markdown)$/.test(entry.path) && entry.current?.kind === "file" && entry.target && ["canonical", "local-customized"].includes(entry.ownership))
+                .map(entry => [entry.path, readBoundedReleaseFile(path.join(workspace, ".memory-bank", entry.path), 64 * 1024 * 1024)]));
+            templates = memoryCanonicalTemplatePaths(canonicalEntries, canonicalFiles, current);
+        }
+        const supplementalFiles = config ? memoryVerificationSupplementalLintFiles(config, corrected
+            ? memoryVerificationActivePaths(corrected.unit_inventory, corrected.assignments, guidance, templates)
+            : memoryVerificationActivePaths(compose.units, [], guidance, templates)) : [];
+        const canonicalExceptions = memoryCanonicalLintExceptions(canonicalEntries, canonicalFiles, supplementalFiles);
         let observed = null;
         let exists = false;
         try {
@@ -183,6 +240,8 @@ export class PreparedMemoryVerificationChecks {
         }
         const profileRefs = input.corrected ? input.corrected.value().run_inputs : compose.units.flatMap(unit => unit.artifacts);
         const expectedProfiles = new Set(profileRefs.filter(artifact => artifact.root === "workspace" && artifact.path === profilePath).map(artifact => artifact.sha256));
+        if (upgrade && exists && !expectedProfiles.size && selected.baselineProfile)
+            expectedProfiles.add(selected.baselineProfile);
         if (expectedProfiles.size !== (exists ? 1 : 0))
             refuse("profile_presence_differs_from_composition");
         if (exists) {
@@ -194,21 +253,27 @@ export class PreparedMemoryVerificationChecks {
         const { profile: policy, hash: profileHash } = readCodeCheckProfile(workspace);
         if (profileHash !== (observed?.hashes().get(`workspace\0${profilePath}`) ?? null))
             refuse("profile_changed_during_preparation");
-        const checks = [{ id: "MEMORY/verify/lint-schema-links", canonical_ref: "MEMORY/verify/lint-schema-links",
-                command: `${quote(selected.lint.facts.executable)} --root ${quote(workspace)} --format json > "$DD_FLOW_EVIDENCE_DIR/mb-lint.json"`,
-                purpose: "Mandatory bootstrap-selected Memory Bank lint, frontmatter/schema and Markdown target checks", run_at: "readiness", availability: "available", required_artifacts: ["mb-lint.json"], inputs: ["."],
-                // The pinned linter reads project files/config and invokes Git; provider
-                // Session configuration is not one of its execution dependencies.
-                environment_inputs: ["PATH", "PATHEXT", "HOME", "XDG_CONFIG_HOME", "NODE_*", "UV_*", "GIT_*", "LANG", "LC_*", "TZ", "DYLD_*", "LD_*", "SYSTEMROOT", "COMSPEC", "TMPDIR", "TMP", "TEMP"] },
+        const lintCheck = { id: "MEMORY/verify/lint-schema-links", canonical_ref: "MEMORY/verify/lint-schema-links",
+            command: `${quote(selected.lint.facts.executable)} --root ${quote(workspace)} --format json > "$DD_FLOW_EVIDENCE_DIR/mb-lint.json"`,
+            purpose: "Mandatory bootstrap-selected Memory Bank lint, frontmatter/schema and Markdown target checks", run_at: "readiness", availability: "available", required_artifacts: ["mb-lint.json"], inputs: ["."],
+            // The pinned linter reads project files/config and invokes Git; provider
+            // Session configuration is not one of its execution dependencies.
+            environment_inputs: ["PATH", "PATHEXT", "HOME", "XDG_CONFIG_HOME", "NODE_*", "UV_*", "GIT_*", "LANG", "LC_*", "TZ", "DYLD_*", "LD_*", "SYSTEMROOT", "COMSPEC", "TMPDIR", "TMP", "TEMP"] };
+        const checks = [lintCheck,
+            ...(supplementalFiles.length ? [{ ...lintCheck, id: "MEMORY/verify/lint-active-documents", canonical_ref: "MEMORY/verify/lint-active-documents",
+                    command: memorySupplementalLintCommand(selected.lint.facts.executable, workspace, supplementalFiles, canonicalExceptions),
+                    purpose: "Mandatory independent lint of active Markdown excluded by preserved project policy",
+                    required_artifacts: ["mb-lint-active-config.json", "mb-lint-active.json"] }] : []),
             ...projectPolicyCheckDeclarationsFromProfile(policy, "readiness")];
-        if (input.corrected && codeCheckProfileHash(workspace, checks) !== input.corrected.verificationProfileHash(context))
-            refuse("correction_policy_requires_readmission");
+        if (input.corrected)
+            assertRetainedMemoryVerificationPolicy(input.corrected.verificationProfileHash(context), codeCheckProfileHash(workspace, checks));
         const prepared = new PreparedMemoryVerificationChecks(token, input, selected, observed, preservation, checks, config ? hash(config) : null);
         prepared.#checkEnvironment = memoryCheckEnvironment(context, input.projectId, input.runId);
         prepared.revalidate(context);
         return prepared;
     }
     declarations() { return structuredClone(this.#checks); }
+    profileHash() { return this.#profileSha256; }
     assertCorrectionOwner(corrected) {
         if (!isMemoryCorrectionInputOwner(corrected) || this.#input.corrected !== corrected)
             refuse("foreign_correction_check_owner");

package/dist/services/memory-verification-receipt.js

@@ -137,15 +137,16 @@ function accepted(context, scope) {
         return refuse("invalid_receipt_json");
     }
     if (!receipt || typeof receipt !== "object" || Array.isArray(receipt) || hybridDigest({ ...receipt, checks: undefined }) !== hybridDigest({ schema_id: "dd-flow/memory-verification-acceptance@1", run_id: scope.runId, stage: "verify", project_id: scope.projectId,
-        attempt: selected.attempt, input_sha256: selected.input_sha256, result_sha256: data.result.sha256 }) || data.data_schema_id !== "dd-flow/mb-init-verify-result@1"
+        attempt: selected.attempt, input_sha256: selected.input_sha256, result_sha256: data.result.sha256 }) || !["dd-flow/mb-init-verify-result@1", "dd-flow/mb-upgrade-stage-result@1"].includes(data.data_schema_id ?? "")
         || data.input_sha256 !== selected.input_sha256)
         refuse("accepted_receipt_changed");
     const value = JSON.parse(data.bytes.toString("utf8"));
-    const compose = readAcceptedStageData(context, { ...scope, stage: "compose" }), 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
+    const authoring = data.data_schema_id === "dd-flow/mb-upgrade-stage-result@1" ? "upgrade" : "compose";
+    const compose = readAcceptedStageData(context, { ...scope, stage: authoring }), composed = JSON.parse(compose.bytes.toString("utf8"));
+    if (compose.data_schema_id !== (authoring === "upgrade" ? data.data_schema_id : "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(value.predecessors) !== hybridDigest([{ stage: "compose", result: compose.result, input_sha256: compose.input_sha256 }]))
+        || hybridDigest(value.predecessors) !== hybridDigest([{ stage: authoring, result: compose.result, input_sha256: compose.input_sha256 }]))
         refuse("accepted_predecessor_changed");
     if (value.stage !== "verify" || value.run_id !== scope.runId || !["accepted", "needs_repair"].includes(value.outcome) || value.input_sha256 !== selected.input_sha256
         || !Array.isArray(receipt.checks) || receipt.checks.some(reference => !reference || typeof reference !== "object" || Array.isArray(reference)

package/dist/services/memory-verify-handler.js

@@ -24,14 +24,14 @@ function refuse(reason) {
  */
 export function runMemoryVerificationChecks(context, input) {
     const bundle = readFlowRunExecutionBundle(context, input);
-    if (!bundle || bundle.descriptor.descriptor.id !== "mb-init" || bundle.descriptor.successor("compose", "accepted") !== "verify"
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || bundle.descriptor.successor(bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose", "accepted") !== "verify"
         || bundle.descriptor.successor("verify", "accepted") !== "review")
         refuse("registered_memory_bundle_required");
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), scope = { projectId: project.id, runId: input.runId };
     const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), index = JSON.parse(run.index_json);
     if (index.current_stage !== "verify" || index.stage_runs.find((stage) => stage.stage === "verify")?.status !== "running")
         refuse("active_verification_required");
-    return PreparedMemoryVerificationChecks.prepare(context, { ...scope, execution: bundle.execution, flow: bundle.descriptor }).execute(context);
+    return PreparedMemoryVerificationChecks.prepare(context, { ...scope, execution: bundle.execution, flow: bundle.descriptor, bundle }).execute(context);
 }
 /** Productive entry implementation, not registered until the complete six-stage
  * memory group is ready. Checks and semantic assessment acceptance belong to
@@ -41,22 +41,23 @@ export function startMemoryVerification(context, input) {
     if (!(input.bytes instanceof Uint8Array) || input.bytes.length > 1024 * 1024)
         refuse("invalid_input_bytes");
     const bundle = readFlowRunExecutionBundle(context, input);
-    if (!bundle || bundle.descriptor.descriptor.id !== "mb-init" || bundle.descriptor.successor("compose", "accepted") !== "verify"
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || bundle.descriptor.successor(bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose", "accepted") !== "verify"
         || bundle.descriptor.successor("verify", "accepted") !== "review")
         refuse("registered_memory_bundle_required");
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), scope = { projectId: project.id, runId: input.runId, stage: "verify" };
     const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), index = JSON.parse(run.index_json);
     if (index.stage_runs.find((stage) => stage.stage === "verify")?.status === "done")
         refuse("use_accepted_finish_replay");
-    const preservation = PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
-    const inherited = context.db.readSnapshot(() => ({ compose: readAcceptedStageData(context, { ...scope, stage: "compose" }), preflight: readAcceptedStageData(context, { ...scope, stage: "preflight" }) }));
+    const upgrade = bundle.descriptor.descriptor.id === "mb-upgrade", authoring = upgrade ? "upgrade" : "compose";
+    const preservation = upgrade ? PreparedAcceptedMemoryComposition.prepare(context, { scope, bundle }) : PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
+    const inherited = context.db.readSnapshot(() => ({ compose: readAcceptedStageData(context, { ...scope, stage: authoring }), preflight: readAcceptedStageData(context, { ...scope, stage: "preflight" }) }));
     const compose = JSON.parse(inherited.compose.bytes.toString("utf8")), preflight = JSON.parse(inherited.preflight.bytes.toString("utf8"));
-    if (compose.schema_id !== "dd-flow/mb-init-compose-result@1" || compose.run_id !== input.runId || compose.outcome !== "accepted"
-        || preflight.schema_id !== "dd-flow/mb-init-preflight-result@1" || preflight.run_id !== input.runId || preflight.outcome !== "accepted")
+    if (compose.schema_id !== (upgrade ? "dd-flow/mb-upgrade-stage-result@1" : "dd-flow/mb-init-compose-result@1") || compose.run_id !== input.runId || compose.outcome !== "accepted"
+        || preflight.schema_id !== (upgrade ? compose.schema_id : "dd-flow/mb-init-preflight-result@1") || preflight.run_id !== input.runId || preflight.outcome !== "accepted")
         refuse("accepted_composition_and_baseline_required");
     const fence = (writer) => {
         preservation.assertCustody(writer);
-        if (readAcceptedStageData(writer, { ...scope, stage: "compose" }).authority_sha256 !== inherited.compose.authority_sha256
+        if (readAcceptedStageData(writer, { ...scope, stage: authoring }).authority_sha256 !== inherited.compose.authority_sha256
             || readAcceptedStageData(writer, { ...scope, stage: "preflight" }).authority_sha256 !== inherited.preflight.authority_sha256)
             refuse("inherited_custody_changed");
     };
@@ -75,7 +76,7 @@ export function finishMemoryVerification(context, input) {
     if (!(input.bytes instanceof Uint8Array) || !input.bytes.length || input.bytes.length > 1024 * 1024)
         refuse("invalid_result_bytes");
     const bundle = readFlowRunExecutionBundle(context, input);
-    if (!bundle || bundle.descriptor.descriptor.id !== "mb-init" || bundle.descriptor.successor("compose", "accepted") !== "verify"
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || bundle.descriptor.successor(bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose", "accepted") !== "verify"
         || bundle.descriptor.successor("verify", "accepted") !== "review")
         refuse("registered_memory_bundle_required");
     const project = requireProjectByRoot(context, resolveProjectRoot(input.projectRoot)), scope = { projectId: project.id, runId: input.runId };
@@ -99,11 +100,11 @@ export function finishMemoryVerification(context, input) {
     }
     const composition = PreparedAcceptedMemoryComposition.prepare(context, { scope, bundle }), compose = composition.result();
     const composedUnits = compose.value().units;
-    const preservation = PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
-    const policy = PreparedMemoryVerificationChecks.prepare(context, { ...scope, execution: bundle.execution, flow: bundle.descriptor });
+    const preservation = bundle.descriptor.descriptor.id === "mb-upgrade" ? composition : PreparedMemoryBaselinePreservation.prepare(context, bundle.execution);
+    const policy = PreparedMemoryVerificationChecks.prepare(context, { ...scope, execution: bundle.execution, flow: bundle.descriptor, bundle, composition });
     const checks = policy.evidence(context, "diagnostic");
     const binding = PreparedMemoryResultBinding.prepare(context, { ...scope, stage: "verify", flow: bundle.descriptor, execution: bundle.execution, bundle,
-        sources: composition.captureSources(context, input.bytes, checks), checks });
+        sources: composition.captureSources(context, input.bytes, checks), checks, historicalEvidence: composition.historicalEvidence() });
     let proposal;
     try {
         proposal = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(input.bytes));
@@ -114,7 +115,8 @@ export function finishMemoryVerification(context, input) {
     }
     const references = checks.sourceReferences().map(({ path, sha256 }) => ({ path, sha256 }));
     const result = PreparedMemoryStageResult.prepare(Buffer.from(JSON.stringify(projectMemoryVerificationChecks(projectMemoryVerificationArtifacts(proposal, composedUnits, composition.outputReferences(), createHash("sha256").update(input.bytes).digest("hex")), references, bundle.descriptor.stage("verify").directory, createHash("sha256").update(input.bytes).digest("hex")))), bundle.descriptor, binding.binding());
-    const acceptance = PreparedMemoryVerificationAcceptance.prepare({ scope, result, compose, checks, composition, roots: bundle.execution.snapshot().scope });
+    const acceptance = PreparedMemoryVerificationAcceptance.prepare({ scope, result, compose, checks, composition, roots: bundle.execution.snapshot().scope,
+        proposalSha256: createHash("sha256").update(input.bytes).digest("hex") });
     const receipt = PreparedMemoryVerificationReceipt.prepare(context, { scope, result, checks, acceptance });
     const settlement = PreparedDescriptorStageSettlement.prepare(context, { ...input, stage: "verify", bytes: result.bytes() });
     composition.revalidate(context);

package/dist/services/memory-work-result-json.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+import { AppError } from "../shared/errors.js";
+/** Syntax only: the caller still owns bounds, assignment and evidence checks. */
+export function parseMemoryWorkResultProposal(bytes, code) {
+    try {
+        return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw new AppError(code, "Memory result proposal is not valid UTF-8 JSON. Correct only this proposal using its assigned packet; do not rerun settled work or change retained inputs", 2, { reason: "invalid_result_json", phase: "prepare", effect: "no_effect", recoverable: true,
+            result_sha256: createHash("sha256").update(bytes).digest("hex") });
+    }
+}

package/dist/services/memory-work-result-preparation.js

@@ -10,7 +10,7 @@ import { restoreMemoryRepairPublicationFromStage, prepareMemorySecondRepairPubli
  * from worker JSON, mutable schemas, caller profile or a supplied request key.
  * Preparation is read-only and occurs before the settlement writer.
  */
-export function prepareRegisteredMemoryWorkResult(context, work, result) {
+export function prepareRegisteredMemoryWorkResult(context, work, result, progress) {
     if (!["dd-flow/memory-composition-work-result@1", "dd-flow/memory-review-work-result@1", "dd-flow/memory-repair-work-result@1"].includes(work.result_schema ?? ""))
         return null;
     const bytes = Buffer.from(result, "utf8");
@@ -44,15 +44,16 @@ export function prepareRegisteredMemoryWorkResult(context, work, result) {
         return PreparedPublishedMemoryRepairWorkResult.prepare(context, publication);
     }
     if (work.result_schema === "dd-flow/memory-review-work-result@1") {
-        return PreparedRegisteredMemoryReviewWorkResult.prepare(context, { workId: work.work_id, bytes });
+        return PreparedRegisteredMemoryReviewWorkResult.prepare(context, { workId: work.work_id, bytes, ...(progress ? { progress } : {}) });
     }
     const run = context.db.get("SELECT project_root FROM runs WHERE project_id=? AND id=?", [work.project_id, work.run_id]);
     const bundle = run && readFlowRunExecutionBundle(context, { projectRoot: run.project_root, runId: work.run_id });
-    if (!bundle || bundle.descriptor.descriptor.id !== "mb-init")
+    if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id))
         throw new AppError("memory_work_result_preparation_required", "Composition finish requires its retained memory flow", 1, { effect: "no_effect" });
+    const stage = bundle.descriptor.descriptor.id === "mb-init" ? "compose" : "upgrade";
     const custody = readWorkBatchCustody(context, work.work_id);
     const registration = selectMemoryCompositionRegistration(context, {
-        project_id: work.project_id, run_id: work.run_id, stage: "compose", attempt: custody.scope.attempt,
+        project_id: work.project_id, run_id: work.run_id, stage, attempt: custody.scope.attempt,
         cycle: custody.scope.cycle, parent_work_id: custody.scope.parent_work_id
     });
     return PreparedRegisteredMemoryCompositionWorkResult.prepareFromStageCustody(context, bytes, bundle.engine(), {

package/dist/services/merge-server.js

@@ -1,6 +1,6 @@
 import { managedInvocationContext, managedLifecycleCommand } from "./lifecycle-invocations.js";
 import { stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
-import { continueProviderCapacity } from "./provider-capacity.js";
+import { continueProviderCapacity, ownedProviderBoundary } from "./provider-capacity.js";
 import { errorRecord } from "./run-controller-state.js";
 import crypto from "node:crypto";
 import fs from "node:fs";
@@ -185,7 +185,9 @@ async function dispatch(context, input) {
                     if (!["created", "running", "paused", "completed"].includes(context.db.get("SELECT status FROM works WHERE work_id = ?", [input.request.executor_work_id])?.status ?? ""))
                         throw new AppError("capacity_continuation_blocked", "MERGE Work has failed or lost its binding", 1);
                 },
-                decision: () => {
+                decision: (boundary) => {
+                    if (boundary && !ownedProviderBoundary(context, { projectId: input.request.project_id, runId: input.request.run_id, stage: "merge", sessionId, generation, workId: input.request.executor_work_id, scope: "stage" }, boundary))
+                        return "reconciliation_blocked";
                     const status = context.db.get("SELECT status FROM merge_requests WHERE merge_request_id = ?", [input.request.merge_request_id])?.status;
                     const workStatus = context.db.get("SELECT status FROM works WHERE work_id = ?", [input.request.executor_work_id])?.status;
                     return status === "completed" ? "completed" : status === "action_required" || workStatus === "paused" ? "paused" : "continue";