@deksden-com/dd-flow-cli 0.9.0-beta.161 → 0.9.0-beta.162

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.162
+
+### Patch Changes
+
+- Bind check-recovery help to its single committed evidence-file successor and canonical RUN path. Strip stale executable retry promises in common and hook-only fatal, repeated and persistence outcomes, including response overlays. Retain proven native assignment and directory refusal diagnostics without granting authority or masking their primary typed error (plan116).
+
 ## 0.9.0-beta.161
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.161",
-  "cli_commit": "367b9cb844aa34fd36d0a00cf059160377d10bdd",
-  "built_at": "2026-10-29T17:36:11.881Z",
+  "cli_version": "0.9.0-beta.162",
+  "cli_commit": "d78bcd1bb6f510fee45a3d77463b172cc92420dd",
+  "built_at": "2026-10-29T23:21:33.965Z",
   "built_with_canon": {
     "version": "4.1.4",
     "commit": "7cc415b3ef3ce37c9624c7cee51023e66f67cd57",

package/dist/cli/run-cli.js

@@ -8,7 +8,7 @@ import { assertAuxiliaryCommandScope, cliManagedInvocationScope, manualRecoveryI
 import path from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { quote } from "shell-quote";
-import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../services/lifecycle-invocations.js";
+import { observeLifecycleCommand, observedLifecycleNativeEvent, removeRetryPromises } 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";
@@ -316,6 +316,8 @@ async function runCliRequest(args, io, env) {
         const diagnostic = env.DD_FLOW_DAEMON_ID && lifecycleCommand.kind === "standalone"
             ? observedLifecycleDiagnostic(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID, observedInvocation?.id) : null;
         if (diagnostic && (!nativeEvent || Number(diagnostic.hook_event_id) > nativeEvent.id)) {
+            if (["invocation_assignment_missing", "invocation_directory_mismatch", "opencode_directory_mismatch", "agy_directory_mismatch", "droid_directory_mismatch"].includes(String(diagnostic.code)))
+                throw new AppError(String(diagnostic.code), String(diagnostic.reason), 1, { ...diagnostic, phase: "prepare", effect: "no_effect", recoverable: false });
             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 });
         }
         let manualRecoveryHookEventKey;
@@ -550,8 +552,7 @@ async function runCliRequest(args, io, env) {
         if (invocationSettlement && error.details.effect !== "committed") {
             try {
                 if (isAppError(error)) {
-                    delete error.details.retry_command;
-                    delete error.details.retry_instruction;
+                    removeRetryPromises(error.details);
                     // The common settlement classifies original validated proof before
                     // errorRecord clones diagnostic objects and loses capability identity.
                     settleLifecycleRejection(invocationSettlement.context, invocationSettlement.id, error);
@@ -560,8 +561,10 @@ async function runCliRequest(args, io, env) {
                     settleLifecycleInvocation(invocationSettlement.context, invocationSettlement.id, { error: { code: "unexpected", message: String(error), exitCode: 1, details: {} } });
             }
             catch (persistenceError) {
-                if (isAppError(error))
+                if (isAppError(error)) {
                     error.details.recoverable = false;
+                    removeRetryPromises(error.details);
+                }
                 io.stderr.write(`Invocation settlement persistence failed: ${String(persistenceError)}\n`);
             }
         }

package/dist/services/hooks.js

@@ -14,7 +14,7 @@ import { prepareTextFile, prepareJsonText, prepareError } from "../cli/input-pre
 import { nativeHookNonParticipation } from "../cli/native-hook-preparation.js";
 import { nativeSessionIdentity, storageSessionId } from "./session-identity.js";
 import { assertRecoveryHookCurrent } from "./hook-recovery-guard.js";
-import { observeLifecycleInvocation, observedLifecycleInvocation, managedNativeInvocationScope } from "./lifecycle-invocations.js";
+import { observeLifecycleInvocation, observedLifecycleInvocation, managedNativeInvocationScope, lifecycleDiagnosticFingerprint } from "./lifecycle-invocations.js";
 import { commandHasOption, commandOption, commandPosition, shellSuffixOffset, parseLifecycleCommand, lifecycleCommandFromPayload, continuationCommand } from "./lifecycle-command.js";
 import { registerProject, requireProjectByRoot } from "./project-registry.js";
 import { activeFlowSessionsForProject, recordFlowSessionObservation } from "./hook-session-observation.js";
@@ -421,7 +421,7 @@ export function handleCodexHook(context, input) {
             throw new AppError("codex_identity_missing", "Managed Codex lifecycle hook has no complete native invocation identity", 1, { invocation_id: invocationId });
         let executionCwd;
         try {
-            executionCwd = assignedLifecycleCwd(context, project.root, lifecycle, providerSessionId, command, stringValue(payload.cwd), { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId, toolCallId }, "codex-desktop");
+            executionCwd = assignedLifecycleCwd(context, project.root, lifecycle, providerSessionId, command, stringValue(payload.cwd), { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId, toolCallId }, "codex-desktop", () => { persist(); return eventKey; });
         }
         catch (error) {
             // A proven external Work is not its Stage coordinator. Deny the tool
@@ -614,7 +614,7 @@ function recordZcodeLifecycle(context, input, invocationId, nativePreTool = fals
         return context.db.writeTransaction(() => persist());
     }
     let persistedResult;
-    const executionCwd = assignedLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, command, observedCwd ?? undefined, { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId ?? null, toolCallId: toolUseId }, "zcode-acp");
+    const executionCwd = assignedLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, command, observedCwd ?? undefined, { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId ?? null, toolCallId: toolUseId }, "zcode-acp", () => { persist(); return eventKey; });
     const receipt = observeLifecycleInvocation(context, {
         currentEventKey: eventKey,
         ...(invocationId ? { id: invocationId } : {}), command,
@@ -715,7 +715,7 @@ export function handleGrokEvent(context, input) {
         return { ...result(context.db.writeTransaction(() => persist())), hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: { ...rawInput, command: commandWithHookEvent(command, eventKey) } } };
     }
     let inserted = false;
-    const executionCwd = assignedLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, command, observedCwd ?? undefined, { daemonId: daemonId ?? "", rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId, toolCallId: eventKey }, "grok-acp");
+    const executionCwd = assignedLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, command, observedCwd ?? undefined, { daemonId: daemonId ?? "", rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId, toolCallId: eventKey }, "grok-acp", () => { persist(); return eventKey; });
     const receipt = observeLifecycleInvocation(context, {
         currentEventKey: eventKey,
         command, harness: "grok-acp", projectId: project.id,
@@ -751,7 +751,7 @@ function requiresAssignedLifecycleCwd(facts) {
     // their tools/checks receive owned paths, not the shell's working directory.
     return !facts || !["stage_finish", "stage_pause", "stage_resume", "work_finish", "work_fail"].includes(facts.invocation.operation);
 }
-function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, command, observedCwd, identity, harness) {
+function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, command, observedCwd, identity, harness, recordRefusal) {
     const auxiliary = continuationCommand(command);
     if ((!facts && !auxiliary) || facts?.analysis.supported === false)
         return undefined;
@@ -764,8 +764,12 @@ function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, co
     }
     const constraint = proven ?? (identity ? { projectRoot, daemonId: identity.daemonId, rootSessionId: identity.rootSessionId } : undefined);
     const issuedRunId = facts && !facts.runId && !facts.workId && !facts.bootstrapStageStart && constraint ? observedLifecycleInvocation(context, command, constraint, identity ? { identity } : undefined)?.scope.runId : null;
-    if (facts?.invocation.operation.startsWith("stage_") && !facts.bootstrapStageStart && !facts.runId && !issuedRunId)
-        throw new AppError("invocation_assignment_missing", "Short lifecycle call has no unique issued RUN assignment; its workspace cannot be inferred", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+    if (facts?.invocation.operation.startsWith("stage_") && !facts.bootstrapStageStart && !facts.runId && !issuedRunId) {
+        const error = assignmentMissing();
+        if (proven && recordRefusal)
+            retainAssignmentRefusal(context, projectRoot, command, recordRefusal, error);
+        throw error;
+    }
     if (!requiresAssignedLifecycleCwd(facts))
         return undefined;
     const expected = controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId, observedCwd);
@@ -774,14 +778,38 @@ function assignedLifecycleCwd(context, projectRoot, facts, providerSessionId, co
     if (!expected)
         return undefined;
     const route = facts?.invocation.expectedCwd ?? auxiliary?.expectedCwd;
-    if (route && resolveProjectRoot(route) !== expected)
-        throw new AppError("invocation_directory_mismatch", "Literal lifecycle route differs from the assigned workspace", 1, { expected, actual: route, actual_provenance: "shell_literal_route", phase: "prepare", effect: "no_effect", recoverable: false });
-    if (!route && observedCwd && resolveProjectRoot(observedCwd) !== expected)
-        throw new AppError("invocation_directory_mismatch", "Native lifecycle directory differs from the assigned workspace", 1, { expected, actual: observedCwd, actual_provenance: "native_tool_cwd", phase: "prepare", effect: "no_effect", recoverable: false });
+    const directoryError = route && resolveProjectRoot(route) !== expected
+        ? new AppError("invocation_directory_mismatch", "Literal lifecycle route differs from the assigned workspace", 1, { expected, actual: route, actual_provenance: "shell_literal_route", phase: "prepare", effect: "no_effect", recoverable: false })
+        : !route && observedCwd && resolveProjectRoot(observedCwd) !== expected
+            ? new AppError("invocation_directory_mismatch", "Native lifecycle directory differs from the assigned workspace", 1, { expected, actual: observedCwd, actual_provenance: "native_tool_cwd", phase: "prepare", effect: "no_effect", recoverable: false }) : null;
+    if (directoryError) {
+        if (proven && recordRefusal)
+            retainAssignmentRefusal(context, projectRoot, command, recordRefusal, directoryError);
+        throw directoryError;
+    }
     // ACP without native cwd still binds assigned authority; CLI confirms the
     // physical process directory, rather than inventing native observation.
     return expected;
 }
+function assignmentMissing() {
+    return new AppError("invocation_assignment_missing", "Short lifecycle call has no unique issued RUN assignment; its workspace cannot be inferred", 1, { phase: "prepare", effect: "no_effect", recoverable: false });
+}
+/** A proven native refusal is diagnosis, never an executable assignment. */
+function retainAssignmentRefusal(context, projectRoot, command, record, error) {
+    const commandFingerprint = lifecycleDiagnosticFingerprint(command);
+    if (!commandFingerprint)
+        return;
+    const project = requireProjectByRoot(context, projectRoot);
+    context.db.writeTransaction(() => {
+        const eventKey = record();
+        const row = context.db.get("SELECT outcome_json FROM hook_events WHERE project_id = ? AND event_key = ?", [project.id, eventKey]);
+        if (row?.outcome_json)
+            return;
+        context.db.run("UPDATE hook_events SET outcome_json = ? WHERE project_id = ? AND event_key = ? AND outcome_json IS NULL", [JSON.stringify({ lifecycle_observation: {
+                    ...error.details, code: error.code, reason: error.message, command_fingerprint: commandFingerprint, phase: "prepare", effect: "no_effect", recoverable: false
+                } }), project.id, eventKey]);
+    });
+}
 function controlledLifecycleCwd(context, projectRoot, facts, providerSessionId, auxiliary, issuedRunId, observedCwd) {
     if (facts?.bootstrapStageStart)
         return projectRoot;
@@ -913,19 +941,18 @@ function handleControlledToolEvent(context, input, event, harness) {
     const provenScope = lifecycle && !shellRefusal ? managedNativeInvocationScope(context, expectedRoot, nativeIdentity, harness) : null;
     const issuedRunId = lifecycle && !lifecycle.runId && !lifecycle.workId && !lifecycle.bootstrapStageStart
         ? observedLifecycleInvocation(context, command, provenScope ?? { projectRoot: expectedRoot, daemonId, rootSessionId: nativeIdentity.rootSessionId }, { identity: nativeIdentity })?.scope.runId : null;
-    if (!shellRefusal && lifecycle && lifecycle.invocation.operation.startsWith("stage_") && !lifecycle.bootstrapStageStart && !lifecycle.runId && !issuedRunId) {
-        throw new AppError("invocation_assignment_missing", "Short lifecycle call has no unique issued RUN assignment; its workspace cannot be inferred", 1, { effect: "no_effect", recoverable: false });
-    }
+    const missingAssignment = !shellRefusal && lifecycle && lifecycle.invocation.operation.startsWith("stage_") && !lifecycle.bootstrapStageStart && !lifecycle.runId && !issuedRunId;
     // These controlled platforms additionally qualify their native launch
     // route against the stable project root when no CLI target is assigned.
     const workspaceBound = requiresAssignedLifecycleCwd(lifecycle);
     const expectedCwd = shellRefusal || !workspaceBound ? observedCwd : controlledLifecycleCwd(context, expectedRoot, lifecycle, providerSessionId, auxiliary, issuedRunId, observedCwd) ?? expectedRoot;
     const executionRoute = shellRefusal || !workspaceBound ? undefined : lifecycle?.invocation.expectedCwd ?? auxiliary?.expectedCwd;
+    let directoryError;
     if (executionRoute && resolveProjectRoot(executionRoute) !== expectedCwd) {
-        throw new AppError(`${errorPrefix}_directory_mismatch`, "Literal shell cd route does not match the assigned lifecycle workspace", 1, { expected: expectedCwd, actual: executionRoute, actual_provenance: "shell_literal_route", effect: "no_effect", recoverable: false });
+        directoryError = new AppError(`${errorPrefix}_directory_mismatch`, "Literal shell cd route does not match the assigned lifecycle workspace", 1, { expected: expectedCwd, actual: executionRoute, actual_provenance: "shell_literal_route", effect: "no_effect", recoverable: false });
     }
     if (workspaceBound && !executionRoute && observedCwd !== expectedCwd) {
-        throw new AppError(`${errorPrefix}_directory_mismatch`, `${label} ${agy ? "launch route" : "Session directory"} does not match the assigned execution workspace`, 1, { expected: expectedCwd, actual: observedCwd, effect: "no_effect", recoverable: false, ...(agy ? { actual_provenance: stringValue(event.cwd_provenance) ?? "unknown" } : {}) });
+        directoryError = new AppError(`${errorPrefix}_directory_mismatch`, `${label} ${agy ? "launch route" : "Session directory"} does not match the assigned execution workspace`, 1, { expected: expectedCwd, actual: observedCwd, effect: "no_effect", recoverable: false, ...(agy ? { actual_provenance: stringValue(event.cwd_provenance) ?? "unknown" } : {}) });
     }
     const bootstrapStageStart = !shellRefusal && lifecycle?.bootstrapStageStart;
     let matchKey = lifecycle && !shellRefusal ? lifecycleMatchKey(lifecycle, expectedRoot) : null;
@@ -959,6 +986,17 @@ function handleControlledToolEvent(context, input, event, harness) {
         return inserted;
     };
     const result = (inserted) => ({ ok: true, observed: inserted, duplicate: !inserted, event_key: baseKey, phase, harness, session: nativeSessionIdentity(harness, providerSessionId), ...(nativeParentId ? { parent_session: nativeSessionIdentity(harness, nativeParentId) } : {}), daemon_id: daemonId });
+    if (directoryError) {
+        if (provenScope)
+            retainAssignmentRefusal(context, expectedRoot, command, () => { persist(); return baseKey; }, directoryError);
+        throw directoryError;
+    }
+    if (missingAssignment) {
+        const error = assignmentMissing();
+        if (provenScope)
+            retainAssignmentRefusal(context, expectedRoot, command, () => { persist(); return baseKey; }, error);
+        throw error;
+    }
     if (lifecycle) {
         let inserted = false;
         const receipt = observeLifecycleInvocation(context, {

package/dist/services/lifecycle-invocations.js

@@ -20,7 +20,7 @@ import { isRegisteredRepair } from "./repair-receipt.js";
 import { stageAttempt, stageWorkIds } from "./stage-work-graph.js";
 import { contextualPathOptionsForLifecycle } from "../cli/command-inputs.js";
 import { canonicalPath } from "../storage/paths.js";
-import { runtimeCommand, shellArgument } from "./runtime-command.js";
+import { runtimeCommand, shellArgument, checkRetryArgs, recoveryEvidenceInput } from "./runtime-command.js";
 import { assignedLifecycleBinding, claimAssignedLifecycle, currentAssignedLifecycle, bindAssignedCoordinatorPacket, inheritAssignedPackets, retainControllerStageAssignment, admitAssignedAuxiliary, bindAssignedStageResume, readAcceptedAssignedWork, assertTerminalSettlementUnreserved } from "./assigned-lifecycle.js";
 import { appendAudit } from "./audit.js";
 import { recordTechnicalNote } from "./technical-notes.js";
@@ -628,8 +628,7 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
                     }
                     else {
                         error.details.recoverable = false;
-                        delete error.details.retry_command;
-                        delete error.details.retry_instruction;
+                        removeRetryPromises(error.details);
                         if (inputKey)
                             error.details.repeated_without_progress = true;
                         else
@@ -641,8 +640,7 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
                 }
                 if (error && !auxiliary && record.disposition === "fatal") {
                     error.details.recoverable = false;
-                    delete error.details.retry_command;
-                    delete error.details.retry_instruction;
+                    removeRetryPromises(error.details);
                 }
                 if (previous?.storage_retry === 1)
                     Object.assign(record, { storage_retry: 1, work_id: previous.work_id });
@@ -663,9 +661,10 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
                 throw persistence;
             if (error) {
                 error.details.recoverable = false;
-                delete error.details.retry_command;
-                delete error.details.retry_instruction;
+                removeRetryPromises(error.details);
             }
+            if (outcome.error)
+                removeRetryPromises(outcome.error.details);
             // Diagnostic evidence is not replay authority. If SQL is unavailable,
             // the controller still sees this failure and fences instead of waiting
             // for a model to report it or invent a new invocation.
@@ -686,10 +685,10 @@ export function observeLifecycleCommand(context, command, nativeEvent) {
         if (outcome.error && error) {
             outcome.error.code = error.code;
             outcome.error.message = error.message;
+            removeRetryPromises(outcome.error.details);
             Object.assign(outcome.error.details, error.details);
             if (record.disposition === "fatal") {
-                delete outcome.error.details.retry_command;
-                delete outcome.error.details.retry_instruction;
+                removeRetryPromises(outcome.error.details);
             }
         }
     };
@@ -892,16 +891,16 @@ export function managedLifecycleCommand(context, command, options = {}) {
         return publicInvocationCommand(context, load(context, issued.id), command);
     });
 }
-export function retryLifecycleInvocationCommand(context, id, checkReceiptId) {
+export function retryLifecycleInvocationCommand(context, id, checkReceiptId, needsEvidenceInput = false) {
     const prior = load(context, id);
     if (prior.status !== "executing")
         throw new AppError("invocation_retry_not_authorized", "Only the executing lifecycle operation can publish its next attempt", 1);
-    return successorLifecycleInvocationCommand(context, prior, checkReceiptId);
+    return successorLifecycleInvocationCommand(context, prior, checkReceiptId, needsEvidenceInput);
 }
 /** A predecessor may publish exactly one successor only while the caller has
  * proved that no lifecycle effect was admitted. Shared by CLI argument
  * validation and conclusive lifecycle/result rejection, never by hooks. */
-function successorLifecycleInvocationCommand(context, prior, checkReceiptId) {
+function successorLifecycleInvocationCommand(context, prior, checkReceiptId, needsEvidenceInput = false) {
     const parsed = invocation(prior.command);
     const argv = [...parsed.argv];
     const at = argv.indexOf("--invocation-id");
@@ -925,7 +924,12 @@ function successorLifecycleInvocationCommand(context, prior, checkReceiptId) {
                 throw new AppError("invocation_command_invalid", "Retained retry option cannot be rewritten unambiguously", 1);
             retained = retained.replace(fragments[0], "");
         }
-        command = retained.replace(` --invocation-id ${prior.id}`, ` --retry-check ${shellArgument(checkReceiptId)} --reason ${shellArgument("Recheck after diagnosis and correction of the failed check")}`);
+        const scope = JSON.parse(prior.scope_json);
+        if (needsEvidenceInput && !scope.runId)
+            throw new AppError("runtime_missing", "Check recovery requires a bound RUN", 1);
+        const retryArgs = needsEvidenceInput ? checkRetryArgs(context, scope.projectRoot, scope.runId, checkReceiptId)
+            : ["--retry-check", checkReceiptId, "--reason", "Recheck after diagnosis and correction of the failed check"];
+        command = retained.replace(` --invocation-id ${prior.id}`, ` ${retryArgs.map(shellArgument).join(" ")}`);
     }
     const successor = managedLifecycleCommand({ ...context, env: { ...context.env, DD_FLOW_INVOCATION_SCOPE: prior.scope_json, DD_FLOW_CURRENT_INVOCATION: prior.id } }, command);
     const next = stagedContinuations.get(context.db)?.get(prior.id) ?? currentIssuedCommand(context, prior.scope_json, successor, prior.id);
@@ -946,6 +950,15 @@ function settleUnadmittedInvocation(context, prior, error) {
     return details;
 }
 const receiptTimeout = (id) => ({ code: "invocation_receipt_timeout", message: "No native confirmation before the receipt deadline; lifecycle state was not changed", exitCode: 1, details: { invocation_id: id } });
+export function removeRetryPromises(details) {
+    delete details.retry_command;
+    delete details.retry_instruction;
+    if (details.continuation && typeof details.continuation === "object" && !Array.isArray(details.continuation)) {
+        const continuation = { ...details.continuation };
+        delete continuation.command_after_input;
+        details.continuation = continuation;
+    }
+}
 /** Settle a conclusive rejection and publish its only legal successor atomically.
  * A crash must leave either the old attempt executing, or both the settled
  * outcome and its successor; never a usable successor beside an unknown effect. */
@@ -962,8 +975,7 @@ export function settleLifecycleRejection(context, id, error) {
     }
     storage(context);
     // Only this settlement may publish a successor; inherited help is not authority.
-    delete error.details.retry_command;
-    delete error.details.retry_instruction;
+    removeRetryPromises(error.details);
     // A producer may have rendered help before throwing. Only the decision below
     // may publish replacement authority for a rejected operation.
     stagedContinuations.get(context.db)?.delete(id);
@@ -992,8 +1004,15 @@ export function settleLifecycleRejection(context, id, error) {
                 && !context.db.get("SELECT 1 FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? AND json_extract(outcome_json, '$.error.details.storage_retry') = 1 LIMIT 1", [prior.scope_json, prior.fingerprint]);
             if (prepared.retryable || storageRetry) {
                 const failures = prepared.receipts.map(value => value.receipt);
-                const retry = retryLifecycleInvocationCommand(context, id, failures[0]?.id);
+                const continuation = details.continuation;
+                const needsInput = failures.length > 0 && continuation?.kind === "needs_input";
+                const retry = retryLifecycleInvocationCommand(context, id, failures[0]?.id, needsInput);
                 details.retry_command = retry;
+                if (needsInput) {
+                    const scope = JSON.parse(prior.scope_json);
+                    const run = context.db.get("SELECT run_root FROM runs WHERE project_root = ? AND id = ?", [scope.projectRoot, scope.runId]);
+                    details.continuation = { ...continuation, ...recoveryEvidenceInput(run.run_root, failures[0].id), command_after_input: retry };
+                }
                 details.effect = "no_effect";
                 details.recoverable = true;
                 if (storageRetry)
@@ -1866,6 +1885,10 @@ export function observedLifecycleNativeEvent(context, command, daemonId) {
     // never choose the latest of several identical native calls.
     return matches.length === 1 ? { project_id: matches[0].project_id, id: matches[0].id } : null;
 }
+export function lifecycleDiagnosticFingerprint(command) {
+    const analysis = parseLifecycleCommand(command);
+    return analysis.kind === "standalone" ? fingerprint(analysis.invocation) : null;
+}
 /** Keep shell diagnostics distinct from genuinely absent native delivery. */
 export function observedLifecycleDiagnostic(context, command, daemonId, invocationId) {
     const analysis = parseLifecycleCommand(command);
@@ -2086,8 +2109,7 @@ function commandWithObservedWorkSemantics(row, argv) {
     return command;
 }
 export function settleLifecyclePreparationRejection(context, id, error, preparedCommand) {
-    delete error.details.retry_command;
-    delete error.details.retry_instruction;
+    removeRetryPromises(error.details);
     try {
         return context.db.writeTransaction(() => {
             let row = load(context, id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.161",
+  "version": "0.9.0-beta.162",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "packageManager": "pnpm@10.23.0",