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

package/dist/services/hybrid-contracts.js

@@ -12,19 +12,8 @@ const hybridContractRegistry = new Set(hybridContractNames);
 const record = (input) => input;
 const list = (input) => input;
 const string = (input) => input;
-/** Deterministic JSON content identity, not a signature or secret-derived hash. */
-export function hybridDigest(input) {
-    const canonical = (value) => {
-        if (Array.isArray(value))
-            return value.map(canonical);
-        if (value !== null && typeof value === "object") {
-            return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b, "en"))
-                .map(([key, child]) => [key, canonical(child)]));
-        }
-        return value;
-    };
-    return createHash("sha256").update(JSON.stringify(canonical(input))).digest("hex");
-}
+import { hybridDigest } from "./hybrid-digest.js";
+export { hybridDigest };
 /** E1 standalone validation. Runtime ingress must explicitly integrate it in E2/E3. */
 export function validateHybridContract(name, input, context = {}) {
     if (name === "flow-descriptor") {
@@ -260,6 +249,8 @@ export function validateHybridContract(name, input, context = {}) {
             fail("foreign_bundle_canon", "/canon");
         if (hybridDigest(data.project_pack) !== hybridDigest(context.bundleProvenance.project_pack))
             fail("foreign_bundle_project_pack", "/project_pack");
+        if ((data.flow_id === "mb-audit" || data.flow_id === "project-review") !== (data.project_pack === null))
+            fail("invalid_bundle_project_pack_role", "/project_pack");
         const memoryFlow = data.flow_id === "mb-init" || data.flow_id === "mb-upgrade";
         if (memoryFlow && context.bootstrapIdentity?.projectRoot !== context.bundleProjectRoot)
             fail("foreign_bootstrap_identity", "/bootstrap_receipts");

package/dist/services/hybrid-digest.js

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+/** Deterministic JSON content identity, not a signature or secret-derived hash. */
+export function hybridDigest(input) {
+    const canonical = (value) => {
+        if (Array.isArray(value))
+            return value.map(canonical);
+        if (value !== null && typeof value === "object") {
+            return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b, "en"))
+                .map(([key, child]) => [key, canonical(child)]));
+        }
+        return value;
+    };
+    return createHash("sha256").update(JSON.stringify(canonical(input))).digest("hex");
+}

package/dist/services/installed-flow-source.js

@@ -6,7 +6,9 @@ import { readSetupStatus } from "./setup.js";
 import { readBoundedReleaseFile } from "./release-source.js";
 import { hybridDigest, validateHybridShape } from "./hybrid-contracts.js";
 import { admitBundledFlow } from "./stage-handlers.js";
+import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
 const limit = 1024 * 1024;
+const flowIds = ["mb-init", "mb-upgrade", "mb-audit", "project-review"];
 const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function refuse(reason) {
     throw new AppError("installed_flow_source_invalid", "Installed flow source is not the selected verified canon", 1, { reason, phase: "prepare", effect: "no_effect" });
@@ -50,7 +52,7 @@ export class PreparedInstalledFlowSource {
     }
     static fromInstalledRelease(home, expectedInstallationSha256, flowId) {
         try {
-            if (!path.isAbsolute(home) || !/^[a-f0-9]{64}$/.test(expectedInstallationSha256) || flowId !== "mb-init")
+            if (!path.isAbsolute(home) || !/^[a-f0-9]{64}$/.test(expectedInstallationSha256) || !flowIds.includes(flowId))
                 refuse("invalid_selection");
             const selected = readSetupStatus(home);
             if (!selected.installation || selected.installation_readiness !== "installed")
@@ -95,6 +97,26 @@ export class PreparedInstalledFlowSource {
                     folded.set(reference.path.toLowerCase(), reference.path);
                     blobs.set(reference.path, Buffer.from(content));
                 }
+            if (isDiagnosticFlow(flowId)) {
+                const support = ["mbb/index.md", "mbb/memory-bank-structure.md", "mbb/frontmatter-standards.md", "mbb/cross-references.md", "mbb/named-deferrals-guide.md",
+                    ...fs.readdirSync(path.join(memoryRoot, "mbb/aspects")).filter(name => name.endsWith(".md")).map(name => `mbb/aspects/${name}`),
+                    "dd-flow/mb-sdlc/review/aspects.md", "dd-flow/mb-sdlc/review/critics/universal.md", "dd-flow/mb-sdlc/review/critics/architectural-harmonization.md",
+                    ...fs.readdirSync(path.join(flowRoot, "mb-audit/aspects")).filter(name => name.endsWith(".md")).map(name => `dd-flow/mb-audit/aspects/${name}`)];
+                for (const logical of support) {
+                    const content = readBoundedReleaseFile(containedFile(memoryRoot, logical), limit), name = `support/${logical}`;
+                    if (!content.length || (total += content.length) > 32 * limit || folded.has(name.toLowerCase()))
+                        refuse("invalid_support_inventory");
+                    new TextDecoder("utf-8", { fatal: true }).decode(content);
+                    folded.set(name.toLowerCase(), name);
+                    blobs.set(name, Buffer.from(content));
+                }
+                const workSchema = "schemas/diagnostic-work-result.schema.json";
+                const content = readBoundedReleaseFile(containedFile(flowRoot, workSchema), limit);
+                if (!content.length || (total += content.length) > 32 * limit || folded.has(workSchema.toLowerCase()))
+                    refuse("invalid_support_inventory");
+                JSON.parse(content.toString("utf8"));
+                blobs.set(workSchema, Buffer.from(content));
+            }
             // Verify compressed/expanded archive identity again after collecting bytes.
             // A coherent descriptor+prompt edit cannot become a new trusted selection.
             const final = readSetupStatus(home);
@@ -120,6 +142,18 @@ export class PreparedInstalledFlowSource {
      * or admit its engine/storage; those remain the bootstrap owner's duties.
      */
     static restoreRetained(input, expectedSha256) {
+        const result = this.restoreRetainedData(input, expectedSha256);
+        try {
+            result.resolveRegisteredFlow();
+            return result;
+        }
+        catch {
+            return refuse("invalid_retained_source");
+        }
+    }
+    /** Data recovery before storage/engine admission. This cannot register a
+     * handler; productive restoration still uses restoreRetained above. */
+    static restoreRetainedData(input, expectedSha256) {
         try {
             if (!input || typeof input !== "object" || Array.isArray(input) || typeof expectedSha256 !== "string"
                 || !/^[a-f0-9]{64}$/.test(expectedSha256))
@@ -132,7 +166,7 @@ export class PreparedInstalledFlowSource {
                 || typeof value.canon.archive_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.canon.archive_sha256)
                 || typeof value.canon.version !== "string" || !/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/.test(value.canon.version)
                 || !value.descriptor || Object.keys(value.descriptor).sort().join() !== "path,sha256"
-                || value.descriptor.path !== "mb-init/flow-descriptor.json" || typeof value.descriptor.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.descriptor.sha256)
+                || !flowIds.some(id => value.descriptor.path === `${id}/flow-descriptor.json`) || typeof value.descriptor.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.descriptor.sha256)
                 || !Array.isArray(value.blobs) || value.blobs.length < 1 || value.blobs.length > 129)
                 refuse("invalid_retained_source");
             const blobs = new Map(), folded = new Set();
@@ -154,10 +188,19 @@ export class PreparedInstalledFlowSource {
             const descriptor = blobs.get(value.descriptor.path);
             if (!descriptor || hash(descriptor) !== value.descriptor.sha256)
                 refuse("retained_source_changed");
-            const result = new PreparedInstalledFlowSource(null, value.installation_sha256, "mb-init", { ...value.descriptor }, { ...value.canon }, blobs);
+            const flowId = value.descriptor.path.slice(0, -"/flow-descriptor.json".length);
+            const declared = JSON.parse(descriptor.toString("utf8"));
+            if (validateHybridShape("flow-descriptor", declared).length || declared.id !== flowId || declared.origin !== "canon")
+                refuse("invalid_retained_source");
+            for (const stage of declared.stages)
+                for (const kind of ["instruction", "result_schema"]) {
+                    const reference = stage[kind], content = blobs.get(reference.path);
+                    if (!content || hash(content) !== reference.sha256)
+                        refuse("retained_source_changed");
+                }
+            const result = new PreparedInstalledFlowSource(null, value.installation_sha256, flowId, { ...value.descriptor }, { ...value.canon }, blobs);
             if (result.sha256 !== expectedSha256)
                 refuse("retained_source_changed");
-            result.resolveRegisteredFlow();
             return result;
         }
         catch (error) {

package/dist/services/lifecycle-invocations.js

@@ -8,16 +8,15 @@ import { AppError, errorRecord } from "../shared/errors.js";
 import { shortEntityReference } from "../shared/entity-references.js";
 import { resolveWorkReference } from "../storage/work-references.js";
 import { commandOption, commandPosition, continuationCommand, lifecycleCommandFromPayload, parseLifecycleCommand, shellSuffixOffset } from "./lifecycle-command.js";
-import { requireProjectByRoot } from "./projects.js";
-import { assertRunMutationAllowed, assertStageSettlementAllowed, assertWorkSettlementAllowed, recoveryGuard, recoveryPacketReceipt } from "./run-recovery.js";
+import { requireProjectByRoot } from "./project-registry.js";
+import { assertRunMutationAllowed, assertStageSettlementAllowed, assertWorkSettlementAllowed, recoveryGuard, recoveryPacketReceipt } from "./run-recovery-guard.js";
 import { readNativeDaemonState, requireManagedDaemonBinding } from "./managed-daemon-binding.js";
 import { managedProcessStatus, processIsAlive, processStartedAt } from "./managed-processes.js";
 import { appendEvent } from "./run-controller-state.js";
-import { recoverCommittedWorkStart } from "./work-registry.js";
 import { observeCommandHook } from "./hooks.js";
 import { runtimeHarness } from "./execution-policy.js";
 import { normalizedPathAlias, resolveContextualPaths } from "./command-context.js";
-import { isRegisteredRepair } from "./repair-intents.js";
+import { isRegisteredRepair } from "./repair-receipt.js";
 import { stageAttempt } from "./stage-work-graph.js";
 import { contextualPathOptionsForLifecycle } from "../cli/command-inputs.js";
 import { canonicalPath } from "../storage/paths.js";
@@ -25,6 +24,9 @@ import { runtimeCommand, shellArgument } from "./runtime-command.js";
 // Process-local custody: an executing SQL row or ambient variable alone cannot
 // recreate admission after a CLI restart, or in another resource database.
 const currentAdmissions = new WeakMap();
+// A same-stage finish continuation is not authority until its predecessor's
+// outcome commits. Process death before that commit leaves no issued successor.
+const stagedContinuations = new WeakMap();
 export function currentLifecycleAdmission(context, id) {
     const owned = currentAdmissions.get(context.db)?.get(id);
     if (!owned || context.env.DD_FLOW_CURRENT_INVOCATION !== id || owned.pid !== process.pid
@@ -380,8 +382,9 @@ export function assertLifecycleOutcomes(context, scope) {
       AND NOT EXISTS (SELECT 1 FROM lifecycle_invocations newer WHERE newer.scope_json = a.scope_json AND newer.fingerprint = a.fingerprint AND newer.rowid > a.rowid)
     ORDER BY a.rowid`, [scope.projectRoot, scope.runId, scope.generation]);
     for (const row of rows) {
-        const error = (row.outcome_json ? JSON.parse(row.outcome_json) : null)?.error;
-        if (typeof error?.code === "string" && !isCorrectableLifecycleRejection(error.code, error.details) && !isRegisteredRepair(context, error.details?.continuation, { projectId: project.id, runId: scope.runId }))
+        const outcome = row.outcome_json ? JSON.parse(row.outcome_json) : null;
+        const error = outcome?.error;
+        if (typeof error?.code === "string" && !committedSuccessor(context, row, outcome) && !isCorrectableLifecycleRejection(error.code, error.details) && !isRegisteredRepair(context, error.details?.continuation, { projectId: project.id, runId: scope.runId }))
             throw new AppError(error.code, typeof error.message === "string" ? error.message : "Mandatory lifecycle failed", 1, { ...(error.details ?? {}), invocation_id: row.id });
     }
 }
@@ -490,14 +493,27 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
             }
         }
         const registeredContinuation = error && registeredLifecycleContinuation(context, error, anchor.project_id, anchor.run_id);
-        const retainedSuccessor = error && typeof error.details.retry_command === "string"
-            && typeof error.details.rejection_signature === "string"
+        const retainedRejections = error && typeof error.details.retry_command === "string"
             && context.db.get("SELECT 1 FROM sqlite_master WHERE name = 'lifecycle_invocations'")
-            && context.db.get(`SELECT 1 FROM lifecycle_invocations a JOIN hook_events h ON h.event_key = a.event_key
-        JOIN projects p ON p.id = h.project_id WHERE h.id = ? AND h.project_id = ? AND a.status = 'settled'
-        AND json_extract(a.scope_json,'$.projectRoot') = p.root AND json_extract(a.scope_json,'$.runId') = ?
-        AND json_extract(a.scope_json,'$.generation') = ? AND json_extract(a.outcome_json,'$.error.details.retry_command') = ?
-        AND json_extract(a.outcome_json,'$.error.details.rejection_signature') = ?`, [anchor.hook_event_id, anchor.project_id, anchor.run_id, anchor.generation, error.details.retry_command, error.details.rejection_signature]);
+            ? context.db.all(`SELECT a.* FROM lifecycle_invocations a JOIN hook_events h ON h.event_key = a.event_key
+        WHERE h.id = ? AND h.project_id = ? AND a.status = 'settled'
+        AND json_extract(a.scope_json,'$.runId') = ?
+        AND json_extract(a.scope_json,'$.generation') = ? AND json_extract(a.outcome_json,'$.error.code') = ?
+        AND json_extract(a.outcome_json,'$.error.details.retry_command') = ?`, [anchor.hook_event_id, anchor.project_id, anchor.run_id, anchor.generation, error.code, error.details.retry_command]) : [];
+        const projectRoot = context.db.get("SELECT root FROM projects WHERE id = ?", [anchor.project_id])?.root;
+        const ownedRejections = retainedRejections.filter(row => {
+            try {
+                return projectRoot !== undefined && canonicalPath(JSON.parse(row.scope_json).projectRoot, false) === projectRoot;
+            }
+            catch {
+                return false;
+            }
+        });
+        const retainedRejection = ownedRejections.length === 1 ? ownedRejections[0] : undefined;
+        // A committed exact successor is authority; reclassifying its sanitized
+        // error would discard the original validated check capability again.
+        const retainedSuccessor = retainedRejection && (committedSuccessor(context, retainedRejection, JSON.parse(retainedRejection.outcome_json ?? "null"))
+            ?? (error && currentIssuedCommand(context, retainedRejection.scope_json, String(error.details.retry_command))));
         const hookOnlyArgumentDefect = error && !invocationId && !context.env.DD_FLOW_INVOCATION_SCOPE
             && !retainedSuccessor
             && ["missing_required_option", "missing_option_value", "empty_option_value", "invalid_number", "invalid_choice", "duplicate_option"].includes(String(error.details.reason));
@@ -536,7 +552,7 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
             }
         }
         const correctable = error && !hookOnlyArgumentDefect && error.details.recoverable !== false && error.details.effect !== "unknown"
-            && (registeredContinuation || error.details.effect === "no_effect" && isCorrectableLifecycleRejection(error.code, error.details)
+            && (registeredContinuation || retainedSuccessor || error.details.effect === "no_effect" && isCorrectableLifecycleRejection(error.code, error.details)
                 && typeof error.details.retry_command === "string");
         const correlationKey = parsed.kind === "standalone" ? fingerprint(parsed.invocation)
             : JSON.stringify([auxiliary.operation, auxiliary.operation === "stage_block" ? auxiliary.args.positional[2] ?? null : auxiliary.args.options.get("run")?.[0] ?? null, auxiliary.args.options.get("stage")?.[0] ?? null]);
@@ -646,18 +662,60 @@ export function lifecycleRetryCommands(context, stage) {
             .flatMap((row) => {
             try {
                 const outcome = row.outcome_json ? JSON.parse(row.outcome_json) : null;
-                const retry = outcome?.error?.details?.retry_command;
+                const retry = outcome?.error?.details?.retry_command ?? outcome?.result?.next?.finish_command;
                 const parsed = invocation(row.command);
                 if (typeof retry !== "string" || parsed.operation !== "stage_finish" || commandOption(parsed, "stage") !== stage)
                     return [];
-                const latest = context.db.get("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? ORDER BY rowid DESC LIMIT 1", [row.scope_json, row.fingerprint]);
-                return latest?.status === "issued" && (latest.deadline === null || latest.deadline > Date.now()) ? [retry] : [];
+                const successor = outcome?.successor_invocation_id
+                    ? context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ? AND scope_json = ?", [outcome.successor_invocation_id, row.scope_json])
+                    : currentIssuedCommand(context, row.scope_json, retry);
+                return successor?.status === "issued" && successor.fingerprint === scopedCommandFingerprint(context, row.scope_json, retry)
+                    && (successor.deadline === null || successor.deadline > Date.now()) ? [publicInvocationCommand(context, successor, successor.command)] : [];
             }
             catch {
                 return [];
             }
         }))];
 }
+function currentIssuedCommand(context, scope, command) {
+    const rows = context.db.all("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? AND status = 'issued'", [scope, scopedCommandFingerprint(context, scope, command)])
+        .filter(row => row.deadline === null || row.deadline > Date.now());
+    if (rows.length > 1)
+        throw new AppError("invocation_ambiguous", "Multiple current lifecycle successors match this command", 1);
+    return rows[0] ?? null;
+}
+function scopedCommandFingerprint(context, scope, command) {
+    return fingerprint(invocation(canonicalManagedCommand(context, command, JSON.parse(scope))));
+}
+function committedSuccessor(context, prior, outcome) {
+    if (typeof outcome?.successor_invocation_id !== "string" || outcome.successor_invocation_id === prior.id)
+        return null;
+    const command = outcome.error?.details?.retry_command ?? outcome.result?.next?.finish_command;
+    if (typeof command !== "string")
+        return null;
+    const next = context.db.get("SELECT * FROM lifecycle_invocations WHERE id = ? AND scope_json = ?", [outcome.successor_invocation_id, prior.scope_json]);
+    return next && next.status !== "expired" && (next.status !== "issued" || next.deadline === null || next.deadline > Date.now())
+        && next.fingerprint === scopedCommandFingerprint(context, prior.scope_json, command) ? next : null;
+}
+function invocationRecoverySnapshot(context, scope) {
+    return JSON.stringify(context.db.get(`SELECT g.generation,g.status,g.recovery_id FROM run_recovery_guards g
+    JOIN projects p ON p.id=g.project_id WHERE p.root=? AND g.run_id=? ORDER BY g.generation DESC LIMIT 1`, [scope.projectRoot, scope.runId]) ?? null);
+}
+/** Resolve authority, never reconstruct it from an old prompt or issue on read. */
+export function currentStageFinishCommand(context, stage) {
+    const scope = context.env.DD_FLOW_INVOCATION_SCOPE;
+    if (!scope || !context.db.get("SELECT 1 FROM sqlite_master WHERE name='lifecycle_invocations'"))
+        return null;
+    const rows = context.db.all("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND status = 'issued'", [scope])
+        .filter(row => {
+        const parsed = invocation(row.command);
+        return parsed.operation === "stage_finish" && commandOption(parsed, "stage") === stage
+            && (row.deadline === null || row.deadline > Date.now());
+    });
+    if (rows.length > 1)
+        throw new AppError("invocation_ambiguous", "Stage has multiple current finish authorities", 1, { stage });
+    return rows[0] ? publicInvocationCommand(context, rows[0], rows[0].command) : null;
+}
 export function managedInvocationContext(context, input) {
     const env = { ...context.env, DD_FLOW_CURRENT_INVOCATION: undefined, DD_FLOW_INVOCATION_SCOPE: undefined };
     if (!["zcode-acp", "codex-desktop", "grok-acp", "antigravity-cli", "droid-cli", "opencode-server"].includes(input.harness))
@@ -713,6 +771,21 @@ export function managedLifecycleCommand(context, command, options = {}) {
         return publicInvocationCommand(context, retained, command);
     }
     storage(context);
+    const predecessorId = context.env.DD_FLOW_CURRENT_INVOCATION;
+    const predecessor = predecessorId ? load(context, predecessorId) : null;
+    if (predecessor?.status === "executing" && predecessor.scope_json === configured
+        && parsed.operation === "stage_finish" && invocation(predecessor.command).operation === "stage_finish"
+        && commandOption(parsed, "stage") === commandOption(invocation(predecessor.command), "stage")) {
+        let staged = stagedContinuations.get(context.db);
+        if (!staged)
+            stagedContinuations.set(context.db, staged = new Map());
+        const prior = staged.get(predecessor.id);
+        if (prior && prior.fingerprint !== fingerprint(parsed))
+            throw new AppError("invocation_continuation_conflict", "One finish may publish only one exact successor", 1);
+        const next = prior ?? prepareIssuedInvocation(command, scope);
+        staged.set(predecessor.id, next);
+        return publicInvocationCommand(context, next, command);
+    }
     return context.db.writeTransaction(() => {
         const prior = options.freshWorkAttempt ? undefined : context.db.get("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? ORDER BY rowid DESC LIMIT 1", [JSON.stringify(scope), fingerprint(parsed)]);
         if (prior && prior.id !== context.env.DD_FLOW_CURRENT_INVOCATION) {
@@ -793,17 +866,35 @@ export function settleLifecycleRejection(context, id, error) {
     // Only this settlement may publish a successor; inherited help is not authority.
     delete error.details.retry_command;
     delete error.details.retry_instruction;
-    const details = { ...error.details };
+    // A producer may have rendered help before throwing. Only the decision below
+    // may publish replacement authority for a rejected operation.
+    stagedContinuations.get(context.db)?.delete(id);
+    // Validate process-local receipt capabilities BEFORE diagnostic cloning.
+    // Only this local preparation crosses into the SQL commit below; public
+    // category fields/serialized receipts cannot recreate the decision.
+    const prepared = {
+        invocation: JSON.stringify(load(context, id)),
+        recovery: invocationRecoverySnapshot(context, JSON.parse(load(context, id).scope_json)),
+        retryable: isRetryableLifecycleRejection(error.code, error.details),
+        receipts: ["work_checks_failed", "code_gate_failed", "code_review_gate_failed", "merge_gate_failed"].includes(error.code) && Array.isArray(error.details.failures)
+            ? error.details.failures.map(receipt => ({ receipt, row: context.db.get("SELECT * FROM check_receipts WHERE id = ?", [receipt.id]) })) : []
+    };
+    if (prepared.receipts.some(({ receipt, row }) => !row || row.status !== receipt.status || row.verification_epoch !== receipt.verification_epoch || row.command !== receipt.command || row.input_hash !== receipt.input_hash))
+        prepared.retryable = false;
+    const serialized = errorRecord(error);
+    const details = { ...serialized.details };
     try {
         context.db.writeTransaction(() => {
             const prior = load(context, id);
-            if (prior.status !== "executing")
-                throw new AppError("invocation_settlement_conflict", "Attempt is no longer executing", 1, { invocation_id: id });
+            if (prior.status !== "executing" || JSON.stringify(prior) !== prepared.invocation
+                || invocationRecoverySnapshot(context, JSON.parse(prior.scope_json)) !== prepared.recovery
+                || prepared.receipts.some(({ receipt, row }) => JSON.stringify(context.db.get("SELECT * FROM check_receipts WHERE id = ?", [receipt.id])) !== JSON.stringify(row)))
+                throw new AppError("invocation_settlement_conflict", "Attempt or bound check receipts changed before settlement", 1, { invocation_id: id });
             const storageRetry = error.code === "storage_write_failed" && error.details.effect === "no_effect"
                 && !context.db.get("SELECT 1 FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? AND json_extract(outcome_json, '$.error.details.storage_retry') = 1 LIMIT 1", [prior.scope_json, prior.fingerprint]);
-            if (isRetryableLifecycleRejection(error.code, error.details) || storageRetry) {
-                const failures = ["work_checks_failed", "code_gate_failed", "code_review_gate_failed", "merge_gate_failed"].includes(error.code) ? error.details.failures : undefined;
-                const retry = retryLifecycleInvocationCommand(context, id, failures?.[0]?.id);
+            if (prepared.retryable || storageRetry) {
+                const failures = prepared.receipts.map(value => value.receipt);
+                const retry = retryLifecycleInvocationCommand(context, id, failures[0]?.id);
                 details.retry_command = retry;
                 details.effect = "no_effect";
                 details.recoverable = true;
@@ -825,7 +916,9 @@ export function settleLifecycleRejection(context, id, error) {
             else {
                 details.recoverable = false;
             }
-            settleLifecycleInvocation(context, id, { error: { ...error, details } });
+            const successor = stagedContinuations.get(context.db)?.get(id)
+                ?? (typeof details.retry_command === "string" ? currentIssuedCommand(context, prior.scope_json, details.retry_command) : null);
+            settleLifecycleInvocation(context, id, { error: { ...serialized, details }, ...(successor ? { successor_invocation_id: successor.id } : {}) });
         });
     }
     catch (persistence) {
@@ -964,15 +1057,22 @@ export function prepareLifecycleIssuance(command, value) {
     return { command, scope, parsed };
 }
 export function issueLifecycleInvocation(context, command, scope) {
-    const { parsed } = prepareLifecycleIssuance(command, scope);
+    const row = prepareIssuedInvocation(command, scope);
     storage(context);
+    insertIssuedInvocation(context, row);
+    return { id: row.id, command: row.command };
+}
+function prepareIssuedInvocation(command, scope) {
+    const { parsed } = prepareLifecycleIssuance(command, scope);
     const id = crypto.randomUUID();
     const prepared = commandWithInvocationId(command, id);
     // Validate the actual inserted argv, including quoted heredoc boundaries.
-    const row = { id, command: prepared, scope_json: JSON.stringify(scope), fingerprint: fingerprint(parsed) };
+    const row = { id, command: prepared, scope_json: JSON.stringify(scope), fingerprint: fingerprint(parsed), status: "issued", event_key: null, identity_json: null, deadline: null, outcome_json: null };
     checkCommand(row, prepared);
-    context.db.run("INSERT INTO lifecycle_invocations (id, scope_json, command, fingerprint, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'issued', ?, ?)", [id, row.scope_json, prepared, row.fingerprint, context.now(), context.now()]);
-    return { id, command: prepared };
+    return row;
+}
+function insertIssuedInvocation(context, row) {
+    context.db.run("INSERT INTO lifecycle_invocations (id, scope_json, command, fingerprint, status, created_at, updated_at) VALUES (?, ?, ?, ?, 'issued', ?, ?)", [row.id, row.scope_json, row.command, row.fingerprint, context.now(), context.now()]);
 }
 /** Prepare outside a write transaction; the Work retry CAS owns issuance. */
 export function prepareWorkStartAuthority(context, command, previousId) {
@@ -1930,9 +2030,40 @@ export async function awaitLifecycleInvocation(context, input) {
             return { outcome: JSON.parse(row.outcome_json), replay: true };
         if (row.status === "executing") {
             const scope = JSON.parse(row.scope_json);
+            const parsed = invocation(row.command);
+            if (parsed.operation === "stage_resume" && scope.runId) {
+                input.assertCurrent(scope);
+                const { recoverCommittedStageResume } = await import("./stage-pause.js");
+                const result = recoverCommittedStageResume(context, { id: row.id, projectRoot: scope.projectRoot, runId: scope.runId, generation: scope.generation, stage: commandOption(parsed, "stage") ?? "", workId: commandOption(parsed, "work") ?? "" });
+                if (result) {
+                    const project = requireProjectByRoot(context, scope.projectRoot);
+                    const { publishStagePacket } = await import("./stage-report-renderer.js");
+                    publishStagePacket(context, project.id, scope.runId, commandOption(parsed, "stage") ?? "", String(result.resume_source_path));
+                    const { preparePromptDelivery } = await import("./prompt-delivery.js");
+                    const delivered = preparePromptDelivery(result);
+                    const previousScope = context.env.DD_FLOW_INVOCATION_SCOPE;
+                    context.env.DD_FLOW_INVOCATION_SCOPE = row.scope_json;
+                    try {
+                        bindLifecyclePublishedPacket(context, String(result.worker_prompt_markdown));
+                    }
+                    finally {
+                        if (previousScope === undefined)
+                            delete context.env.DD_FLOW_INVOCATION_SCOPE;
+                        else
+                            context.env.DD_FLOW_INVOCATION_SCOPE = previousScope;
+                    }
+                    const event = row.event_key ? context.db.get("SELECT id FROM hook_events WHERE project_id = ? AND event_key = ?", [project.id, row.event_key]) : null;
+                    if (event)
+                        observeLifecycleCommand(context, row.command, { project_id: project.id, id: event.id })({ result: delivered });
+                    const outcome = { result: delivered, effect: "committed" };
+                    settleLifecycleInvocation(context, row.id, outcome);
+                    return { outcome, replay: true };
+                }
+            }
             if (invocation(row.command).operation === "work_start" && row.event_key) {
                 input.assertCurrent(scope);
-                const result = recoverCommittedWorkStart(context, row.id, row.event_key, scope.generation);
+                const { recoverCommittedWorkStart } = await import("./work-registry.js");
+                const result = recoverCommittedWorkStart(context, row.id, row.event_key, scope.generation, undefined, input.progress);
                 if (result) {
                     const outcome = { result, effect: "committed" };
                     settleLifecycleInvocation(context, row.id, outcome);
@@ -1994,14 +2125,24 @@ export async function awaitLifecycleInvocation(context, input) {
     }
 }
 export function settleLifecycleInvocation(context, id, outcome) {
-    currentAdmissions.get(context.db)?.delete(id);
-    const encoded = JSON.stringify(outcome);
-    if (encoded === undefined)
-        throw new AppError("invocation_outcome_invalid", "Invocation outcome must be JSON", 1);
-    const changed = context.db.run("UPDATE lifecycle_invocations SET status = 'settled', outcome_json = ?, updated_at = ? WHERE id = ? AND status = 'executing'", [encoded, context.now(), id]);
-    if (changed.changes !== 1) {
+    const successor = stagedContinuations.get(context.db)?.get(id);
+    context.db.writeTransaction(() => {
         const row = load(context, id);
-        if (row.status !== "settled" || row.outcome_json !== encoded)
-            throw new AppError("invocation_settlement_conflict", "Attempt cannot be settled with a different outcome", 1, { invocation_id: id });
-    }
+        const retained = successor && outcome && typeof outcome === "object" ? { ...outcome, successor_invocation_id: successor.id } : outcome;
+        const encoded = JSON.stringify(retained);
+        if (encoded === undefined)
+            throw new AppError("invocation_outcome_invalid", "Invocation outcome must be JSON", 1);
+        if (row.status === "settled") {
+            if (row.outcome_json !== encoded)
+                throw new AppError("invocation_settlement_conflict", "Attempt cannot be settled with a different outcome", 1, { invocation_id: id });
+            return;
+        }
+        if (row.status !== "executing")
+            throw new AppError("invocation_settlement_conflict", "Attempt is no longer executing", 1, { invocation_id: id });
+        if (successor)
+            insertIssuedInvocation(context, successor);
+        if (context.db.run("UPDATE lifecycle_invocations SET status = 'settled', outcome_json = ?, updated_at = ? WHERE id = ? AND status = 'executing'", [encoded, context.now(), id]).changes !== 1)
+            throw new AppError("invocation_settlement_conflict", "Lifecycle outcome changed before commit", 1, { invocation_id: id });
+    });
+    currentAdmissions.get(context.db)?.delete(id);
 }

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

@@ -35,15 +35,16 @@ export class PreparedAcceptedMemoryComposition {
     }
     static prepare(context, input) {
         const { scope, bundle } = input;
-        if (!(bundle instanceof RetainedExecutionBundle) || bundle.descriptor.descriptor.id !== "mb-init")
+        if (!(bundle instanceof RetainedExecutionBundle) || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id))
             refuse("registered_memory_bundle_required");
+        const stage = bundle.descriptor.descriptor.id === "mb-init" ? "compose" : "upgrade";
         const run = assertPreparedRunBundleSqlAuthority(context, scope, bundle), root = readDescriptorRootWork(context, scope, bundle);
-        const registration = selectMemoryCompositionRegistration(context, { ...stageGraphScope(context, scope.projectId, scope.runId, "compose"), stage: "compose", parent_work_id: root.workId });
+        const registration = selectMemoryCompositionRegistration(context, { ...stageGraphScope(context, scope.projectId, scope.runId, stage), stage, parent_work_id: root.workId });
         const blueprint = PreparedMemoryResultBinding.prepareRegisteredComposition(context, { ...scope, flow: bundle.descriptor, execution: bundle.execution, bundle, acceptedReplay: true,
             registrationScope: registration.scope });
         const outputs = PreparedMemoryCompositionAcceptance.prepare(context, { scope: registration.scope, flow: bundle.descriptor, engine: bundle.engine(), binding: blueprint.binding() });
-        const composed = readAcceptedStageData(context, { ...scope, stage: "compose" }), runRoot = run.run_root ?? run.run_dir;
-        const binding = PreparedMemoryResultBinding.prepare(context, { ...scope, stage: "compose", flow: bundle.descriptor, execution: bundle.execution, bundle, acceptedReplay: true,
+        const composed = readAcceptedStageData(context, { ...scope, stage }), runRoot = run.run_root ?? run.run_dir;
+        const binding = PreparedMemoryResultBinding.prepare(context, { ...scope, stage, flow: bundle.descriptor, execution: bundle.execution, bundle, acceptedReplay: true,
             sources: captureMemoryCompositionSources(context, bundle, runRoot, composed.bytes, outputs), historicalEvidence: outputs.historicalEvidence() });
         if (!binding.acceptedBytes()?.equals(composed.bytes))
             refuse("accepted_composition_changed");

package/dist/services/memory-completed-correction-wave.js

@@ -1,9 +1,11 @@
+import { assertMemorySqlCustody } from "./memory-custody-snapshot.js";
 import { AppError } from "../shared/errors.js";
 import { hybridDigest } from "./hybrid-contracts.js";
 import { PreparedRegisteredMemoryCorrections } from "./memory-repair-registration.js";
 import { PreparedRetainedSecondMemoryRepairs } from "./memory-retained-second-repairs.js";
 import { PreparedSettledMemoryRepair } from "./memory-repair-history.js";
 import { PreparedMemoryRepairWorkspace } from "./memory-repair-workspace.js";
+import { isCompletedMemoryRepairClaim } from "./memory-repair-work-results.js";
 import { reviewSourcePaths } from "./review-copy.js";
 import { readAcceptedStageData } from "./stage-report-renderer.js";
 const token = Symbol("completed-memory-correction-wave");
@@ -41,8 +43,7 @@ export function memoryCorrectionAffectedUnits(units, repairs, composition = [])
     const affected = new Set(), changed = new Set();
     for (const repair of repairs) {
         if (!repair || !Array.isArray(repair.unit_ids) || !repair.unit_ids.length || new Set(repair.unit_ids).size !== repair.unit_ids.length
-            || repair.unit_ids.some((id) => !applicable.has(id)) || repair.result?.outcome !== "accepted"
-            || !Array.isArray(repair.result.changes) || !repair.result.changes.length)
+            || repair.unit_ids.some((id) => !applicable.has(id)) || !isCompletedMemoryRepairClaim(repair.result))
             refuse("invalid_settled_repair_projection");
         for (const id of repair.unit_ids)
             affected.add(id);
@@ -138,6 +139,7 @@ const nonMemory = (entry) => entry.path !== ".memory-bank" && !entry.path.starts
  * review. Reconstruction starts at independently retained first-wave state;
  * neither current files nor a second writer's claimed before-view are anchors. */
 export class PreparedHistoricalSecondMemoryCorrectionWave {
+    #custodyKey = {};
     static isPrepared(value) {
         return typeof value === "object" && value !== null && #registration in value;
     }
@@ -167,11 +169,11 @@ export class PreparedHistoricalSecondMemoryCorrectionWave {
         for (const history of histories) {
             if (!prefixes.has(hybridDigest(history.before().entries())))
                 refuse("unexplained_historical_input_view");
-            baseline = baseline.composeSettledDelta(history.before(), history.after());
+            baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
             prefixes.add(hybridDigest(baseline.entries()));
         }
         const batch = registration.batch(), receipt = registration.receipt(), first = registration.initialInputView();
-        const compose = readAcceptedStageData(context, { ...input.scope, stage: "compose" });
+        const compose = readAcceptedStageData(context, { ...input.scope, stage: input.bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose" });
         const affected = memoryCorrectionAffectedUnits(memoryCorrectionCurrentUnits(first.unit_inventory, first.assignments), histories.map(history => ({ result: history.result(),
             unit_ids: batch.works.find(item => receipt.work_ids[item.key] === history.workId).payload.memory_repair.unit_ids })), JSON.parse(compose.bytes.toString("utf8")).details.works);
         const prepared = new PreparedHistoricalSecondMemoryCorrectionWave(historicalToken, registration, selected, histories, baseline, affected);
@@ -189,10 +191,13 @@ export class PreparedHistoricalSecondMemoryCorrectionWave {
             unit_ids: batch.works.find(item => receipt.work_ids[item.key] === history.workId).payload.memory_repair.unit_ids }));
     }
     assertCustody(context) {
-        if (hybridDigest(selection(context, this.#registration)) !== hybridDigest(this.#selected))
-            refuse("historical_second_graph_changed");
-        for (const history of this.#histories)
-            history.assertCustody(context);
+        const registration = this.#registration;
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            if (hybridDigest(selection(context, registration)) !== hybridDigest(this.#selected))
+                refuse("historical_second_graph_changed");
+            for (const history of this.#histories)
+                history.assertCustody(context);
+        });
     }
     revalidate(context) {
         this.#registration.revalidate(context);
@@ -207,6 +212,7 @@ export class PreparedHistoricalSecondMemoryCorrectionWave {
  * from today's filesystem. This owner neither allocates reviewers nor marks
  * repair findings resolved; independent re-review must consume it separately. */
 export class PreparedCompletedMemoryCorrectionWave {
+    #custodyKey = {};
     static isPrepared(value) {
         return typeof value === "object" && value !== null && #selected in value;
     }
@@ -252,7 +258,7 @@ export class PreparedCompletedMemoryCorrectionWave {
         for (const history of histories) {
             if (!known.has(hybridDigest(history.before().entries())))
                 refuse("unexplained_historical_input_view");
-            baseline = baseline.composeSettledDelta(history.before(), history.after());
+            baseline = baseline.composeSettledDelta(history.before(), history.after(), history.result().outcome);
             known.add(hybridDigest(baseline.entries()));
         }
         const view = PreparedRetainedSecondMemoryRepairs.isPrepared(registration) ? registration.initialInputView()
@@ -272,7 +278,7 @@ export class PreparedCompletedMemoryCorrectionWave {
         if (histories.some(history => hybridDigest(history.workspaceManifest().entries().filter(nonMemory)) !== sourceSha256))
             refuse("non_memory_source_changed");
         const batch = registration.batch(), receipt = registration.receipt();
-        const compose = readAcceptedStageData(context, { projectId: receipt.scope.project_id, runId: receipt.run_id, stage: "compose" });
+        const compose = readAcceptedStageData(context, { projectId: receipt.scope.project_id, runId: receipt.run_id, stage: bundle.descriptor.descriptor.id === "mb-upgrade" ? "upgrade" : "compose" });
         const dependencies = JSON.parse(compose.bytes.toString("utf8")).details.works;
         const currentUnits = PreparedRetainedSecondMemoryRepairs.isPrepared(registration)
             ? memoryCorrectionCurrentUnits(registration.initialInputView().unit_inventory, registration.initialInputView().assignments)
@@ -292,11 +298,13 @@ export class PreparedCompletedMemoryCorrectionWave {
     repairResults() { return this.#histories.map(history => ({ work_id: history.workId, result: history.result(), reference: history.reference(), authority_sha256: history.sha256 })); }
     /** Only SQL custody is inspected inside the future review-allocation writer. */
     assertCustody(context) {
-        const selected = this.#selected;
-        if (hybridDigest(selection(context, this.#registration)) !== hybridDigest(selected))
-            refuse("completed_wave_custody_changed");
-        for (const history of this.#histories)
-            history.assertCustody(context);
+        assertMemorySqlCustody(context, this.#custodyKey, () => {
+            const selected = this.#selected;
+            if (hybridDigest(selection(context, this.#registration)) !== hybridDigest(selected))
+                refuse("completed_wave_custody_changed");
+            for (const history of this.#histories)
+                history.assertCustody(context);
+        });
     }
     /** Fresh allocation fence, before adding successor reviewers. General
      * custody deliberately stays valid when those admitted children exist. */