@deksden-com/dd-flow-cli 0.9.0-beta.151 → 0.9.0-beta.155

package/dist/cli/memory-init.js

@@ -13,7 +13,8 @@ import { PreparedMemoryInitLintCapability } from "../services/memory-init-lint-c
 import { PreparedMemoryInitWorktrunkCapability } from "../services/memory-init-worktrunk-capability.js";
 import { produceMemoryInitNativeCapacity } from "../services/memory-init-native-capacity.js";
 import { openMemoryInitStores, assertMemoryInitStorePrerequisites } from "../services/memory-init-stores.js";
-import { prepareMemoryInitControllerStart, prepareMemoryUpgradeControllerStart } from "../services/memory-init-controller-start.js";
+import { prepareMemoryInitControllerStart, prepareMemoryUpgradeControllerStart, prepareInteractiveControllerStart, prepareDeliveryControllerStart } from "../services/memory-init-controller-start.js";
+import { isDeliveryFlow } from "../domain/delivery-flows.js";
 import { runControllerStatus } from "../services/run-controller.js";
 import { requireRun } from "../services/run-controller-state.js";
 import { requireProjectByRoot } from "../services/projects.js";
@@ -28,8 +29,8 @@ import { onboardExecutor } from "../services/executor-onboarding.js";
 import { readOperatorProfiles, readOperatorProfileInput } from "../services/operator-profiles.js";
 import { resolveDdFlowHome } from "../storage/paths.js";
 import { askExecutorChoice } from "./executor-onboarding.js";
-import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
-import { prepareDiagnosticControllerStart } from "../services/memory-init-controller-start.js";
+import { isSourceSnapshotFlow } from "../domain/source-snapshot-flows.js";
+import { prepareDiagnosticControllerStart, prepareMemoryFixControllerStart } from "../services/memory-init-controller-start.js";
 /** Backpressure bounds the observing client's output; closing it never controls the RUN. */
 export async function writeMemoryInitObservation(stdout, text) {
     const disconnected = () => Boolean(stdout.destroyed);
@@ -186,7 +187,7 @@ export async function launchAndObserveMemoryFlow(context, invocation, started, f
         await writeMemoryInitObservation(io.stdout, `${JSON.stringify(writeResponseFile(response, output), null, output.json || output.progressJsonl ? undefined : 2)}\n`);
         return 0;
     }
-    const launch = isDiagnosticFlow(flowId) ? prepareDiagnosticControllerStart(context, invocation.scope, flowId)
+    const launch = isDeliveryFlow(flowId) ? prepareDeliveryControllerStart(context, invocation.scope, flowId) : flowId === "interactive" ? prepareInteractiveControllerStart(context, invocation.scope) : flowId === "mb-fix" ? prepareMemoryFixControllerStart(context, invocation.scope) : isSourceSnapshotFlow(flowId) ? prepareDiagnosticControllerStart(context, invocation.scope, flowId)
         : (flowId === "mb-init" ? prepareMemoryInitControllerStart : prepareMemoryUpgradeControllerStart)(context, invocation.scope);
     // Use the existing RUN-bound router: a global CLI must not launch its own
     // controller code in place of the independently frozen RUN executable.

package/dist/cli/native-hook-ingress.js

@@ -1,7 +1,7 @@
 import { AppError, errorRecord } from "../shared/errors.js";
 import { parseCommandArgs } from "../services/lifecycle-command.js";
 import { channel } from "node:diagnostics_channel";
-import { nativeHookNonParticipation } from "./native-hook-preparation.js";
+import { nativeHookAssignedSettlement, nativeHookNonParticipation } from "./native-hook-preparation.js";
 /** These ingress commands consume a prepared store; they never prepare it. */
 export function isNativeHookIngress(args) {
     return args[2] === "handle" && ((args[1] === "event" && ["agy", "grok", "droid", "opencode", "zcode"].includes(args[0] ?? ""))
@@ -31,6 +31,10 @@ export async function dispatchNativeHook(args, stdin, env) {
         phase("ack");
         return unrelated;
     }
+    if (nativeHookAssignedSettlement(args, stdin, env)) {
+        phase("ack");
+        return { ok: true, observed: false, reason: "cli_invocation_owns_admission" };
+    }
     const [hooks, { createContext }, { resolveDdFlowHome }] = await Promise.all([
         import("../services/hooks.js"), import("../runtime/context.js"), import("../storage/paths.js")
     ]);

package/dist/cli/native-hook-preparation.js

@@ -1,12 +1,12 @@
 import path from "node:path";
 import { parseJsonObject } from "../shared/json.js";
-import { continuationCommand, parseLifecycleCommand } from "../services/lifecycle-command.js";
+import { commandOption, continuationCommand, parseLifecycleCommand } from "../services/lifecycle-command.js";
 const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 const text = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
 /** Only a validated, ordinary before-tool command can skip the stateful handler.
  * In particular after-tool, Stop, malformed and ambiguous events remain owned
  * by their existing handler; this gate does not invent an admission policy. */
-export function nativeHookNonParticipation(args, stdin) {
+function beforeCommand(args, stdin) {
     const payload = parseJsonObject(stdin || "{}", "native hook stdin");
     let command;
     if (args[0] === "zcode" && args[1] === "event") {
@@ -47,9 +47,36 @@ export function nativeHookNonParticipation(args, stdin) {
         const input = object(payload.input);
         command = text(input.command) ?? text(input.cmd) ?? text(input.CommandLine);
     }
-    if (!command)
+    return command ? { command, reason: args[0] === "zcode" && args[1] === "event" ? "acp_evidence_only" : "event_not_participating" } : null;
+}
+export function nativeHookNonParticipation(args, stdin) {
+    const before = beforeCommand(args, stdin);
+    if (!before)
         return null;
+    const { command, reason } = before;
     const parsed = parseLifecycleCommand(command);
     return parsed.participation === "none" && !continuationCommand(command)
-        ? { ok: true, observed: false, reason: args[0] === "zcode" && args[1] === "event" ? "acp_evidence_only" : "event_not_participating" } : null;
+        ? { ok: true, observed: false, reason } : null;
+}
+/** A supplied ID is not a grant. The executing CLI must prove its retained
+ * assignment; the synchronous native hook has no second admission role. */
+export function assignedLifecycleHookCommand(command, env) {
+    if (!env.DD_FLOW_DAEMON_ID)
+        return false;
+    const parsed = parseLifecycleCommand(command);
+    return parsed.kind === "standalone" && Boolean(commandOption(parsed.invocation, "invocation-id"))
+        && ["stage_start", "stage_finish", "stage_pause", "stage_resume", "work_finish", "work_fail"].includes(parsed.invocation.operation);
+}
+/** The native daemon has already retained this exact delivery; the CLI will
+ * verify and materialize it before admitting the issued Work invocation. */
+export function retainedWorkStartHookCommand(command, binding) {
+    const retained = object(binding), parsed = parseLifecycleCommand(command);
+    return parsed.kind === "standalone" && parsed.invocation.operation === "work_start"
+        && Boolean(commandOption(parsed.invocation, "invocation-id"))
+        && retained.schema_id === "dd-flow/hook-request@1" && retained.source_harness === "codex-desktop"
+        && retained.native_command === command && typeof retained.request_id === "string" && retained.request_id.length > 0;
+}
+export function nativeHookAssignedSettlement(args, stdin, env) {
+    const before = beforeCommand(args, stdin);
+    return Boolean(before && assignedLifecycleHookCommand(before.command, env));
 }

package/dist/cli/run-cli.js

@@ -3,13 +3,14 @@ import { prepareResponseDestination, writeResponseFile } from "./response-file.j
 import { preparePromptDelivery, publishPromptDelivery } from "../services/prompt-delivery.js";
 import { requiredOption, optionalOption, optionalNumber, optionalPositiveNumber } from "./argument-values.js";
 import { resolveCommandPaths, resolveCommandProjectRoot } from "../services/command-context.js";
-import { assertAuxiliaryCommandScope, cliManagedInvocationScope, manualRecoveryInvocationScope, assertManualRecoveryInvocationTarget } from "../services/lifecycle-invocations.js";
+import { assertAuxiliaryCommandScope, cliManagedInvocationScope, manualRecoveryInvocationScope, assertManualRecoveryInvocationTarget, currentAssignedLifecycle } from "../services/lifecycle-invocations.js";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { quote } from "shell-quote";
 import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../services/lifecycle-invocations.js";
 import { verifyCodexHookDelivery } from "../services/codex-hook-delivery.js";
 import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, bindLifecyclePublishedPacket, expandLifecycleInvocationArgs, issueLifecycleInvocation, prepareLifecycleIssuance, lifecycleInvocationScope, observedLifecycleDiagnostic, observedLifecycleInvocation, resolveObservedLifecycleArgs, retainObservedLifecycleSemantics, settleLifecycleInvocation, settleLifecyclePreparationRejection, settleLifecycleRejection, validateLifecyclePathAliases } from "../services/lifecycle-invocations.js";
+import { readAcceptedAssignedWork } from "../services/assigned-lifecycle.js";
 import { createContext, createRouterContext } from "../runtime/context.js";
 import { dispatchNativeHook, isNativeHookIngress } from "./native-hook-ingress.js";
 import { isRuntimeMaintenance, runtimeMaintenanceDiagnostics, withMaintenanceDiagnosticScope } from "./runtime-maintenance-diagnostics.js";
@@ -66,9 +67,43 @@ import { applyVnextMerge, getVnextMergeRequest, isVnextMergeRun, prepareVnextMer
 import { sdlcStageHandlers } from "../services/stage-handlers.js";
 import { startMemoryStage, finishMemoryStage, startMemoryUpgradeStage, finishMemoryUpgradeStage } from "../services/memory-stage-dispatch.js";
 import { startDiagnosticStage, finishDiagnosticStage } from "../services/diagnostic-stage-handlers.js";
+import { startDistillStage, finishDistillStage } from "../services/distill-stage-handlers.js";
+import { startMemoryFixStage } from "../services/memory-fix-stage-entry.js";
+import { finishMemoryFixStage } from "../services/memory-fix-stage-handlers.js";
+import { startReviewFixStage } from "../services/review-fix-stage-entry.js";
+import { finishReviewFixStage } from "../services/review-fix-stage-handlers.js";
+import { startInteractiveStage } from "../services/interactive-stage-entry.js";
+import { isDeliveryFlow } from "../domain/delivery-flows.js";
+import { startDeliveryStage, readDeliveryStageScope, assertDeliveryCommandOwner } from "../services/delivery-stage-entry.js";
+import { finishDeliveryStage } from "../services/delivery-stage-handlers.js";
+import { prepareDeliveryChecks } from "../services/delivery-checks.js";
+import { executeDeliveryOperation } from "../services/delivery-operation.js";
+import { observeDeliveryResult } from "../services/delivery-result.js";
+import { prepareDeliveryProjectBinding } from "../services/delivery-policy.js";
+import { deliveryApprovalScope } from "../services/delivery-approval.js";
+import { issueDeliveryStageCommands } from "../services/delivery-stage-commands.js";
+import { readDescriptorStageInput } from "../services/descriptor-stage-coordinator.js";
+import { readAcceptedStageData } from "../services/stage-report-renderer.js";
+import { finishInteractiveStage, registerInteractiveReviewCorrection, registerInteractiveCorrectionReview } from "../services/interactive-stage-handlers.js";
+import { observeInteractiveOriginalGitInputs } from "../services/interactive-finish-integration.js";
+import { readInteractiveUserInputs } from "../services/interactive-user-inputs.js";
+import { deliverInteractiveUserInput } from "../services/interactive-input-delivery.js";
+import { PreparedInteractiveMutationScope } from "../services/interactive-mutation-scope.js";
+import { PreparedInteractiveChecks } from "../services/interactive-checks.js";
+import { registerInteractiveStageGraph } from "../services/interactive-work-registration.js";
+import { readInteractiveWorkGit } from "../services/interactive-work-start.js";
+import { integrateInteractiveFinish } from "../services/interactive-git-dispatch.js";
+import { readMemoryFixSourceIntake } from "../services/memory-fix-intake-custody.js";
+import { readMemoryFixUserInputs } from "../services/diagnostic-repair-intake.js";
+import { prepareMemoryFixScopeEvidence } from "../services/memory-fix-scope.js";
+import { prepareMemoryFixPublication } from "../services/memory-fix-publication.js";
+import { integrateMemoryFixFinish } from "../services/memory-fix-git-dispatch.js";
 import { isDiagnosticFlow } from "../domain/diagnostic-flows.js";
 import { bindStageCoordinatorWork } from "../services/work-registry.js";
 import { registerMemoryCompositionFromStage, publishMemoryUpgradeFromStage } from "../services/memory-compose-handler.js";
+import { publishDistillFromStage } from "../services/distill-promotion.js";
+import { readDistillUserInputs } from "../services/distill-user-inputs.js";
+import { hybridDigest } from "../services/hybrid-contracts.js";
 import { runMemoryVerificationChecks } from "../services/memory-verify-handler.js";
 import { registerMemoryReviewFromStage, collectMemoryInitialReviewFromStage } from "../services/memory-review-handler.js";
 import { PreparedRetainedMemoryReviewAuthority } from "../services/memory-retained-review-authority.js";
@@ -77,7 +112,7 @@ import { registerMemoryCorrectionsFromStage, registerMemorySecondCorrectionsFrom
 import { integrateMemoryFinishFromStage, registerMemoryFinishEvidenceFromStage } from "../services/memory-finish-handler.js";
 import { registerMemoryRepairBaselineFromStage, registerMemorySecondRepairBaselineFromStage, reserveMemoryRepairWriterCopyFromStage, reserveMemorySecondRepairCopyFromStage, materializeMemoryRepairWriterCopyFromStage, materializeMemorySecondRepairCopyFromStage, prepareMemoryRepairDispatchFromStage, prepareMemorySecondRepairDispatchFromStage, registerMemoryRepairCurrentViewFromStage, registerMemorySecondRepairCurrentViewFromStage, registerMemoryRepairPublicationSourceFromStage, reserveMemoryRepairPublicationAgainstSourceFromStage, reserveMemorySecondRepairPublicationFromStage, applyMemoryRepairPublicationFromStage, applyMemorySecondRepairPublicationFromStage, finishMemoryRepairPublicationFromStage, finishMemorySecondRepairPublicationFromStage } from "../services/memory-review-handler.js";
 import { mergeServerStatus, serveMergeRequests, stopMergeServer } from "../services/merge-server.js";
-import { getVnextFanoutStatus, memoryStageFanoutDescriptor, diagnosticStageFanoutDescriptor, observeVnextNativeChildren, prepareNativeObservations, reconcileVnextFanout } from "../services/vnext-fanout.js";
+import { getVnextFanoutStatus, registeredStageFanoutDescriptor, observeVnextNativeChildren, prepareNativeObservations, reconcileVnextFanout } from "../services/vnext-fanout.js";
 import { pauseStageForUser, resumeStageAfterUser, prepareStagePause, prepareStageResume, stagePauseCommand } from "../services/stage-pause.js";
 import { runtimeCommand } from "../services/runtime-command.js";
 import { managedLifecycleCommand } from "../services/lifecycle-invocations.js";
@@ -132,6 +167,10 @@ async function runCliRequest(args, io, env) {
     let output;
     try {
         output = parseOutputOptions(args);
+        // Expand before routing/context selection, after stripping transport flags.
+        // The alias keeps the existing RUN's engine and prepared-store rules.
+        if (output.args[0] === "finish")
+            output.args = ["interactive", "finish", ...output.args.slice(1)];
     }
     catch (error) {
         const rejection = isAppError(error) ? error : new AppError("usage", error instanceof Error ? error.message : String(error), 2);
@@ -349,6 +388,7 @@ async function runCliRequest(args, io, env) {
         // after admission; retained outcomes must not need a fresh hook receipt.
         if (invocationId) {
             const command = quote(["dd-flow", ...invocationArgs]);
+            let nextNativeObservation = 0;
             const admission = await awaitLifecycleInvocation(dispatchContext, { id: invocationId, command,
                 validateArgs: () => {
                     try {
@@ -362,7 +402,14 @@ async function runCliRequest(args, io, env) {
                     }
                 },
                 prepare: async () => { preparedInput = await prepareCliInput(invocationArgs, dispatchContext, io, scopeProjectRoot, output.responseFile, preparedRoute, commandProgress(io, output)); },
-                assertCurrent: scope => assertLifecycleInvocationCurrent(dispatchContext, scope, command), progress: commandProgress(io, output) });
+                assertCurrent: scope => assertLifecycleInvocationCurrent(dispatchContext, scope, command), progress: commandProgress(io, output),
+                ...((env.DD_FLOW_RUNTIME_OWNER || env.DD_FLOW_CODEX_STATE_DIR || env.DD_AGY_STATE_DIR || env.DD_GROK_STATE_DIR || env.DD_ZCODE_STATE_DIR) ? { reconcileNativeObservation: async (scope, onProgress) => {
+                        if (Date.now() < nextNativeObservation)
+                            return;
+                        nextNativeObservation = Date.now() + 250;
+                        const { reconcileRetainedNativeHook } = await import("../services/retained-native-hook.js");
+                        await reconcileRetainedNativeHook(dispatchContext, { scope, invocationId, onProgress });
+                    } } : {}) });
             if (admission.replay) {
                 retainedOutcome = admission.outcome;
                 settleHook = undefined;
@@ -372,8 +419,10 @@ async function runCliRequest(args, io, env) {
                 invocationSettlement = { context: dispatchContext, id: invocationId };
                 if (observedInvocation)
                     retainObservedLifecycleSemantics(dispatchContext, invocationId, invocationArgs);
-                dispatchArgs = [...invocationArgs, "--hook-event-id", admission.eventKey];
-                preparedInput?.route?.parsed.options.set("hook-event-id", [admission.eventKey]);
+                if (admission.kind === "native_hook") {
+                    dispatchArgs = [...invocationArgs, "--hook-event-id", admission.eventKey];
+                    preparedInput?.route?.parsed.options.set("hook-event-id", [admission.eventKey]);
+                }
                 dispatchContext.env.DD_FLOW_INVOCATION_SCOPE = JSON.stringify(lifecycleInvocationScope(dispatchContext, invocationId));
                 dispatchContext.env.DD_FLOW_CURRENT_INVOCATION = invocationId;
             }
@@ -498,6 +547,23 @@ async function runCliRequest(args, io, env) {
                 io.stderr.write(`Invocation settlement persistence failed: ${String(persistenceError)}\n`);
             }
         }
+        if (invocationSettlement && error.details.work_result_accepted === true) {
+            const accepted = readAcceptedAssignedWork(invocationSettlement.context, invocationSettlement.id);
+            if (accepted) {
+                // The Work/WorkSession commit is authoritative. Report its retained
+                // answer even if a derivative publication failed after that commit.
+                const payload = addWarnings(accepted, [{ code: "work_post_commit_pending", message: "Work result accepted; derivative publication requires reconciliation" }]);
+                try {
+                    writeResponseFile(payload, output);
+                }
+                catch { /* Accepted SQL reply remains available on stdout/replay. */ }
+                if (output.json)
+                    writeJson(io.stdout, payload);
+                else
+                    io.stdout.write(renderHumanResult(output.args, payload));
+                return completedCommandExitCode(payload);
+            }
+        }
         if (settleHook) {
             try {
                 settleHook({ error: isAppError(error) ? error : { code: "unexpected", message: String(error), details: {} } });
@@ -560,6 +626,9 @@ function databaseModeForCommand(args, classification) {
     if (isRuntimeMaintenance(args))
         return "read_existing";
     const [family, command] = args;
+    // Bound interactive operations never initialize or migrate a RUN store.
+    if (family === "interactive" && classification.mode !== "read_only_diagnostics")
+        return "prepared_existing";
     if (family === "migration" && command === "readiness")
         return "prepared_existing";
     // Managed attempts are issued only from a prepared store. Opening that
@@ -872,6 +941,57 @@ async function prepareCliInput(...args) {
 async function prepareCliInputValue(args, context, io, scopeProjectRoot, responseFile = null, route = prepareCommandRoute(args), progress) {
     const { family, command, parsed } = route;
     const prepared = { route };
+    if (family === "delivery" && ["checks", "execute"].includes(command ?? "")) {
+        const file = requiredOption(parsed, "result-file"), text = prepareTextFile(file, "Delivery input", 1024 * 1024);
+        const value = prepareJsonText(text.text, { file, label: "Delivery input" }).value;
+        const keys = command === "checks" ? "path,sha256,subject_ref,version" : "basis,expires_at,reason,scope_sha256,user_inputs_sha256";
+        if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== keys)
+            throw new AppError("usage", "Delivery input must match the selected command's exact JSON contract", 2, { phase: "prepare", effect: "no_effect" });
+        if (command === "checks")
+            prepared.deliveryArtifact = value;
+        else
+            prepared.deliveryApproval = value;
+    }
+    if (family === "interactive" && command === "integrate" && hasOption(parsed, "result-file")) {
+        const file = requiredOption(parsed, "result-file"), input = prepareTextFile(file, "Interactive Git agreement", 1024 * 1024);
+        const value = prepareJsonText(input.text, { file, label: "Interactive Git agreement" }).value;
+        if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== "basis,include_existing_paths,reason")
+            throw new AppError("usage", "Interactive Git agreement requires basis, include_existing_paths and reason", 2, { phase: "prepare", effect: "no_effect" });
+        prepared.interactiveGitAgreement = value;
+    }
+    if (family === "interactive" && command === "checks") {
+        const file = requiredOption(parsed, "result-file"), input = prepareTextFile(file, "Interactive check selection", 1024 * 1024);
+        const value = prepareJsonText(input.text, { file, label: "Interactive check selection" }).value;
+        if (!value || typeof value !== "object" || Array.isArray(value)
+            || !["additionalChecks", "additionalChecks,noChecksReason"].includes(Object.keys(value).sort().join()))
+            throw new AppError("usage", "Interactive checks require additionalChecks and optional noChecksReason", 2, { phase: "prepare", effect: "no_effect" });
+        prepared.interactiveChecksProposal = value;
+    }
+    if (family === "interactive" && command === "scope") {
+        const file = requiredOption(parsed, "result-file"), input = prepareTextFile(file, "Interactive mutation scope", 1024 * 1024);
+        const value = prepareJsonText(input.text, { file, label: "Interactive mutation scope" }).value;
+        if (!value || typeof value !== "object" || Array.isArray(value)
+            || Object.keys(value).sort().join() !== "basis,expectedInputsSha256,paths,reason,requestId")
+            throw new AppError("usage", "Interactive scope requires requestId, paths, basis, reason and expectedInputsSha256", 2, { phase: "prepare", effect: "no_effect" });
+        const basis = recordObject(recordObject(value).basis);
+        if (!basis || Object.keys(basis).sort().join() !== "event_id,role,sha256"
+            || !["request", "turn", "answer", "finish"].includes(String(basis.role))
+            || typeof basis.event_id !== "number" || !Number.isSafeInteger(basis.event_id) || basis.event_id < 0
+            || typeof basis.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(basis.sha256))
+            throw new AppError("usage", "Interactive scope basis requires role request|turn|answer|finish, a nonnegative integer event_id and a SHA-256", 2, {
+                reason: "invalid_scope_basis_shape", phase: "prepare", effect: "no_effect", recoverable: true,
+                retry_command: runtimeCommand(context, ["interactive", "scope", "--project-root", requiredOption(parsed, "project-root"),
+                    "--run", requiredOption(parsed, "run"), "--result-file", file, "--json", "--progress-jsonl"]),
+                retry_instruction: "Correct only the rejected basis shape. For the original request use role=request, event_id=0 and initial_request.sha256 from interactive inputs. For a later user message copy its exact role, integer event_id and sha256 from messages; a question is not user approval. No scope was retained by this call. Reuse this exact retry_command; valid-shaped but unowned evidence or conflicting accepted scope identities remain refusals."
+            });
+        prepared.interactiveScopeProposal = value;
+    }
+    if (family === "interactive" && (command === "turn" || command === "finish")) {
+        const input = prepareTextFile(requiredOption(parsed, "intake-file"), "Interactive user input", 1024 * 1024);
+        prepared.interactiveInputBytes = Buffer.from(input.text);
+        if (!prepared.interactiveInputBytes.length || !/^[a-f0-9]{64}$/.test(requiredOption(parsed, "expected-inputs-sha256")))
+            throw new AppError("usage", "Interactive delivery requires nonempty UTF-8 input and its current input digest", 2, { phase: "prepare", effect: "no_effect" });
+    }
     if (optionalOption(parsed, "reason-file")) {
         const value = prepareJsonFile(requiredOption(parsed, "reason-file"), "Check recovery evidence").value;
         if (!value || typeof value.reason !== "string" || !value.reason.trim() || Object.keys(value).some(key => key !== "reason"))
@@ -1232,7 +1352,7 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
             const bundle = readFlowRunExecutionBundle(context, { projectRoot: requiredOption(parsed, "project-root"), runId: requiredPosition(parsed, 0, "run-id") });
             if (bundle)
                 prepared.stageBindingBundle = { stage, bundle, ...(contextSha256 ? { contextSha256 } : {}) };
-            if (bundle && (["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) || isDiagnosticFlow(bundle.descriptor.descriptor.id))) {
+            if (bundle && (["interactive", "mb-init", "mb-upgrade", "mb-distill", "mb-fix", "review-fix"].includes(bundle.descriptor.descriptor.id) || isDiagnosticFlow(bundle.descriptor.descriptor.id) || isDeliveryFlow(bundle.descriptor.descriptor.id))) {
                 bundle.descriptor.stage(stage);
                 if (hasOption(parsed, "dir"))
                     throw new AppError("usage", "Memory stage layout belongs to its frozen descriptor", 2);
@@ -1240,7 +1360,7 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
                 if (loaded)
                     prepared.stageStart = { externalContext: loaded };
                 prepared.memoryStage = { operation: "start", bytes: loaded ? Buffer.from(loaded.bytes) : Buffer.alloc(0),
-                    flowId: isDiagnosticFlow(bundle.descriptor.descriptor.id) ? bundle.descriptor.descriptor.id : bundle.descriptor.descriptor.id === "mb-upgrade" ? "mb-upgrade" : "mb-init" };
+                    flowId: isDeliveryFlow(bundle.descriptor.descriptor.id) ? bundle.descriptor.descriptor.id : bundle.descriptor.descriptor.id === "interactive" ? "interactive" : bundle.descriptor.descriptor.id === "review-fix" ? "review-fix" : bundle.descriptor.descriptor.id === "mb-fix" ? "mb-fix" : bundle.descriptor.descriptor.id === "mb-distill" ? "mb-distill" : isDiagnosticFlow(bundle.descriptor.descriptor.id) ? bundle.descriptor.descriptor.id : bundle.descriptor.descriptor.id === "mb-upgrade" ? "mb-upgrade" : "mb-init" };
                 return prepared;
             }
         }
@@ -1345,7 +1465,8 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
         prepared.observations = prepareNativeObservations(prepareJsonFile(requiredOption(parsed, "observations-file"), "native observations").value);
     }
     if (family === "memory" && (["compose", "corrections"].includes(command ?? "") && parsed.positional[0] === "register"
-        || command === "repair" && parsed.positional[0] === "publication-reserve")) {
+        || command === "repair" && parsed.positional[0] === "publication-reserve"
+        || command === "distill" && parsed.positional[0] === "publish")) {
         try {
             const bytes = prepareFileBytes(requiredOption(parsed, "result-file"), `Memory ${command} result`, 1024 * 1024).bytes;
             if (!bytes.length || bytes.length > 1024 * 1024)
@@ -1359,6 +1480,12 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
             throw error;
         }
     }
+    if (family === "memory" && command === "fix" && ["scope", "publish", "integrate"].includes(parsed.positional[0] ?? "") && hasOption(parsed, "result-file")) {
+        const file = requiredOption(parsed, "result-file"), input = prepareTextFile(file, "Memory repair proposal", 1024 * 1024);
+        prepared.memoryFixProposal = prepareJsonText(input.text, { file, label: "Memory repair proposal" }).value;
+        if (!prepared.memoryFixProposal || typeof prepared.memoryFixProposal !== "object" || Array.isArray(prepared.memoryFixProposal))
+            throw new AppError("usage", "Memory repair proposal must be a JSON object", 2, { phase: "prepare", effect: "no_effect" });
+    }
     if (family !== "stage" || command !== "finish")
         return prepared;
     const projectRoot = requiredOption(parsed, "project-root");
@@ -1375,9 +1502,9 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
     const resultFile = optionalOption(parsed, "result-file") ?? semanticFile;
     const runtime = run(projectRoot, runId);
     const retainedFlowId = JSON.parse(runtime.indexJson).execution_bundle?.flow_id;
-    if (["mb-init", "mb-upgrade"].includes(retainedFlowId) || isDiagnosticFlow(retainedFlowId)) {
+    if (["interactive", "mb-init", "mb-upgrade", "mb-distill", "mb-fix", "review-fix"].includes(retainedFlowId) || isDiagnosticFlow(retainedFlowId) || isDeliveryFlow(retainedFlowId)) {
         const bundle = readFlowRunExecutionBundle(context, { projectRoot, runId });
-        if (!bundle || !["mb-init", "mb-upgrade"].includes(bundle.descriptor.descriptor.id) && !isDiagnosticFlow(bundle.descriptor.descriptor.id))
+        if (!bundle || !["interactive", "mb-init", "mb-upgrade", "mb-distill", "mb-fix", "review-fix"].includes(bundle.descriptor.descriptor.id) && !isDiagnosticFlow(bundle.descriptor.descriptor.id) && !isDeliveryFlow(bundle.descriptor.descriptor.id))
             throw new AppError("cli_input_unprepared", "Registered RUN bundle is unavailable", 1);
         bundle.descriptor.stage(stage);
         if (["dir", "outcome", "decision-file", "verification-file", "retry-check", "reason", "reason-file", "request", "work"].some(option => hasOption(parsed, option)))
@@ -1387,7 +1514,7 @@ async function prepareCliInputValue(args, context, io, scopeProjectRoot, respons
         const bytes = resultStdin ? Buffer.from(await readStdin(io.stdin, 1024 * 1024)) : prepareFileBytes(resultFile, "Memory stage result", 1024 * 1024).bytes;
         if (!bytes.length || bytes.length > 1024 * 1024)
             throw new AppError("usage", "Memory stage result exceeds its byte bound", 2);
-        prepared.memoryStage = { operation: "finish", bytes, flowId: isDiagnosticFlow(bundle.descriptor.descriptor.id) ? bundle.descriptor.descriptor.id : bundle.descriptor.descriptor.id === "mb-upgrade" ? "mb-upgrade" : "mb-init" };
+        prepared.memoryStage = { operation: "finish", bytes, flowId: isDeliveryFlow(bundle.descriptor.descriptor.id) ? bundle.descriptor.descriptor.id : bundle.descriptor.descriptor.id === "interactive" ? "interactive" : bundle.descriptor.descriptor.id === "review-fix" ? "review-fix" : bundle.descriptor.descriptor.id === "mb-fix" ? "mb-fix" : bundle.descriptor.descriptor.id === "mb-distill" ? "mb-distill" : isDiagnosticFlow(bundle.descriptor.descriptor.id) ? bundle.descriptor.descriptor.id : bundle.descriptor.descriptor.id === "mb-upgrade" ? "mb-upgrade" : "mb-init" };
         return prepared;
     }
     const terminalReplay = (name) => {
@@ -1776,12 +1903,12 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
         const externalContext = prepared.stageStart?.externalContext;
         if (prepared.memoryStage?.operation === "start") {
             const runId = requiredPosition(parsed, 0, "run-id");
-            const event = hookEventId ?? findRecentMatchingHookEvent(context, {
+            const event = hookEventId ?? (currentAssignedLifecycle(context) ? undefined : findRecentMatchingHookEvent(context, {
                 projectId: requireProjectByRoot(context, resolveProjectRoot(projectRoot)).id,
                 matchKey: entityReferenceVariants(runId).map(reference => stageStartMatchKey(reference, stage, projectRoot, contextSha256)),
                 errorCode: "trusted_session_binding_required", operation: "Memory stage start"
-            }).eventKey;
-            const work = (isDiagnosticFlow(prepared.memoryStage.flowId) ? startDiagnosticStage : prepared.memoryStage.flowId === "mb-upgrade" ? startMemoryUpgradeStage : startMemoryStage)(context, { projectRoot, runId, stage, bytes: prepared.memoryStage.bytes });
+            }).eventKey);
+            const work = (isDeliveryFlow(prepared.memoryStage.flowId) ? startDeliveryStage : prepared.memoryStage.flowId === "interactive" ? startInteractiveStage : prepared.memoryStage.flowId === "review-fix" ? startReviewFixStage : prepared.memoryStage.flowId === "mb-fix" ? startMemoryFixStage : prepared.memoryStage.flowId === "mb-distill" ? startDistillStage : isDiagnosticFlow(prepared.memoryStage.flowId) ? startDiagnosticStage : prepared.memoryStage.flowId === "mb-upgrade" ? startMemoryUpgradeStage : startMemoryStage)(context, { projectRoot, runId, stage, bytes: prepared.memoryStage.bytes });
             try {
                 const binding = bindStageCoordinatorWork(context, { workId: work.work_id, hookEventId: event, stage,
                     promptPath: work.prompt_path, resultPath: work.result_path, ...(contextSha256 ? { contextSha256 } : {}) });
@@ -1791,9 +1918,12 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
                 const finish = managedLifecycleCommand(context, runtimeCommand(context, ["stage", "finish", runId,
                     "--stage", stage, "--project-root", projectRoot, "--result-file", work.result_path, "--json"]));
                 const pause = stagePauseCommand(context, { projectRoot, runId, stage, workId: work.work_id });
-                const orchestration = memoryStageFanoutDescriptor(context, { projectRoot, runId, stage }) ?? diagnosticStageFanoutDescriptor(context, { projectRoot, runId, stage });
+                // These assignments belong to this native coordinator delivery, not to
+                // the immutable semantic packet restored by auxiliary owners.
+                const deliveryInstructions = isDeliveryFlow(prepared.memoryStage.flowId) ? issueDeliveryStageCommands(context, { flowId: prepared.memoryStage.flowId, projectRoot, runId, stage, stageRoot: path.dirname(work.result_path) }).instructions : "";
+                const orchestration = registeredStageFanoutDescriptor(context, { projectRoot, runId, stage });
                 const delivery = { ...work, binding, ...(orchestration ? { orchestration } : {}), next: { finish_command: finish, pause_command: pause },
-                    worker_prompt_markdown: `${work.worker_prompt_markdown}\n## Current lifecycle commands\n\nWrite the semantic result to the assigned result path, then execute exactly:\n${finish}\n\nFor a required user choice, write the question file named by this command, then execute exactly:\n${pause}\n` };
+                    worker_prompt_markdown: `${work.worker_prompt_markdown}${deliveryInstructions}\n## Current lifecycle commands\n\nWrite the semantic result to the assigned result path, then execute exactly:\n${finish}\n\nFor a required user choice, write the question file named by this command, then execute exactly:\n${pause}\n` };
                 bindLifecyclePublishedPacket(context, delivery.worker_prompt_markdown);
                 return controlLifecycleReply(context, { projectRoot, runId }, delivery);
             }
@@ -1803,6 +1933,8 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
             }
         }
         const claimVnextStageStart = (runId) => {
+            if (currentAssignedLifecycle(context)?.operation === "stage_start")
+                return undefined;
             registerProject(context, { root: projectRoot });
             return findRecentMatchingHookEvent(context, {
                 projectId: requireProjectByRoot(context, resolveProjectRoot(projectRoot)).id,
@@ -1900,12 +2032,12 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
             // Descriptor settlement validates exact coordinator custody and claims
             // the fresh hook atomically with result acceptance. Do not consume it
             // through the SDLC lifecycle owner before that settlement.
-            return controlledReply((isDiagnosticFlow(prepared.memoryStage.flowId) ? finishDiagnosticStage : prepared.memoryStage.flowId === "mb-upgrade" ? finishMemoryUpgradeStage : finishMemoryStage)(context, { projectRoot, runId, stage, bytes: prepared.memoryStage.bytes,
-                hookEventId: hookEventId ?? findRecentMatchingHookEvent(context, {
+            return controlledReply((isDeliveryFlow(prepared.memoryStage.flowId) ? finishDeliveryStage : prepared.memoryStage.flowId === "interactive" ? finishInteractiveStage : prepared.memoryStage.flowId === "review-fix" ? finishReviewFixStage : prepared.memoryStage.flowId === "mb-fix" ? finishMemoryFixStage : prepared.memoryStage.flowId === "mb-distill" ? finishDistillStage : isDiagnosticFlow(prepared.memoryStage.flowId) ? finishDiagnosticStage : prepared.memoryStage.flowId === "mb-upgrade" ? finishMemoryUpgradeStage : finishMemoryStage)(context, { projectRoot, runId, stage, bytes: prepared.memoryStage.bytes,
+                hookEventId: hookEventId ?? (currentAssignedLifecycle(context) ? "" : findRecentMatchingHookEvent(context, {
                     projectId: requireProjectByRoot(context, resolveProjectRoot(projectRoot)).id,
                     matchKey: entityReferenceVariants(runId).map(reference => stageLifecycleMatchKey("stage_finish", reference, stage, projectRoot)),
                     errorCode: "trusted_session_binding_required", operation: "Memory stage finish"
-                }).eventKey }));
+                }).eventKey) }));
         }
         const protectedLifecycle = (stage === "specify" && isVnextSpecifyRun(context, { projectRoot, runId }))
             || (stage === "protocolize" && isVnextProtocolizeRun(context, { projectRoot, runId }))
@@ -2112,6 +2244,102 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
     if (family === "schema") {
         return prepared.schemaValidation;
     }
+    if (family === "delivery") {
+        const projectRoot = requiredOption(parsed, "project-root"), project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
+        const runId = resolveRun(context, project.id, requiredPosition(parsed, 0, "run-id")).id, stage = requiredOption(parsed, "stage");
+        const input = { projectRoot, runId, stage, command: quote(["dd-flow", ...args]) };
+        const selected = command === "inputs" ? readDeliveryStageScope(context, input) : assertDeliveryCommandOwner(context, input);
+        if (command === "checks") {
+            if (!prepared.deliveryArtifact)
+                throw new AppError("cli_input_unprepared", "Delivery artifact was not prepared", 1);
+            const checks = prepareDeliveryChecks(context, { ...input, artifact: prepared.deliveryArtifact });
+            await checks.run();
+            return { ok: true, verification: checks.evidence().receipt };
+        }
+        if (command === "execute") {
+            if (!prepared.deliveryApproval)
+                throw new AppError("cli_input_unprepared", "Delivery approval was not prepared", 1);
+            return executeDeliveryOperation(context, { ...input, approval: prepared.deliveryApproval });
+        }
+        const packet = readDescriptorStageInput(context, selected.scope, selected.bundle);
+        const previous = packet.input.predecessor ? readAcceptedStageData(context, { ...selected.scope, stage: packet.input.predecessor.stage }) : null;
+        const details = previous ? JSON.parse(previous.bytes.toString("utf8")).details : null;
+        const operation = details?.decision && details?.artifact ? deliveryApprovalScope(selected.scope, selected.bundle, { operationId: details.decision.operation_id, binding: details.decision.binding,
+            artifact: { subject_ref: details.artifact.subject_ref, version: details.artifact.version, sha256: details.artifact.sha256 } }) : null;
+        if (command === "inputs")
+            return { flow_id: selected.flowId, run_id: runId, stage, user_inputs: selected.users,
+                user_inputs_sha256: selected.userInputsSha256, operation_scope: operation, scope_sha256: operation ? hybridDigest(operation) : null };
+        if (command === "reconcile") {
+            if (!details?.decision)
+                throw new AppError("delivery_stage_invalid", "Original delivery decision is required", 2, { effect: "no_effect" });
+            const policy = prepareDeliveryProjectBinding(selected.bundle.execution.snapshot().scope.workspace, details.decision.policy, details.decision.binding.selector);
+            if (hybridDigest(policy.binding) !== hybridDigest(details.decision.binding))
+                throw new AppError("delivery_stage_invalid", "Original delivery policy changed", 2, { effect: "no_effect" });
+            return observeDeliveryResult(context, { ...selected.scope, binding: policy.binding,
+                assertCurrent() { assertDeliveryCommandOwner(context, input); policy.assertCurrent(); } });
+        }
+        throw new AppError("usage", "Unknown delivery command", 2);
+    }
+    if (family === "interactive") {
+        const projectRoot = requiredOption(parsed, "project-root"), project = requireProjectByRoot(context, resolveProjectRoot(projectRoot));
+        const runId = resolveRun(context, project.id, requiredOption(parsed, "run")).id;
+        if (command === "integrate")
+            return integrateInteractiveFinish(context, { projectRoot, runId,
+                ...(prepared.interactiveGitAgreement ? { agreement: prepared.interactiveGitAgreement } : {}) });
+        if (command === "correction")
+            return registerInteractiveReviewCorrection(context, { projectRoot, runId, reviewWorkId: requiredOption(parsed, "work") });
+        if (command === "re-review")
+            return registerInteractiveCorrectionReview(context, { projectRoot, runId, correctionWorkId: requiredOption(parsed, "work") });
+        if (command === "checks") {
+            if (!prepared.interactiveChecksProposal)
+                throw new AppError("cli_input_unprepared", "Interactive check selection was not prepared", 1);
+            let checks;
+            try {
+                checks = PreparedInteractiveChecks.prepare(context, { projectRoot, runId,
+                    stage: requiredOption(parsed, "stage"), ...prepared.interactiveChecksProposal });
+            }
+            catch (error) {
+                if (isAppError(error) && error.code === "interactive_checks_invalid"
+                    && error.details.reason === "invalid_check_selection" && error.details.effect === "no_effect") {
+                    Object.assign(error.details, { phase: "prepare", recoverable: true,
+                        retry_command: runtimeCommand(context, ["interactive", "checks", "--project-root", projectRoot, "--run", runId,
+                            "--stage", requiredOption(parsed, "stage"), "--result-file", requiredOption(parsed, "result-file"), "--json", "--progress-jsonl"]),
+                        retry_instruction: "Correct only the rejected check selection JSON: additionalChecks contains unique id,command,purpose entries; IDs match ^CHK-[A-Za-z0-9-]{1,64}$ and must not collide with policy checks. No plan or check execution was retained by this call. Keep existing obligations and use this exact retry_command; this does not authorize replay of executed checks or bypass other refusals." });
+                }
+                throw error;
+            }
+            return checks.execute(context).then(receipts => ({ plan_sha256: checks.sha256, plan: checks.value(), receipts }));
+        }
+        if (command === "register") {
+            const bundle = readFlowRunExecutionBundle(context, { projectRoot, runId });
+            if (!bundle || bundle.manifest.flow_id !== "interactive")
+                throw new AppError("interactive_stage_invalid", "Bound interactive RUN required", 2, { effect: "no_effect" });
+            return registerInteractiveStageGraph(context, { projectRoot, runId, stage: requiredOption(parsed, "stage"),
+                gitExecutable: readInteractiveWorkGit(bundle).git_executable });
+        }
+        if (command === "git-inputs")
+            return observeInteractiveOriginalGitInputs(context, { projectRoot, runId, stage: requiredOption(parsed, "stage") });
+        if (command === "inputs" || command === "turn" || command === "finish" || command === "scope") {
+            const bundle = readFlowRunExecutionBundle(context, { projectRoot, runId });
+            if (!bundle || bundle.manifest.flow_id !== "interactive")
+                throw new AppError("interactive_stage_invalid", "Bound interactive RUN required", 2, { effect: "no_effect" });
+            const scope = { projectId: project.id, runId };
+            if (command === "inputs")
+                return readInteractiveUserInputs(context, scope, bundle);
+            if (command === "scope") {
+                if (!prepared.interactiveScopeProposal)
+                    throw new AppError("cli_input_unprepared", "Interactive scope proposal was not prepared", 1);
+                const result = PreparedInteractiveMutationScope.prepare(context, scope, bundle, prepared.interactiveScopeProposal).retain(context);
+                return { changed: result.changed, scope_revision: result.scope.revision, user_inputs_sha256: result.scope.inputs.sha256,
+                    baseline_sha256: result.scope.baseline.sha256, paths: result.scope.active_paths, needs_scope_refresh: result.scope.needs_scope_refresh };
+            }
+            if (!prepared.interactiveInputBytes)
+                throw new AppError("cli_input_unprepared", "Interactive user bytes were not prepared", 1);
+            return deliverInteractiveUserInput(context, scope, bundle, { projectRoot, intakeFile: requiredOption(parsed, "intake-file"),
+                requestId: requiredOption(parsed, "request-id"), kind: command, bytes: prepared.interactiveInputBytes,
+                expectedInputsSha256: requiredOption(parsed, "expected-inputs-sha256") });
+        }
+    }
     if (family === "memory") {
         return dispatchMemory(context, command, parsed, prepared);
     }
@@ -2502,6 +2730,32 @@ function dispatchMemory(context, command, parsed, prepared) {
     }
     if (command === "upgrade" && subcommand === "publish")
         return publishMemoryUpgradeFromStage(context, scope());
+    if (command === "distill" && subcommand === "inputs") {
+        const inputs = readDistillUserInputs(context, scope());
+        return { ...inputs, user_inputs_sha256: hybridDigest(inputs) };
+    }
+    if (command === "fix" && subcommand === "context") {
+        const intake = readMemoryFixSourceIntake(context, scope()), users = readMemoryFixUserInputs(context, scope());
+        return { ...intake, user_inputs: users, user_inputs_sha256: hybridDigest(users) };
+    }
+    if (command === "fix" && subcommand === "scope") {
+        const proposal = prepared.memoryFixProposal;
+        if (!proposal || Object.keys(proposal).sort().join() !== "routing,write_scope")
+            throw new AppError("usage", "Repair scope proposal requires routing and write_scope", 2, { effect: "no_effect" });
+        return prepareMemoryFixScopeEvidence(context, { ...scope(), routing: proposal.routing, writeScope: proposal.write_scope }).snapshot();
+    }
+    if (command === "fix" && subcommand === "publish") {
+        if (!prepared.memoryFixProposal)
+            throw new AppError("cli_input_unprepared", "Repair proposal was not prepared", 1);
+        return prepareMemoryFixPublication(context, { ...scope(), proposal: prepared.memoryFixProposal }).apply();
+    }
+    if (command === "fix" && subcommand === "integrate")
+        return integrateMemoryFixFinish(context, { ...scope(), ...(prepared.memoryFixProposal ? { agreement: prepared.memoryFixProposal } : {}) });
+    if (command === "distill" && subcommand === "publish") {
+        if (!prepared.memoryOperationBytes)
+            throw new AppError("cli_input_unprepared", "Distillation proposal bytes were not prepared", 1);
+        return publishDistillFromStage(context, { ...scope(), bytes: prepared.memoryOperationBytes });
+    }
     if (command === "verify" && subcommand === "checks")
         return runMemoryVerificationChecks(context, scope());
     if (command === "review" && subcommand === "register")

package/dist/cli.js

@@ -53,12 +53,26 @@ if (args[0] === "upgrade" || args[0] === "flow" && args[1] === "mb-upgrade") {
     const { runMemoryUpgradeCli } = await import("./cli/memory-upgrade.js");
     process.exit(await runMemoryUpgradeCli(args, process.env));
 }
-if (args[0] === "review" || args[0] === "flow" && ["mb-audit", "project-review"].includes(args[1] ?? "")) {
+if (args[0] === "review" || args[0] === "flow" && ["mb-audit", "project-review", "mb-distill", "review-fix"].includes(args[1] ?? "")) {
     publishSetup('ingress_entered');
     const { runDiagnosticCli } = await import("./cli/diagnostic.js");
     publishSetup('imports_ready');
     process.exit(await runDiagnosticCli(args, process.env));
 }
+if (args[0] === "flow" && args[1] === "mb-fix") {
+    publishSetup('ingress_entered');
+    const { runMemoryFixCli } = await import("./cli/memory-fix.js");
+    publishSetup('imports_ready');
+    process.exit(await runMemoryFixCli(args, process.env));
+}
+if (args[0] === "flow" && args[1] === "interactive") {
+    const { runInteractiveCli } = await import("./cli/interactive.js");
+    process.exit(await runInteractiveCli(args, process.env));
+}
+if (args[0] === "flow" && ["release", "deploy", "publish"].includes(args[1] ?? "")) {
+    const { runDeliveryCli } = await import("./cli/delivery.js");
+    process.exit(await runDeliveryCli(args, process.env));
+}
 if (args.slice(0, 3).join(" ") === "runtime storage admit") {
     const { runMemoryStorageAdmissionCli } = await import("./cli/memory-storage-admission.js");
     process.exit(runMemoryStorageAdmissionCli(args));
@@ -75,10 +89,10 @@ if (args.slice(0, 3).join(" ") === "runtime flow admit") {
     const { runMemoryFlowAdmissionCli } = await import("./cli/memory-flow-admission.js");
     process.exit(await runMemoryFlowAdmissionCli(args));
 }
-const managedHook = Boolean(process.env.DD_FLOW_CODEX_STATE_DIR) && args.slice(0, 3).join(" ") === "codex hook handle";
+const codexHook = args.slice(0, 3).join(" ") === "codex hook handle";
 const exitCode = isRuntimeMaintenanceIngress(args, process.env)
     ? await runRuntimeMaintenanceIngress(args)
-    : managedHook
+    : codexHook
         ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
         : isNativeHookIngress(args)
             ? await (await import("./cli/native-hook-ingress.js")).runNativeHookIngress(args)