@deksden-com/dd-flow-cli 0.9.0-beta.87 → 0.9.0-beta.88

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.88
+
+### Patch Changes
+
+- 5f3806c: Keep managed HITL answer paths inside retained runtime authority, preserve early
+  native CLI failures, and fail controllers conclusively when an answer turn does
+  not resume its assigned pause.
+
 ## 0.9.0-beta.87
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.87",
-  "cli_commit": "68245785d197ab491e80db40faf2e57a18a6a055",
-  "built_at": "2026-09-20T22:46:39.592Z",
+  "cli_version": "0.9.0-beta.88",
+  "cli_commit": "6cd7da3104a366d4b2866fa31ef8635949e79143",
+  "built_at": "2026-09-21T00:22:16.324Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "acaae844a871ddfbc49fd66355373f166dc3e683",

package/dist/cli/help.js

@@ -233,6 +233,8 @@ Usage:
   dd-flow stage start --bootstrap --project-root <root> --stage specify --subject <safe-subject> (--intake-file <path>|--intake-stdin) [--require-session-binding] --json
   dd-flow stage pause <RUN-ID|RUN-short-id> --project-root <root> --stage <name> --work <WORK-ID> (--question-file <path>|--question-stdin) --json
   dd-flow stage resume <RUN-ID|RUN-short-id> --project-root <root> --stage <name> --work <WORK-ID> (--answer-file <path>|--answer-stdin) --json
+
+Managed resume commands restore the accepted answer file from runtime state. Execute the returned command without adding an answer path or recreating the answer. The explicit answer flags above are for unmanaged calls.
   dd-flow stage block <RUN-ID|RUN-short-id> --project-root <root> --stage <name> --work <WORK-ID> --kind engine|harness|environment --code <code> (--summary-file <path>|--summary-stdin) [--retryable] --json
   dd-flow stage unblock <RUN-ID|RUN-short-id> --project-root <root> --stage <name> --work <WORK-ID> --json
   dd-flow stage fanout status <RUN-ID|RUN-short-id> --project-root <root> --stage <name> --json

package/dist/cli/run-cli.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { quote } from "shell-quote";
-import { observeLifecycleCommand } from "../services/lifecycle-invocations.js";
+import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../services/lifecycle-invocations.js";
 import { verifyCodexHookDelivery } from "../services/codex-hook-delivery.js";
 import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, expandLifecycleInvocationArgs, issueLifecycleInvocation, prepareLifecycleIssuance, lifecycleInvocationScope, observedLifecycleDiagnostic, observedLifecycleInvocation, resolveObservedLifecycleArgs, settleLifecycleInvocation, settleLifecyclePreparationRejection, settleLifecycleRejection, validateLifecyclePathAliases } from "../services/lifecycle-invocations.js";
 import { createContext, createRouterContext } from "../runtime/context.js";
@@ -132,12 +132,13 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         const lifecycleCommand = parseLifecycleCommand(publicCommand);
         if (lifecycleCommand.kind === "standalone")
             validateLifecyclePathAliases(output.args, lifecycleCommand.invocation.operation);
-        const observedInvocation = observedLifecycleInvocation(routerContext, publicCommand);
+        const observedInvocation = observedLifecycleInvocation(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID);
         if (!observedInvocation && !suppliedInvocationId && env.DD_FLOW_DAEMON_ID && lifecycleCommand.kind === "standalone") {
             const diagnostic = observedLifecycleDiagnostic(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID);
             if (diagnostic)
                 throw new AppError("lifecycle_shell_syntax_invalid", `Native observer rejected the shell form: ${String(diagnostic.reason ?? "unsupported shell composition")}. Write structured input to a file and run the returned dd-flow command separately.`, 2, { ...diagnostic, phase: "prepare", effect: "no_effect", recoverable: true });
-            throw new AppError("invocation_receipt_missing", "Managed lifecycle command has no committed native receipt", 1, { effect: "no_effect", recoverable: false });
+            const nativeEvent = observedLifecycleNativeEvent(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID);
+            throw new AppError(nativeEvent ? "invocation_assignment_missing" : "invocation_receipt_missing", nativeEvent ? "Native call was observed, but its arguments do not match an issued lifecycle assignment" : "Managed lifecycle command has no committed native receipt", 1, { effect: "no_effect", recoverable: false });
         }
         const invocationId = observedInvocation?.id ?? suppliedInvocationId;
         let boundInvocationArgs;
@@ -266,6 +267,23 @@ export async function runCli(args, io = defaultIo, env = process.env) {
     }
     catch (caught) {
         const error = isAppError(caught) ? caught : new AppError("unexpected", caught instanceof Error ? caught.message : String(caught), 1, { effect: "unknown", cause: { code: caught?.code ?? null, sqlite_extended_code: caught?.errcode ?? null } });
+        if (!settleHook && !invocationSettlement && env.DD_FLOW_DAEMON_ID) {
+            let earlyContext;
+            try {
+                const command = quote(["dd-flow", ...output.args]);
+                const event = observedLifecycleNativeEvent(createRouterContext(env), command, env.DD_FLOW_DAEMON_ID);
+                if (event) {
+                    earlyContext = createContext({ ...env }, "hook");
+                    observeLifecycleCommand(earlyContext, command, event)({ error });
+                }
+            }
+            catch (persistence) {
+                error.details.lifecycle_diagnostic_error = String(persistence);
+            }
+            finally {
+                earlyContext?.db.close?.();
+            }
+        }
         if (diagnosticHome && (!isAppError(caught) || error.code === "storage_write_failed")) {
             try {
                 const directory = path.join(diagnosticHome, "diagnostics", "cli");

package/dist/services/lifecycle-invocations.js

@@ -6,7 +6,7 @@ import { setTimeout as delay } from "node:timers/promises";
 import { AppError, errorRecord } from "../shared/errors.js";
 import { shortEntityReference } from "../shared/entity-references.js";
 import { resolveWorkReference } from "../storage/work-references.js";
-import { commandOption, parseLifecycleCommand, shellSuffixOffset } from "./lifecycle-command.js";
+import { commandOption, lifecycleCommandFromPayload, parseLifecycleCommand, shellSuffixOffset } from "./lifecycle-command.js";
 import { requireProjectByRoot } from "./projects.js";
 import { assertRunMutationAllowed, assertStageSettlementAllowed, assertWorkSettlementAllowed, recoveryGuard } from "./run-recovery.js";
 import { readNativeDaemonState, requireManagedDaemonBinding } from "./managed-daemon-binding.js";
@@ -68,7 +68,7 @@ function fingerprint(parsed) {
 const runtimeOwnedOptions = {
     stage_start: new Set(["project-root", "context-file", "context-sha256", "response-file", "require-session-binding"]),
     stage_finish: new Set(["project-root", "result-file", "decision-file", "verification-file"]),
-    stage_pause: new Set(["project-root"]), stage_resume: new Set(["project-root"]),
+    stage_pause: new Set(["project-root"]), stage_resume: new Set(["project-root", "answer-file"]),
     work_start: new Set(["project-root", "recovery-id"]),
     work_finish: new Set(["project-root"]), work_fail: new Set(["project-root"]),
     merge_apply: new Set(["project-root"]), merge_repair: new Set(["project-root"]),
@@ -278,7 +278,7 @@ export function assertLifecycleOutcomes(context, scope) {
 }
 /** Hooks already own native identity. Retain command outcomes there, with an
  * atomic controller notification; missing notifications reconcile from the row. */
-export function observeLifecycleCommand(context, command) {
+export function observeLifecycleCommand(context, command, nativeEvent) {
     const parsed = parseLifecycleCommand(command);
     if (parsed.kind !== "standalone")
         return () => { };
@@ -335,9 +335,12 @@ export function observeLifecycleCommand(context, command) {
             return;
         anchor = { project_id: projectId, run_id: runId, generation: generation ?? recoveryGuard(context, projectId, runId)?.generation ?? 0, hook_event_id: eventId, session_id: event.session_id, harness: event.harness, operation: parsed.invocation.operation };
     };
-    observeCommandHook(context, command);
+    if (nativeEvent)
+        context.observeLifecycleHook(nativeEvent.project_id, nativeEvent.id);
+    else
+        observeCommandHook(context, command);
     const invocationId = commandOption(parsed.invocation, "invocation-id");
-    if (!anchor && invocationId) {
+    if (!anchor && invocationId && !nativeEvent) {
         const attempt = load(context, invocationId);
         checkCommand(attempt, command);
         if (attempt.event_key && ["observed", "executing"].includes(attempt.status)) {
@@ -441,9 +444,10 @@ export function managedInvocationContext(context, input) {
     env.DD_FLOW_INVOCATION_SCOPE = JSON.stringify(scope);
     return { ...context, env };
 }
-/** Generated commands retain their attempt across repeated rendering. Only a
- * currently executing command can emit its own successor with the same argv. */
-export function managedLifecycleCommand(context, command) {
+/** Generated commands retain their attempt across repeated rendering. Execution
+ * can issue a retry; accepted HITL intent can replace an unobserved placeholder
+ * or issue the next pause's assignment after successful settlement. */
+export function managedLifecycleCommand(context, command, options = {}) {
     const configured = context.env.DD_FLOW_INVOCATION_SCOPE;
     if (!configured)
         return command;
@@ -474,7 +478,18 @@ export function managedLifecycleCommand(context, command) {
     return context.db.writeTransaction(() => {
         const prior = context.db.get("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? ORDER BY rowid DESC LIMIT 1", [JSON.stringify(scope), fingerprint(parsed)]);
         if (prior && prior.id !== context.env.DD_FLOW_CURRENT_INVOCATION) {
-            return publicInvocationCommand(context, prior, command);
+            const replacesAnswer = options.replaceUnobservedAnswer && parsed.operation === "stage_resume"
+                && (prior.status === "settled" || commandOption(invocation(prior.command), "answer-file") !== commandOption(parsed, "answer-file"));
+            if (!replacesAnswer)
+                return publicInvocationCommand(context, prior, command);
+            // The pause packet can prepare a placeholder before the controller has
+            // accepted an answer. Replace only an unobserved assignment; never change
+            // the authority of a native call already in flight.
+            const completed = prior.status === "settled" && prior.outcome_json && !JSON.parse(prior.outcome_json).error;
+            if (prior.status !== "issued" && !completed)
+                throw new AppError("invocation_answer_conflict", "Cannot replace an answer while its lifecycle assignment is in flight or failed", 1, { invocation_id: prior.id });
+            if (prior.status === "issued")
+                context.db.run("UPDATE lifecycle_invocations SET status = 'expired' WHERE id = ?", [prior.id]);
         }
         if (context.env.DD_FLOW_INVOCATION_READONLY === "1")
             throw new AppError("invocation_command_unprepared", "No prepared lifecycle command is available; read-only inspection cannot issue one", 1);
@@ -807,8 +822,38 @@ export function observeLifecycleInvocation(context, input) {
         throw error;
     }
 }
-/** Return a precise native-observer rejection for the same argv. This keeps
- * shell diagnostics distinct from a genuinely absent hook receipt. */
+/** Correlate exact native argv for diagnostics, independently of assignment
+ * matching. A hook-added event key must name the same persisted native call. */
+export function observedLifecycleNativeEvent(context, command, daemonId) {
+    if (!context.db.get("SELECT 1 FROM sqlite_master WHERE name = 'hook_events'"))
+        return null;
+    const signature = (value) => {
+        const parsed = parseLifecycleCommand(value);
+        if (parsed.kind !== "standalone" || parsed.invocation.wrapped)
+            return null;
+        return JSON.stringify([parsed.invocation.operation, parsed.invocation.args.positional,
+            [...parsed.invocation.args.options].filter(([key]) => !["json", "progress-jsonl", "hook-event-id"].includes(key)).sort(([a], [b]) => a.localeCompare(b))]);
+    };
+    const expected = signature(command);
+    if (!expected)
+        return null;
+    const eventKey = commandOption(invocation(command), "hook-event-id");
+    const matches = context.db.all("SELECT project_id, id, event_key, sanitized_summary FROM hook_events WHERE daemon_id = ? AND status = 'observed' AND outcome_json IS NULL", [daemonId]).filter(row => {
+        if (eventKey && row.event_key !== eventKey)
+            return false;
+        try {
+            const observed = lifecycleCommandFromPayload(JSON.parse(row.sanitized_summary));
+            return typeof observed === "string" && signature(observed) === expected;
+        }
+        catch {
+            return false;
+        }
+    });
+    // Diagnostic correlation only: never use this as execution authority, and
+    // never choose the latest of several identical native calls.
+    return matches.length === 1 ? { project_id: matches[0].project_id, id: matches[0].id } : null;
+}
+/** Keep shell diagnostics distinct from genuinely absent native delivery. */
 export function observedLifecycleDiagnostic(context, command, daemonId) {
     const analysis = parseLifecycleCommand(command);
     if (analysis.kind !== "standalone")
@@ -833,7 +878,7 @@ export function observedLifecycleDiagnostic(context, command, daemonId) {
 /** Resolve only a command that a native hook has already bound to an issued
  * attempt. This is the CLI-side half of admission for model-facing commands
  * that intentionally omit the internal UUID. */
-export function observedLifecycleInvocation(context, command) {
+export function observedLifecycleInvocation(context, command, daemonId) {
     if (!context.db.get("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'lifecycle_invocations'"))
         return null;
     const analysis = parseLifecycleCommand(command);
@@ -843,6 +888,8 @@ export function observedLifecycleInvocation(context, command) {
         .filter(row => {
         try {
             const scope = JSON.parse(row.scope_json);
+            if (daemonId && scope.daemonId !== daemonId)
+                return false;
             return fingerprint(invocation(canonicalManagedCommand(context, command, scope))) === row.fingerprint;
         }
         catch {

package/dist/services/run-controller.js

@@ -598,19 +598,25 @@ async function executeController(context, row, manifest, state, assertOwnership,
                 const pause = view.index.stage_runs.find(stage => stage.stage === next.stage)?.pause;
                 if (!pause || state.current_session === null)
                     throw new AppError("controller_hitl_missing", "Paused RUN has no managed Session or HITL receipt", 1);
-                const answer = context.db.get("SELECT operation_id, input_json FROM run_controller_operations WHERE controller_id = ? AND status = 'accepted' AND json_extract(input_json, '$.action') = 'user_answer' AND json_extract(input_json, '$.pause_id') = ? ORDER BY created_at LIMIT 1", [row.controller_id, pause.id]);
+                const answer = context.db.get("SELECT operation_id, input_json, status FROM run_controller_operations WHERE controller_id = ? AND status IN ('accepted','completed') AND json_extract(input_json, '$.action') = 'user_answer' AND json_extract(input_json, '$.pause_id') = ? ORDER BY created_at LIMIT 1", [row.controller_id, pause.id]);
                 if (!answer) {
                     await delay(1000);
                     continue;
                 }
+                if (answer.status === "completed")
+                    throw new AppError("controller_answer_not_applied", "Completed answer operation still has its original HITL pause", 1, { pause_id: pause.id, operation_id: answer.operation_id, stage: next.stage });
                 const input = JSON.parse(answer.input_json);
                 if (digestBytes(fs.readFileSync(input.file)) !== input.sha256)
                     throw new AppError("context_checksum_mismatch", "Accepted HITL answer bytes changed", 1);
                 assertOwner();
                 // The accepted answer is logical intent; only its generation-bound
                 // adapter operation represents a physical dispatch that stop must drain.
-                const command = managedLifecycleCommand(executionContext, `${flowCommand(executionContext)} stage resume ${run.id} --stage ${next.stage} --work ${input.work_id} --project-root ${quote([run.project_root])} --answer-file ${quote([input.file])} --json`);
+                const command = managedLifecycleCommand(executionContext, `${flowCommand(executionContext)} stage resume ${run.id} --stage ${next.stage} --work ${input.work_id} --project-root ${quote([run.project_root])} --answer-file ${quote([input.file])} --json`, { replaceUnobservedAnswer: true });
                 const receipt = await prompt(state.sessions[state.current_session], `The user supplied the raw answer for pause ${pause.id}. Your first tool call must be this exact standalone command:\n\n${command}\n\nDo not alter the answer. Follow the returned packet, then stop at this Stage boundary.`, `${answer.operation_id}:prompt:${row.generation}`);
+                const afterAnswer = getFlowRunStatus(executionContext, { projectRoot: run.project_root, runId: run.id });
+                if (afterAnswer.index.stage_runs.some(stage => stage.status === "paused" && stage.pause?.id === pause.id)) {
+                    throw new AppError("controller_answer_not_applied", "The answer Turn completed without resuming the assigned HITL pause", 1, { pause_id: pause.id, operation_id: answer.operation_id, stage: next.stage, effect: "no_progress" });
+                }
                 context.db.run("UPDATE run_controller_operations SET status = 'completed', receipt_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify({ delivered: true, session_id: adapterSessionId(receipt) }), context.now(), answer.operation_id]);
                 state.last_continuation = null;
                 saveState(context, row, state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.87",
+  "version": "0.9.0-beta.88",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {