@deksden-com/dd-flow-cli 0.9.0-beta.152 → 0.9.0-beta.156

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.156
+
+### Patch Changes
+
+- b59c32b: Preserve current lifecycle successors, restore OpenCode retained child admission, and separate Work correction from technical pause and native resource cleanup. Continue an eligible completed child once per Work without replaying unknown effects or treating descriptive deviations as unfinished obligations.
+
+  Observe a concurrent controller-launch winner instead of rejecting an already accepted duplicate resume; retain physical ownership and launch CAS fences.
+
+## 0.9.0-beta.155
+
+Versions beta.153 and beta.154 were used by unpublished preparation candidates; this release uses a new immutable identity. Older pending Changesets below reconcile release accounting rather than claim their functionality is new.
+
+Scoped workers validate only their own consumed inputs; the coordinator retains whole-selection checks. Include integrated E5 flow owners and Changesets prerelease metadata in the reviewed impact map.
+
+Connect the selected E5 and engine-storage Node contracts to their explicit runner groups without changing historical release-candidate@1 requirements.
+
+### Patch Changes
+
+- 025a576: Accept managed lifecycle results through their retained assignments, without a
+  fresh native tool receipt. Preserve accepted work when native retirement fails,
+  report technical notes separately and retain conflicting-writer safeguards.
+- f06d07f: Replace mandatory full release gates with change-impact verification and reusable scoped evidence. Publish component identities for technical EVAL proof reuse without coupling unrelated native adapter changes.
+- fa9d145: Preserve AGY task completion and native profile provenance; validate recursive runner proofs through a portable shared core. Add bounded, effect-fenced transient provider recovery and managed ZCode continuation contracts, and expose immutable browser capability facts to checks.
+- 623b866: Keep native hooks lightweight and admit first child Work through the existing CLI assignment and CAS. Preserve original late-tool identities and failures, extend native verification only on real progress, and prevent historical public callbacks from starving a fresh successor.
+
+  Separate accepted execution from resource retirement, refuse graceful cancellation of newly active required work, and retain shutdown notices as technical evidence. Preserve E5 coordinator and historical result custody with assigned lifecycle execution.
+
+- a2ec242: Scope verification to meaningful per-contract inputs and reuse immutable evidence
+  across release selections and squash-equivalent sources. Isolate bounded jobs,
+  retain exact attempts and prevent orphaned children from freeing verification slots.
+
 ## 0.9.0-beta.151
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.152",
-  "cli_commit": "70ed6da341845d1b7f262b74f6731ac4787aff73",
-  "built_at": "2026-10-26T03:31:35.940Z",
+  "cli_version": "0.9.0-beta.156",
+  "cli_commit": "1a2bd0ea6d022b22e94f552f1cde1fb8e8b6689e",
+  "built_at": "2026-10-28T07:26:47.345Z",
   "built_with_canon": {
-    "version": "4.1.2",
-    "commit": "925ef10ecc0b683f7feba6f74913e15560842500",
+    "version": "4.1.3",
+    "commit": "052ffdf0fff642a46485d2decc79bf78b1970d5e",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-cp253",
-    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-cp253/.memory-bank",
-    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-memorybank-cp253/.memory-bank/dd-flow",
+    "repo_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp260-manifest",
+    "memorybank_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp260-manifest/.memory-bank",
+    "flow_root": "/Users/deksden/Documents/_Projects/_worktrees/dd-canon-cp260-manifest/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/cli/command-inputs.js

@@ -16,7 +16,8 @@ const protocolTransitionInput = route(1, "to", `${scoped} payload-file json-file
 const setupInput = route(0, "request-id trust-file", "canon-source canon-version release-registry channel profile profile-file save-profile-intent", "non-interactive skip-agent-setup", "", { channel: ["stable", "preview", "development"] });
 const memoryInitInput = route(0, "project-root workspace-root request-id", "intake-file intake-sha256 profile profile-file stage-profile work-profile max-parallel delegation native-config-home git-route integration-branch", "detach non-interactive prepare-only allow-live-probe", "stage-profile work-profile", { "git-route": ["integration_branch_direct", "feature_worktree"], delegation: ["external", "native"] });
 const diagnosticInput = route(0, "project-root request-id", "intake-file profile profile-file stage-profile work-profile max-parallel", "detach non-interactive prepare-only", "stage-profile work-profile");
-export const commandAliases = { transition: "protocol transition", init: "flow mb-init", upgrade: "flow mb-upgrade", review: "flow project-review" };
+const interactiveFinishInput = route(0, "project-root run request-id expected-inputs-sha256 intake-file");
+export const commandAliases = { transition: "protocol transition", init: "flow mb-init", upgrade: "flow mb-upgrade", review: "flow project-review", finish: "interactive finish" };
 /** Path-shaped arguments default to physical paths unless the route explicitly
  * opts into contextualPaths. This inventory does not expand arbitrary strings. */
 export const physicalPathOptions = new Set(words("canon-source trust-file root project-root workspace-root workspace-path workspace-path path dir file schema-dir output result-file semantic-file data decision-file verification-file reason-file task-file intake-file context-file observations-file observation-file summary-file question-file answer-file payload-file json-file task-profile-file execution-routing-file protocol-override-file manifest-file routing-file config-file input-file report-file snapshot-file output-dir state-dir capture-root capture-path destination source archive snapshot plan-file backup-path database backup source-home target-home stdout stderr adapter-executable memory-bank flow stage-report dashboard report"));
@@ -28,21 +29,44 @@ physicalPathOptions.add("seed-file");
 physicalPathOptions.add("native-executable");
 physicalPathOptions.add("native-config-home");
 physicalPathOptions.add("operational-decision-file");
+physicalPathOptions.add("workspace");
 export const commandInputs = {
+    "delivery inputs": route(1, "project-root stage"),
+    "delivery checks": route(1, "project-root stage result-file", lifecycle, "", "", { stage: ["prepare", "verify"] }),
+    "delivery execute": route(1, "project-root stage result-file", lifecycle, "", "", { stage: ["publish", "deploy"] }),
+    "delivery reconcile": route(1, "project-root stage", lifecycle, "", "", { stage: ["publish", "deploy", "verify", "finish"] }),
     "version": route(0),
     "flow list": route(0),
+    "flow release": route(0, "project-root request-id", "workspace intake-file profile profile-file stage-profile work-profile max-parallel", "detach prepare-only non-interactive", "stage-profile work-profile"),
+    "flow deploy": route(0, "project-root request-id", "workspace intake-file profile profile-file stage-profile work-profile max-parallel", "detach prepare-only non-interactive", "stage-profile work-profile"),
+    "flow publish": route(0, "project-root request-id", "workspace intake-file profile profile-file stage-profile work-profile max-parallel", "detach prepare-only non-interactive", "stage-profile work-profile"),
+    "flow interactive": route(0, "project-root request-id", "workspace intake-file profile profile-file stage-profile work-profile max-parallel execution git-route integration-branch", "detach prepare-only non-interactive", "stage-profile work-profile", { execution: ["attached", "managed"], "git-route": ["integration_branch_direct", "feature_worktree"] }),
+    "interactive inputs": route(0, "project-root run"),
+    "interactive turn": route(0, "project-root run request-id expected-inputs-sha256 intake-file"),
+    "interactive finish": interactiveFinishInput,
+    "finish": interactiveFinishInput,
+    "interactive scope": route(0, "project-root run result-file"),
+    "interactive checks": route(0, "project-root run stage result-file", "", "", "", { stage: ["hardening", "review"] }),
+    "interactive register": route(0, "project-root run stage", "", "", "", { stage: ["hardening", "review"] }),
+    "interactive correction": route(0, "project-root run work"),
+    "interactive re-review": route(0, "project-root run work"),
+    "interactive integrate": route(0, "project-root run", "result-file"),
+    "interactive git-inputs": route(0, "project-root run stage", "", "", "", { stage: ["preflight", "interactive", "consolidation", "hardening", "review", "integration"] }),
     "flow show": route(1),
     "flow mb-init": memoryInitInput,
     "init": memoryInitInput,
     "flow mb-upgrade": memoryInitInput,
     "upgrade": memoryInitInput,
     "flow mb-audit": diagnosticInput,
+    "flow mb-distill": diagnosticInput,
+    "flow review-fix": route(0, "project-root request-id", "source-run finding intake-file profile profile-file stage-profile work-profile max-parallel", "detach non-interactive prepare-only", "finding stage-profile work-profile"),
+    "flow mb-fix": route(0, "project-root request-id", "workspace-root source-run finding intake-file profile profile-file stage-profile work-profile max-parallel git-route integration-branch", "detach non-interactive prepare-only", "finding stage-profile work-profile", { "git-route": ["integration_branch_direct", "feature_worktree"] }),
     "flow project-review": diagnosticInput,
     "review": diagnosticInput,
     "runtime storage admit": route(0, "operation", "", "", "", { operation: ["memory-init", "memory-upgrade"] }),
     "runtime storage qualify": route(0, "operation", "", "", "", { operation: ["memory-upgrade"] }),
     "runtime storage transition": route(0, "action project-root workspace-root request-id selection-sha256", "expected-sha256 recovery-id", "offline", "", { action: ["plan", "apply", "status", "recovery-plan", "recover", "recovery-status"] }),
-    "runtime flow admit": route(0, "operation", "", "", "", { operation: ["memory-init", "memory-upgrade", "mb-audit", "project-review"] }),
+    "runtime flow admit": route(0, "operation", "", "", "", { operation: ["memory-init", "memory-upgrade", "mb-audit", "project-review", "mb-distill", "mb-fix", "review-fix", "interactive", "release", "deploy", "publish"] }),
     "completion bash": route(0),
     "completion zsh": route(0),
     "completion fish": route(0),
@@ -147,7 +171,7 @@ export const commandInputs = {
     "run recovery capture": route(1, `${project} recovery-id capture-path`),
     "run recovery resume": route(1, `${project} recovery-id daemon-id harness native-session-id`),
     "run recovery accept": { ...route(1, `${project} recovery-id`, lifecycle), contextualPaths: ["project-root"] },
-    "run snapshot bootstrap create": route(0, `${project} output flow`),
+    "run snapshot bootstrap create": route(0, `${project} output`, "flow"),
     "run snapshot bootstrap restore": route(0, `${project} snapshot`),
     "run snapshot create": route(1, `${project} output`, "recovery-id stage-entry", "candidate incomplete"),
     "run snapshot restore": route(0, `${project} snapshot`, "execution-routing-file operational-decision-file recovery-id"),
@@ -275,6 +299,12 @@ export const commandInputs = {
     "memory permissions preflight": route(0, "root memory-bank flow mode", "tasks"),
     "memory compose register": route(0, "project-root run request-key result-file"),
     "memory upgrade publish": route(0, "project-root run"),
+    "memory distill inputs": route(0, "project-root run"),
+    "memory distill publish": route(0, "project-root run result-file"),
+    "memory fix context": route(0, "project-root run"),
+    "memory fix scope": route(0, "project-root run result-file"),
+    "memory fix publish": route(0, "project-root run result-file"),
+    "memory fix integrate": route(0, "project-root run", "result-file"),
     "memory verify checks": route(0, "project-root run"),
     "memory review register": route(0, "project-root run"),
     "memory review collect": route(0, "project-root run"),

package/dist/cli/command-metadata.js

@@ -60,7 +60,60 @@ const memoryInitOptions = {
     "profile-file": "Absolute regular JSON file with one complete validated operation-only executor profile. Exclusive with --profile; never saves settings or changes defaults. Omit on replay to reuse frozen bytes; supplied profile content must match the original selection.",
     "non-interactive": "Never open the first-flow executor dialog, even on a terminal. Without an explicit profile/file or configured default, refuse before project effects; init cannot skip its executor."
 };
+const deliveryLaunchOptions = {
+    "intake-file": "Original bounded UTF-8 user request. Required fresh; supplied replay text must equal the retained original. Starting delivery is not publication or deployment approval.",
+    workspace: "Existing canonical assigned Git checkout. Fresh defaults to project root; omitted replay preserves the original workspace. Never uses a diagnostic clone.",
+    "stage-profile": "Repeatable known stage=profile assignment for this delivery descriptor. Frozen before RUN creation; independent verify uses a separate physical Session.",
+    "profile-file": "Absolute JSON operation-only executor profile, exclusive with --profile. Does not save settings; omitted replay uses the retained selection.",
+    "prepare-only": "Retain or replay one request-bound delivery RUN without launching its controller. Publishes runtime state, not a dry run or permission to mutate the delivery target. Exclusive with --detach."
+};
 const commandOptionDescriptions = {
+    "flow release": deliveryLaunchOptions,
+    "flow deploy": deliveryLaunchOptions,
+    "flow publish": deliveryLaunchOptions,
+    "delivery inputs": { stage: "Bound delivery Stage. Read original request/answers and the accepted operation scope when available; never grants approval." },
+    "delivery checks": { stage: "Current prepare or verify Stage; issued coordinator command only. Uses project CODE/readiness checks and actual artifact bytes.", "result-file": "Exact artifact JSON: path (workspace-relative), subject_ref, version and sha256. No commands or invented check receipts. Omit neither required checks nor artifact selection." },
+    "delivery execute": { stage: "Current publish or deploy Stage, bound to the physically admitted coordinator. Does not finish the Stage or RUN.", "result-file": "Exact scoped approval JSON: scope_sha256, user_inputs_sha256, basis (role=request|answer,event_id,sha256), expires_at and reason. Copy scope/input references from delivery inputs; startup, a question or authentication is not approval. Unknown effects require reconciliation, not retry." },
+    "delivery reconcile": { stage: "Current owned delivery Stage. Run only the original read-only result procedure and retain observation after physical command settlement. Never republishes, rolls back, switches account or grants retry." },
+    "flow interactive": {
+        "non-interactive": "Never open executor selection. A fresh request needs an explicit profile/file or configured default; the executor cannot be skipped and no profile is saved.",
+        "profile-file": "Absolute regular JSON file with a complete validated operation-only executor profile; exclusive with --profile. Does not save settings. Omitted replay uses retained selection; supplied content must match.",
+        workspace: "Optional existing canonical assigned checkout. Defaults to project root for a fresh request; omitted replay uses the original workspace. Does not create a worktree or widen Git scope.",
+        execution: "Defaults to attached: requires a unique current trusted hook observation of this exact argv, workspace and profile. Managed must be selected explicitly; no automatic fallback.",
+        "intake-file": "Original bounded nonempty UTF-8 request, up to 64 KiB. Required fresh; supplied replay bytes must match exactly. Current turns and answers remain separate retained inputs.",
+        "prepare-only": "Retain the original request and allocate its RUN without starting controller/provider execution. Attached also publishes immutable context candidates. Not a dry run; exclusive with --detach.",
+        detach: "Managed execution only. Return the existing controller receipt without foreground observation; disconnect never stops its owner.",
+        "stage-profile": "Repeatable preflight/interactive/consolidation/hardening/review/integration=profile selection. Frozen before dispatch; attached same-session constraints still apply.",
+        "work-profile": "Repeatable allowed author/critic executor profile. Work still uses existing physical Session and independence admission.",
+        "git-route": "Explicit local integration route, paired with --integration-branch; otherwise use project workspace policy. No push permission. Feature route requires an already assigned --workspace.",
+        "max-parallel": "External Work concurrency from 1 to 64, default 1; does not combine author and critic identities or qualify native capacity."
+    },
+    "flow review-fix": {
+        "project-root": "Canonical absolute source project. Review-fix uses a private read-only snapshot; it does not repair code or integrate Git changes.",
+        "source-run": "Exact completed mb-audit or project-review RUN. Required with --finding for a fresh request; omitted replay uses the retained original source, never the latest report.",
+        finding: "Repeat for each explicitly selected accepted finding ID, in retained order. No implicit all-findings scope; selecting a finding is not approval to implement it.",
+        "intake-file": "Original bounded UTF-8 user request and constraints. Required fresh; supplied replay bytes must match. Actual delivered answers remain part of scope assessment, not an agent-authored replacement specification.",
+        "stage-profile": "Repeatable intake/scope-review/handoff=profile assignment, frozen before dispatch. Scope-review requires a physically independent new Session; each stage may use a different supported profile.",
+        "prepare-only": "Retain the request, private source snapshot and review-fix RUN without launching controller/provider Sessions. Creates runtime state, not a dry run or downstream SDLC task. Exclusive with --detach.",
+        "max-parallel": "Frozen external Work concurrency limit from 1 to 64, default 1. The three root stages remain sequential; this does not combine intake and independent scope-review Sessions."
+    },
+    "flow mb-fix": {
+        "source-run": "Completed mb-audit or project-review RUN containing accepted findings. Required with explicit findings for a fresh request; omitted replay reuses the original source, never the latest audit.",
+        finding: "Repeat for each selected finding ID from --source-run. Order and exact IDs are retained; no implicit all-findings selection. Selection alone is not write approval.",
+        "workspace-root": "Optional canonical absolute existing repair workspace. Otherwise the launcher prepares the policy-selected workspace; replay uses its retained workspace, not the current shell directory.",
+        "intake-file": "Bounded UTF-8 original repair request and constraints. Required fresh; supplied replay bytes must match. Scope and consent are assessed at intake before document publication.",
+        "stage-profile": "Repeatable intake/repair/verify/review/finish=profile override. Profiles are frozen; verify and review require independent physical Sessions.",
+        "prepare-only": "Prepare or replay the retained repair RUN without launching controller/provider Sessions. Creates runtime/workspace state, not a dry run or semantic repair acceptance. Exclusive with --detach.",
+        "git-route": "Explicit feature_worktree or integration_branch_direct paired with --integration-branch; otherwise use project workspace policy. Never authorizes push or unrelated commits.",
+        "max-parallel": "External Work concurrency from 1 to 64, default 1. Does not combine author, verifier and reviewer Sessions or advertise native qualification."
+    },
+    "flow mb-distill": {
+        "project-root": "Canonical absolute source project identity. Extraction uses an isolated read-only snapshot; promotion requires a separately accepted destination and exact write scope.",
+        "intake-file": "Bounded UTF-8 original distillation request, intended reusable practices and constraints. Required fresh; supplied replay bytes must match the retained request. Does not grant destination write authority.",
+        "stage-profile": "Repeatable preflight/extract/review/promote/verify/finish=profile override. All profiles are frozen before dispatch; verification requires an independent physical Session.",
+        "prepare-only": "Retain the request, source snapshot and RUN without launching a controller or provider Sessions. Creates runtime state, not destination changes; not a dry run.",
+        "max-parallel": "External extraction and critic Work concurrency from 1 to 64; default 1. Changes scheduling, not required aspect coverage."
+    },
     "flow mb-audit": {
         "project-root": "Canonical absolute project identity. The runtime creates an isolated read-only source snapshot; neither the project nor its Memory Bank is a write destination.",
         "intake-file": "Bounded UTF-8 original diagnostic request, including audit mode/focus and constraints. Required for a fresh request; optional on exact replay, where supplied bytes must match.",
@@ -81,7 +134,7 @@ const commandOptionDescriptions = {
     upgrade: { ...memoryInitOptions, "stage-profile": "Repeatable stage=profile assignment for preflight, diff-analysis, upgrade, verify, review or finish. The original selection is frozen before dispatch.", "prepare-only": "Prepare or replay the upgrade RUN and accepted storage/bootstrap selection without launching its controller or a productive Session. This is not a dry run; it does not publish the upgraded canonical layer or accept semantic preservation." },
     "runtime storage admit": { operation: "Operation-specific writable-connection admission: memory-init or memory-upgrade. Upgrade also checks retained request storage. Requires explicit canonical DD_FLOW_HOME and an existing compatible resource registry. Never initializes, migrates, repairs or starts agents." },
     "runtime storage qualify": { operation: "memory-upgrade only. Qualify the selected engine before a native probe. Incompatible drained stores are copied privately with committed WAL; the actual transition and operation admission run on those copies. Requires both explicit canonical Homes. Never migrates real stores, grants productive admission, creates a RUN or starts agents." },
-    "runtime flow admit": { operation: "Handler admission for memory-init or memory-upgrade in the executing engine. Reads bounded UTF-8 JSON stdin with source and source_sha256; memory-init additionally accepts startup_input_schema to require its startup reader. Validates the matching six-stage descriptor using actual registered handlers. Does not establish release trust, storage/provider readiness or semantic completion, and never creates Home, RUN or agents." },
+    "runtime flow admit": { operation: "Handler admission for the selected memory, source-snapshot or project-local interactive flow in the executing engine. Reads bounded UTF-8 JSON stdin with source and source_sha256; interactive requires its retained project pack, not installed canon. memory-init additionally accepts startup_input_schema to require its startup reader. Validates the exact descriptor using actual registered handlers and refuses unsupported handlers. Does not establish release trust, storage/provider readiness or semantic completion, and never creates Home, RUN or agents." },
     "profiles create": { file: "Regular UTF-8 JSON file containing one complete validated agent profile. The ID must be unused. Credentials and unknown fields are refused; creation uses --expected-revision and never starts a model Turn." },
     "profiles edit": { file: "Regular UTF-8 JSON file containing the complete replacement agent profile, not a patch. Its ID must already exist. Revision conflicts refuse the edit; retained RUN snapshots are unchanged." },
     "profiles alias": {
@@ -124,6 +177,7 @@ const commandOptionDescriptions = {
         "no-progress-ms": "Override the health-assessment progress-age threshold in milliseconds; integer at least 1000. Defaults are 120000 for starting, 300000 for capturing and 1800000 otherwise. This is not a productive command timeout or permission to stop a live owner."
     },
     "run fork": { from: "Existing retained snapshot path to fork into a new RUN with the explicitly selected engine; not a control request identity." },
+    "run snapshot bootstrap create": { flow: "Pre-RUN boundary: sdlc starts at specify; mb-init, mb-upgrade and source workflows start at preflight from installed canon. interactive starts at preflight from the selected project's curated pack, never global fallback. Creates no RUN or provider Session.", output: "New snapshot directory outside the project and runtime Home. Captures original project files and Git state; refuses an existing output." },
     "run control resume": { from: "Exact retained pause/stop control ID whose captured state authorizes this resume request; not a snapshot path." },
     "stage block": { kind: "Blocker category: engine, harness or environment; code and summary identify the actionable cause." },
     "migration impact": { mode: "Optional full_migration request forces the strict full-migration assessment; otherwise impact evidence determines patch, targeted_minor or full_migration." },
@@ -140,6 +194,22 @@ const commandOptionDescriptions = {
     "memory permissions preflight": { mode: "Permission contour to check: read, write, repair or report_only; write checks may create temporary permission probes.", flow: "Workflow permission contour: mb-init, mb-upgrade, mb-audit, mb-fix, mb-upgrade-review or custom. Not a filesystem path." },
     "memory compose register": { "run": "Active mb-init or mb-upgrade RUN whose accepted discovery/diff-analysis and immutable execution bind the composition graph.", "request-key": "Stable composition registration identity; exact replay retains the original Work graph.", "result-file": "Bounded proposed composition JSON. Bytes are prepared before registration; agent fields do not grant Work or write authority." },
     "memory upgrade publish": { run: "Active mb-upgrade authoring Stage with a registered blueprint and settled Work. Apply only its retained canonical publication plan and recovery archive; this does not accept the Stage or complete the RUN." },
+    "memory distill inputs": { run: "Bound mb-distill RUN. Read its original request and every delivered question/answer from retained custody; this grants no write scope and allocates no RUN or Session." },
+    "interactive inputs": { run: "Bound interactive RUN. Read the original request, its CLI-issued initial_request_basis, ordered turns, actual HITL answers and current input digest. Does not create a RUN, finish intake or approve changes." },
+    "interactive integrate": { run: "Bound interactive integration Stage with accepted independent review. Perform or reconcile only its retained scoped local Git operation; never push, reset or autostash. This does not accept the terminal Stage or complete the RUN.", "result-file": "Optional bounded JSON inclusion agreement: basis (role,event_id,sha256), reason and include_existing_paths. Required for pre-existing selected changes; cite genuine user input resolved before review. Exact retained replay needs no fresh agreement; unknown effects are reconciled, not repeated." },
+    "interactive checks": { run: "Bound interactive RUN. Retain current check obligations and execute them through the common aggregate runner; returned receipts are not Stage or review acceptance.", stage: "Current hardening or review Stage. Checks bind the complete task, scope and observed patch; corrections cannot reuse stale evidence.", "result-file": "Bounded JSON with additionalChecks (array of id,command,purpose) and optional noChecksReason. Each id must match ^CHK-[A-Za-z0-9-]{1,64}$, be unique and not collide with project policy checks; command and purpose must be nonempty strings. Example: {\"additionalChecks\":[{\"id\":\"CHK-project-test\",\"command\":\"npm test\",\"purpose\":\"Run the existing project tests\"}]}. Project CODE/readiness checks are always included. Keep accepted check IDs and commands unchanged in later rounds; do not drop retained obligations. A substantive no-check reason is required only when no checks apply." },
+    "interactive register": { run: "Bound interactive RUN. Register or replay the initial author/reviewer Work graph without starting a provider or accepting its results.", stage: "Current hardening or review Stage; each uses its own retained packet and role. Corrections use interactive correction and re-review, not arbitrary registration identities." },
+    "interactive correction": { run: "Bound interactive review RUN. Register or replay a scoped correction author within the same Stage and attempt; no Stage rewind.", work: "Exact latest completed negative reviewer Work. A ready reviewer or foreign Work cannot authorize correction." },
+    "interactive re-review": { run: "Bound interactive review RUN. Register or replay a fresh independent critic after a ready correction and current checks; author claims never become review acceptance.", work: "Exact completed correction-author Work in this review Stage. New registration requires latest current output and retained check evidence." },
+    "interactive scope": { run: "Bound interactive RUN. Retain the coordinator's selected mutation scope and original before-images. New user input requires explicit scope reassessment; no files are edited or Git effects performed.", "result-file": "Bounded JSON with exactly requestId, paths (sorted unique relative files), basis (role,event_id,sha256), reason and expectedInputsSha256. Basis for the original request uses role=request, event_id=0 (a JSON integer, not a request ID), and initial_request.sha256 from interactive inputs. For later input copy role (turn,answer,finish), integer event_id and sha256 from its exact messages entry; question is not user approval. expectedInputsSha256 is the complete interactive inputs response sha256. requestId identifies the scope operation, not the RUN: use a fresh scope requestId when the input digest, paths, basis or reason changes, including after finish; reuse only for an identical proposal retry. Basis must name genuine delivered user input; semantic applicability remains agent-owned. A finish message alone cannot widen scope." },
+    "interactive turn": { run: "Existing interactive RUN accepting turns. Retain these exact user bytes without allocating another RUN or Session. An unanswered managed pause also receives an ordinary controller answer; accepted means queued, not physically delivered.", "request-id": "Stable delivery identity. Exact retry reconciles the original turn and original pause only; different bytes or revision under the same identity refuse.", "expected-inputs-sha256": "Current SHA-256 from interactive inputs, including actual HITL answers. A concurrent delivery refuses instead of overwriting it.", "intake-file": "Bounded nonempty UTF-8 user message, preserved byte-for-byte, up to 1 MiB. Its text is never interpreted as a finish command or inclusion approval." },
+    "interactive finish": { run: "Existing interactive RUN. Explicitly close free-turn intake within this RUN and queue an ordinary answer to its unanswered managed pause, if present. This does not accept review, commit changes or complete the RUN; attached execution retains input for its current coordinator.", "request-id": "Stable finish delivery identity. Exact retry reconciles the original retained finish and original pause without duplicating either.", "expected-inputs-sha256": "Current SHA-256 from interactive inputs. Finish includes every delivered turn and HITL answer; stale revisions refuse.", "intake-file": "Bounded nonempty UTF-8 final user message and constraints, preserved byte-for-byte, up to 1 MiB. Choosing this command, not text inside the file, requests finish." },
+    "interactive git-inputs": { run: "Bound interactive RUN. Inspect original selected workspace, index and HEAD versions without Git writes or inclusion approval. Resolve existing-change decisions before accepting review.", stage: "Descriptor Stage whose current input and mutation scope must match. Available before finish and accepted review; stale scope or moved original Git inputs refuse." },
+    "memory fix context": { run: "Bound mb-fix RUN. Read its original selected findings, source intake and all delivered user inputs. Read-only; does not approve repair or close findings." },
+    "memory fix scope": { run: "Bound mb-fix RUN. Prepare current drift and selected-target observations without writing documents or accepting the intake Stage.", "result-file": "Bounded JSON object with routing and write_scope. Scope cites an actual delivered request/answer and the complete current user-input digest; semantic consent remains agent-owned." },
+    "memory fix publish": { run: "Active mb-fix repair Stage with accepted intake. Apply only the original admitted document publication; does not accept verification, review or finish.", "result-file": "Bounded JSON object with outputs: path, content (string or null for selected removal), finding_ids. Paths and findings must match the accepted repair scope. Retained intent governs recovery." },
+    "memory fix integrate": { run: "Active mb-fix finish Stage with independently verified and accepted review. Scoped local commit/merge under the frozen Git policy; never push, reset or autostash.", "result-file": "Optional current agreement object: user_inputs_sha256 and approval_source. Required when later delivered answers make the original agreement stale; cannot widen the accepted repair scope. Unknown original Git effects require reconciliation, not redispatch." },
+    "memory distill publish": { run: "Active bound mb-distill promote Stage with accepted review and independently settled research Work. Apply the original scoped publication and retain its observed result; this does not accept the Stage or RUN.", "result-file": "Bounded JSON proposal: write_scope, user_inputs_sha256 and outputs (path, content, candidate_ids). The agent interprets agreement; CLI checks delivered sources, accepted candidate IDs, exact paths and original-intent recovery. Missing agreement requires stage pause, not invented approval." },
     "memory verify checks": { "run": "Active mb-init or mb-upgrade RUN. Execute only its independently selected declared verification checks." },
     "memory review register": { "run": "Active mb-init or mb-upgrade RUN with accepted verification. Register initial independent reviewers; this does not launch providers." },
     "memory review collect": { "run": "Active mb-init or mb-upgrade RUN. Collect genuine registered initial-wave results without accepting the Stage or granting correction authority." },
@@ -197,7 +267,8 @@ export function optionsForCommandTree(command) {
 export function routerNativeRoute(key) {
     return key === "version" || key.startsWith("engine ") || key === "schema validate"
         || key === "flow list" || key === "flow show" || key === "flow mb-init" || key === "init" || key === "flow mb-upgrade" || key === "upgrade"
-        || key === "flow mb-audit" || key === "flow project-review" || key === "review"
+        || key === "flow mb-audit" || key === "flow project-review" || key === "flow mb-distill" || key === "flow mb-fix" || key === "flow review-fix" || key === "flow interactive" || key === "review"
+        || key === "flow release" || key === "flow deploy" || key === "flow publish"
         || key === "run reconcile" || key === "runtime storage admit" || key === "runtime storage qualify" || key === "runtime storage transition"
         || key === "runtime flow admit"
         || key.startsWith("profiles ") || key.startsWith("models ") || key.startsWith("harnesses ") || key.startsWith("completion ") || key === "setup" || key.startsWith("setup ")

package/dist/cli/delivery.js

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { createContext } from "../runtime/context.js";
+import { AppError, errorRecord } from "../shared/errors.js";
+import { deliveryFlowStages, isDeliveryFlow } from "../domain/delivery-flows.js";
+import { prepareCommandRoute } from "./command-inputs.js";
+import { prepareFlowExecutionSelectors } from "./diagnostic-invocation.js";
+import { parseOutputOptions } from "./output-options.js";
+import { prepareResponseDestination } from "./response-file.js";
+import { prepareTextFile } from "./input-preparation.js";
+import { writePreparationError } from "./error-output.js";
+import { resolveDdFlowHome, resolveProjectRoot } from "../storage/paths.js";
+import { readOperatorProfiles, readOperatorProfileInput } from "../services/operator-profiles.js";
+import { onboardExecutor } from "../services/executor-onboarding.js";
+import { askExecutorChoice } from "./executor-onboarding.js";
+import { PreparedInstalledFlowSource } from "../services/installed-flow-source.js";
+import { readSetupStatus } from "../services/setup.js";
+import { selectMemoryInitInstalledEngine } from "../services/memory-init-engine-release.js";
+import { FrozenGenericExecution } from "../services/generic-execution.js";
+import { readDeliveryRequest, retainDeliveryRequest, startDeliveryRun } from "../services/delivery-request.js";
+import { hybridDigest } from "../services/hybrid-contracts.js";
+import { registerProject } from "../services/projects.js";
+import { readFlowRunExecutionBundle } from "../services/runs.js";
+import { launchAndObserveMemoryFlow } from "./memory-init.js";
+function refuse(message) { throw new AppError("usage", message, 2, { phase: "prepare", effect: "no_effect" }); }
+export function prepareDeliveryInvocation(args) {
+    const route = prepareCommandRoute(args), flowId = route.command;
+    if (route.family !== "flow" || !isDeliveryFlow(flowId))
+        refuse("Use flow release, flow deploy or flow publish");
+    const options = route.parsed.options, value = (key) => options.get(key)?.[0];
+    const projectRoot = value("project-root"), requestId = value("request-id"), workspace = value("workspace");
+    if (!path.isAbsolute(projectRoot) || path.resolve(projectRoot) !== projectRoot
+        || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(requestId)
+        || workspace !== undefined && (!path.isAbsolute(workspace) || path.resolve(workspace) !== workspace))
+        refuse("Use canonical absolute roots and a bounded request ID");
+    if (options.has("detach") && options.has("prepare-only"))
+        refuse("--detach and --prepare-only are exclusive");
+    const selected = prepareFlowExecutionSelectors(options, deliveryFlowStages[flowId]);
+    if (selected.profileFile && !path.isAbsolute(selected.profileFile))
+        refuse("--profile-file must be absolute");
+    return { scope: { projectRoot, requestId, flowId }, workspace, ...selected, intakeFile: value("intake-file"),
+        detach: options.has("detach"), prepareOnly: options.has("prepare-only"), nonInteractive: options.has("non-interactive") };
+}
+/** Managed physical Sessions use the ordinary RUN controller. Launch is not
+ * publication permission; each productive operation still consumes approval. */
+export async function runDeliveryCli(args, env = process.env, io = process) {
+    let context, effects = false;
+    try {
+        const output = parseOutputOptions(args), invocation = prepareDeliveryInvocation(output.args), home = resolveDdFlowHome(env);
+        if (output.responseFile)
+            prepareResponseDestination(output.responseFile);
+        const { scope } = invocation;
+        if (resolveProjectRoot(scope.projectRoot) !== scope.projectRoot || invocation.workspace !== undefined
+            && resolveProjectRoot(invocation.workspace) !== invocation.workspace)
+            refuse("Roots must be canonical existing checkouts");
+        if (invocation.profileFile)
+            invocation.execution.rootProfile = readOperatorProfileInput(invocation.profileFile);
+        const text = invocation.intakeFile ? prepareTextFile(invocation.intakeFile, "delivery request", 64 * 1024).text : undefined;
+        context = createContext(env, "prepared_existing", undefined, { resourceDatabaseMode: "prepared_existing" });
+        const project = context.db.get("SELECT status FROM projects WHERE root=?", [scope.projectRoot]);
+        if (project && project.status !== "active")
+            refuse("Activate the selected project before delivery");
+        const retained = project ? readDeliveryRequest(context, scope) : null;
+        if (retained) {
+            if (Object.entries(invocation.execution).some(([key, value]) => !Object.hasOwn(retained.selection, key)
+                || hybridDigest(value) !== hybridDigest(retained.selection[key]))
+                || text !== undefined && text !== retained.objective
+                || invocation.workspace !== undefined && invocation.workspace !== retained.execution.scope.workspace)
+                refuse("Replay must preserve the original request, workspace and selectors");
+        }
+        else {
+            if (!text?.trim())
+                refuse("Fresh delivery requires --intake-file with the original request");
+            const setup = readSetupStatus(home);
+            if (!setup.installation || setup.installation_readiness !== "installed")
+                refuse("Install the desired canon and CLI using setup first");
+            const source = PreparedInstalledFlowSource.fromInstalledRelease(home, setup.installation.manifest_sha256, scope.flowId);
+            const engine = selectMemoryInitInstalledEngine(home, setup.installation.manifest_sha256);
+            engine.admitDeliveryFlow(source, scope.flowId);
+            const profiles = readOperatorProfiles(home), root = invocation.execution.rootProfile, stdin = io.stdin ?? process.stdin;
+            const selected = await onboardExecutor(typeof root === "string" ? { profileId: root } : root ? { profile: root } : {}, () => profiles, { allowSkip: false, nonInteractive: invocation.nonInteractive || output.json || output.progressJsonl
+                    || !stdin.isTTY || !io.stderr.isTTY }, settings => askExecutorChoice(settings, { stdin, stderr: io.stderr }, { allowSkip: false, allowSave: false }));
+            if (!selected.profile)
+                refuse("Select a delivery executor profile");
+            const execution = FrozenGenericExecution.prepare(source.resolveRegisteredFlow(), profiles, { ...invocation.execution,
+                rootProfile: root ?? selected.profile, execution: "managed", stageSessionMode: "new_session",
+                delegation: invocation.execution.delegation ?? { mode: "external", max_parallel: 1 } }, { projectRoot: scope.projectRoot, requestId: scope.requestId, workspace: invocation.workspace ?? scope.projectRoot });
+            effects = true;
+            registerProject(context, { root: scope.projectRoot });
+            retainDeliveryRequest(context, { scope, source, execution, engine, selection: invocation.execution, objective: text });
+        }
+        effects = true;
+        const started = startDeliveryRun(context, scope), bundle = readFlowRunExecutionBundle(context, { projectRoot: scope.projectRoot, runId: started.runId });
+        if (!bundle || bundle.manifest.flow_id !== scope.flowId)
+            throw new AppError("delivery_bundle_missing", "Restore the original delivery bundle", 1, { effect: "committed" });
+        return await launchAndObserveMemoryFlow(context, { ...invocation,
+            scope: { projectRoot: scope.projectRoot, requestId: scope.requestId, workspaceRoot: bundle.execution.snapshot().scope.workspace } }, started, scope.flowId, output, env, io);
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        if (effects)
+            record.details = { ...record.details, effect: ["unknown", "partial", "committed"].includes(String(record.details.effect)) ? record.details.effect : "partial", next_action: "reconcile_exact_request" };
+        writePreparationError(io, args, record);
+        return record.exitCode;
+    }
+    finally {
+        context?.db.close?.();
+    }
+}

package/dist/cli/diagnostic-invocation.js

@@ -1,29 +1,46 @@
 import path from "node:path";
 import { AppError } from "../shared/errors.js";
 import { diagnosticFlowStages } from "../domain/diagnostic-flows.js";
+import { distillStages } from "../domain/distill-flow.js";
+import { reviewFixStages } from "../domain/review-fix-flow.js";
 import { prepareCommandRoute } from "./command-inputs.js";
 function refuse(message) { throw new AppError("usage", message, 2, { effect: "no_effect" }); }
 /** Parser only: no files, operator settings, project mutation or runtime state. */
 export function prepareDiagnosticInvocation(args) {
     const route = prepareCommandRoute(args), options = route.parsed.options;
-    const flowId = route.key === "flow mb-audit" ? "mb-audit"
-        : ["review", "flow project-review"].includes(route.key) ? "project-review" : refuse("Use flow mb-audit or review / flow project-review");
+    const flowId = route.key === "flow review-fix" ? "review-fix" : route.key === "flow mb-distill" ? "mb-distill" : route.key === "flow mb-audit" ? "mb-audit"
+        : ["review", "flow project-review"].includes(route.key) ? "project-review" : refuse("Use flow mb-distill, flow mb-audit or review / flow project-review");
+    const stages = flowId === "review-fix" ? reviewFixStages : flowId === "mb-distill" ? distillStages : diagnosticFlowStages[flowId];
     const value = (key) => options.get(key)?.[0];
     const projectRoot = value("project-root"), requestId = value("request-id");
     if (!path.isAbsolute(projectRoot) || path.resolve(projectRoot) !== projectRoot
         || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(requestId))
         refuse("Use a canonical absolute project root and a bounded request ID");
-    if (value("profile") && value("profile-file"))
-        refuse("Use either --profile or --profile-file");
     if (options.has("detach") && options.has("prepare-only"))
         refuse("--detach and --prepare-only are exclusive");
+    const selected = prepareFlowExecutionSelectors(options, stages);
+    const sourceRunId = value("source-run"), findingIds = options.get("finding");
+    if (Boolean(sourceRunId) !== Boolean(findingIds))
+        refuse("Supply --source-run together with one or more --finding values");
+    if (sourceRunId && (!/^RUN-[0-9]+-[a-z0-9-]+$/.test(sourceRunId) || !findingIds?.length || findingIds.length > 4096
+        || findingIds.some(id => !id.trim() || id.includes("\0")) || new Set(findingIds).size !== findingIds.length))
+        refuse("Select one exact source RUN and unique ordered finding IDs");
+    return { scope: { projectRoot, requestId, flowId }, ...selected,
+        ...(sourceRunId && findingIds ? { repairSelection: { sourceRunId, findingIds: [...findingIds] } } : {}), intakeFile: value("intake-file"),
+        detach: options.has("detach"), prepareOnly: options.has("prepare-only"), nonInteractive: options.has("non-interactive") };
+}
+/** Shared pure selectors for registered diagnostic and bounded repair launchers. */
+export function prepareFlowExecutionSelectors(options, stages) {
+    const value = (key) => options.get(key)?.[0];
+    if (value("profile") && value("profile-file"))
+        refuse("Use either --profile or --profile-file");
     const execution = {};
     if (value("profile"))
         execution.rootProfile = value("profile");
     const stageProfiles = {};
     for (const assignment of options.get("stage-profile") ?? []) {
         const match = /^([^=]+)=([^=]+)$/.exec(assignment);
-        if (!match || !diagnosticFlowStages[flowId].includes(match[1]) || Object.hasOwn(stageProfiles, match[1]))
+        if (!match || !stages.includes(match[1]) || Object.hasOwn(stageProfiles, match[1]))
             refuse("--stage-profile requires one known stage=profile assignment per stage");
         stageProfiles[match[1]] = match[2];
     }
@@ -41,6 +58,5 @@ export function prepareDiagnosticInvocation(args) {
             refuse("--max-parallel must be an integer from 1 to 64");
         execution.delegation = { mode: "external", max_parallel: n };
     }
-    return { scope: { projectRoot, requestId, flowId }, execution, profileFile: value("profile-file"), intakeFile: value("intake-file"),
-        detach: options.has("detach"), prepareOnly: options.has("prepare-only"), nonInteractive: options.has("non-interactive") };
+    return { execution, profileFile: value("profile-file") };
 }

package/dist/cli/diagnostic.js

@@ -42,6 +42,8 @@ export async function runDiagnosticCli(args, env = process.env, io = process) {
         finally {
             reader.db.close?.();
         }
+        if (scope.flowId === "review-fix" && !retained && !invocation.repairSelection)
+            throw new AppError("usage", "Fresh review-fix requires --source-run and explicit --finding selections", 2, { effect: "no_effect" });
         if (invocation.profileFile)
             invocation.execution.rootProfile = readOperatorProfileInput(invocation.profileFile);
         const readIntake = () => {
@@ -60,6 +62,8 @@ export async function runDiagnosticCli(args, env = process.env, io = process) {
             return text;
         };
         if (retained) {
+            if (invocation.repairSelection && hybridDigest(invocation.repairSelection) !== hybridDigest(retained.repair_source?.selection))
+                throw new AppError("diagnostic_request_conflict", "Supplied finding selection differs from the retained review-fix request", 2, { effect: "no_effect" });
             if (Object.entries(invocation.execution).some(([key, value]) => !Object.hasOwn(retained.selection, key) || hybridDigest(value) !== hybridDigest(retained.selection[key]))
                 || invocation.intakeFile && readIntake() !== retained.objective)
                 throw new AppError("diagnostic_request_conflict", "Supplied selectors differ from the original diagnostic request", 2, { effect: "no_effect" });
@@ -76,7 +80,12 @@ export async function runDiagnosticCli(args, env = process.env, io = process) {
             publishSetup("dependency_check_completed", "diagnostic:canon");
             engine = selectMemoryInitInstalledEngine(home, installation.manifest_sha256);
             publishSetup("dependency_check_completed", "diagnostic:engine");
-            engine.admitDiagnosticFlow(source, scope.flowId);
+            if (scope.flowId === "review-fix")
+                engine.admitReviewFixFlow(source);
+            else if (scope.flowId === "mb-distill")
+                engine.admitDistillFlow(source);
+            else
+                engine.admitDiagnosticFlow(source, scope.flowId);
             publishSetup("dependency_check_completed", "diagnostic:handlers");
             const stdin = io.stdin ?? process.stdin;
             const selected = await onboardExecutor({ ...(typeof rootProfile === "string" ? { profileId: rootProfile } : {}),
@@ -88,7 +97,8 @@ export async function runDiagnosticCli(args, env = process.env, io = process) {
         }
         effects = true;
         context = openMemoryInitStores(env, { scope: { projectRoot: scope.projectRoot, workspaceRoot: scope.projectRoot, requestId: scope.requestId },
-            selectionSha256: hybridDigest({ scope, objective, selection: retained?.selection ?? invocation.execution }) }).context;
+            selectionSha256: hybridDigest({ scope, objective, selection: retained?.selection ?? invocation.execution,
+                ...(scope.flowId === "review-fix" ? { repair_selection: retained?.repair_source?.selection ?? invocation.repairSelection } : {}) }) }).context;
         publishSetup("dependency_check_completed", "diagnostic:stores");
         registerProject(context, { root: scope.projectRoot });
         if (!retained) {
@@ -99,7 +109,8 @@ export async function runDiagnosticCli(args, env = process.env, io = process) {
                 ...invocation.execution, ...(rootProfile !== undefined ? { rootProfile } : {}), execution: "managed", stageSessionMode: "new_session",
                 delegation: invocation.execution.delegation ?? { mode: "external", max_parallel: 1 }
             }, { requestId: scope.requestId, projectRoot: scope.projectRoot, workspace });
-            retainDiagnosticRequest(context, { scope, source: source, execution, engine: engine, objective, selection: invocation.execution });
+            retainDiagnosticRequest(context, { scope, source: source, execution, engine: engine, objective, selection: invocation.execution,
+                ...(invocation.repairSelection ? { repairSelection: invocation.repairSelection } : {}) });
         }
         const started = startDiagnosticRun(context, scope), bundle = readFlowRunExecutionBundle(context, { projectRoot: scope.projectRoot, runId: started.runId });
         if (!bundle)