@deksden-com/dd-flow-cli 0.9.0-beta.56 → 0.9.0-beta.63

package/CHANGELOG.md

@@ -1,5 +1,49 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.63
+
+### Patch Changes
+
+- Accept the qualified retained-subagent ZCode bridge and settle a control only
+  when a durable startup rejection proves that it created no native resources.
+
+## 0.9.0-beta.62
+
+### Patch Changes
+
+- Verify a controlled native Session with a fresh inspection after cancellation before treating its tree as settled.
+
+## 0.9.0-beta.61
+
+### Patch Changes
+
+- Keep the scope reconciliation contract test type-safe.
+
+## 0.9.0-beta.60
+
+### Patch Changes
+
+- Document and verify explicit reconciliation of a drained runtime scope without automatic observer respawn.
+
+## 0.9.0-beta.59
+
+### Patch Changes
+
+- Keep bundled ZCode close-contract fixtures aligned with retained native topology checks.
+
+## 0.9.0-beta.58
+
+### Patch Changes
+
+- Keep local task artifacts outside the release lint scope.
+
+## 0.9.0-beta.57
+
+### Patch Changes
+
+- Bound recovery observation, expose safe external reconciliation, and require
+  complete non-resident ZCode session-tree evidence before a stopped run settles.
+
 ## 0.9.0-beta.56
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,15 +1,15 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.56",
-  "cli_commit": "ae4bbaa5b2299aeedf3ee90bccc8ed3db19a6191",
-  "built_at": "2026-09-13T21:08:32.108Z",
+  "cli_version": "0.9.0-beta.63",
+  "cli_commit": "4975ba184bd847fd34db995cd3d9e1feb3db9f9f",
+  "built_at": "2026-09-14T10:36:19.793Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "97f811d33c212ae3497020178b1ed825c7c3ebac",
     "flow_contract": "dd-flow-canonical-2026-08",
-    "repo_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank",
-    "memorybank_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank/.memory-bank",
-    "flow_root": "/home/runner/work/dd-flow-cli/dd-flow-cli/dd-memorybank/.memory-bank/dd-flow",
+    "repo_root": "/Users/deksden/Documents/_Projects/dd-memorybank",
+    "memorybank_root": "/Users/deksden/Documents/_Projects/dd-memorybank/.memory-bank",
+    "flow_root": "/Users/deksden/Documents/_Projects/dd-memorybank/.memory-bank/dd-flow",
     "layout": "dot_memory_bank"
   }
 }

package/dist/cli/help.js

@@ -5,6 +5,7 @@ const helpPages = new Map([
   dd-flow runtime scope stop --scope-id EVAL_ID --request-id ID --json
   dd-flow runtime scope control --scope-id EVAL_ID --request-id ID --mode pause|stop [--manifest-json JSON] --json
   dd-flow runtime scope resume --scope-id EVAL_ID --request-id ID --generation N --capture-key SHA256 --json
+  dd-flow runtime scope reconcile --scope-id EVAL_ID --generation N --request-id ID --json
 
 Use the EVAL manifest's retained DD_FLOW_RESOURCE_HOME. Commands select exactly
 one scope across its registered runtime homes; neighboring scopes are untouched.
@@ -188,6 +189,7 @@ Usage:
   dd-flow id next --type protocol|run --project-root <root> --slug <slug> --json
   dd-flow run status <RUN-ID|RUN-short-id> --project-root <root> --json
   dd-flow run control status --run <RUN-ID> --project-root <root> --json
+  dd-flow run control reconcile --run <RUN-ID> --project-root <root> --control-id <ID> --request-id <ID> --json
   dd-flow run drive launch --run <RUN-ID> --project-root <root> --request-id <id> --context-file <file> --context-sha256 <sha256> [--stop-after <stage>] [--capture-root <directory>] --json
   dd-flow run drive status --run <RUN-ID> --project-root <root> [--after <sequence>] --json
   dd-flow run list --project-root <root> --json

package/dist/cli/run-cli.js

@@ -59,11 +59,11 @@ import { loadExternalStageContext } from "../services/stage-context.js";
 import { stopManagedProcess, confirmManagedProcess, finishManagedProcess, heartbeatManagedProcess, managedProcessRuntimeHome, managedProcessStatus, processIsAlive, reconcileExpiredManagedProcesses, registerManagedProcess } from "../services/managed-processes.js";
 import { fenceRuntimeBudget, runtimeBudgetStatus, admitRuntimeCheck, parseRuntimeBudget, reserveProviderTurn, releaseProviderTurns } from "../services/runtime-budget.js";
 import { stopRuntimeScope } from "../services/runtime-scope-stop.js";
-import { launchRuntimeScopeControl, launchRuntimeScopeResume, serveRuntimeScopeControl } from "../services/runtime-scope-worker.js";
+import { launchRuntimeScopeControl, launchRuntimeScopeResume, reconcileRuntimeScopeControl, serveRuntimeScopeControl } from "../services/runtime-scope-worker.js";
 import { launchRunController, resumeRunController, serveRunController, runControllerStatus, answerRunController, supplyRunControllerContext } from "../services/run-controller.js";
 import { controllerHitlAdmission } from "../services/run-controller-adapter.js";
 import { controlLifecycleReply, runControlStatus } from "../services/run-control.js";
-import { requestRunControl, serveRunControl } from "../services/run-control-worker.js";
+import { reconcileRunControl, requestRunControl, serveRunControl } from "../services/run-control-worker.js";
 import { startRuntimeService } from "../services/runtime-service.js";
 const defaultIo = {
     stdout: process.stdout,
@@ -1142,6 +1142,11 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
             const scope = { projectRoot: requiredOption(parsed, "project-root"), runId: requiredOption(parsed, "run") };
             if (action === "status")
                 return runControlStatus(context, scope);
+            if (action === "reconcile") {
+                if ([...parsed.options.keys()].some(key => !["run", "project-root", "control-id", "request-id"].includes(key)) || [...parsed.options.values()].some(values => values.length !== 1))
+                    throw new AppError("usage", "Use run control reconcile --run ID --project-root PATH --control-id ID --request-id ID", 2);
+                return await reconcileRunControl(context, { ...scope, controlId: requiredOption(parsed, "control-id"), requestId: requiredOption(parsed, "request-id") });
+            }
             if (action === "resume") {
                 if (["force", "grace-ms", "escalate"].some(option => hasOption(parsed, option)))
                     throw new AppError("usage", "Resume does not accept stop or pause escalation options", 2);
@@ -1157,7 +1162,7 @@ async function dispatch(args, context, io, scopeProjectRoot = null, classificati
                     ...(hasOption(parsed, "escalate") ? { escalate: requiredOption(parsed, "escalate") } : {}),
                     ...(hasOption(parsed, "wait-ms") ? { waitMs: Number(requiredOption(parsed, "wait-ms")) } : {})
                 });
-            throw new AppError("usage", "Use: dd-flow run control pause|stop|resume|status", 2);
+            throw new AppError("usage", "Use: dd-flow run control pause|stop|resume|reconcile|status", 2);
         }
         if (command === "drive") {
             const action = requiredPosition(parsed, 0, "drive action");
@@ -1790,6 +1795,11 @@ function dispatchRun(context, command, parsed) {
 }
 async function dispatchRuntime(context, command, parsed, progress) {
     if (command === "scope") {
+        if (parsed.positional.length === 1 && parsed.positional[0] === "reconcile") {
+            if ([...parsed.options.keys()].some(key => !["scope-id", "request-id", "generation"].includes(key)) || [...parsed.options.values()].some(values => values.length !== 1))
+                throw new AppError("usage", "Use runtime scope reconcile --scope-id ID --generation N --request-id ID", 2);
+            return { ok: true, ...await reconcileRuntimeScopeControl(context, requiredOption(parsed, "scope-id"), Number(requiredOption(parsed, "generation")), requiredOption(parsed, "request-id")) };
+        }
         if (parsed.positional.length === 1 && parsed.positional[0] === "resume") {
             if ([...parsed.options.keys()].some(key => !["scope-id", "request-id", "generation", "capture-key"].includes(key)) || [...parsed.options.values()].some(values => values.length !== 1))
                 throw new AppError("usage", "Use runtime scope resume --scope-id ID --request-id ID --generation N --capture-key SHA256", 2);

package/dist/harness-runtime/lib/dd-zcode-daemon.mjs

@@ -16,6 +16,8 @@ import {
   forkSessionWithBridge,
   inspectSessionWithBridge,
   promptSessionWithBridge,
+  zcodeChildSessionIds,
+  observeClosedZcodeTree,
 } from "./dd-zcode.mjs";
 
 const REQUEST_SCHEMA = "dd-zcode/daemon-request@1";
@@ -152,7 +154,7 @@ export async function startDaemon(options) {
   await removeSocket(paths.socket, paths.dir);
   const versions = await doctor({ bin: config.bin, zcodePath: config.zcodePath });
   if (hasFlowContext && versions.compatible !== true) {
-    throw new DaemonError("zcode_lifecycle_unqualified", "ZCode native event identity is not qualified for managed CLI admission; inspect lifecycle_qualification before starting E2E.", false, { observed_runtime: versions.observed_runtime, lifecycle_qualification: versions.lifecycle_qualification });
+    throw new DaemonError("zcode_lifecycle_unqualified", "ZCode native event identity is not qualified for managed CLI admission; inspect lifecycle_qualification before starting E2E.", false, { startup_resources: "not_created", observed_runtime: versions.observed_runtime, lifecycle_qualification: versions.lifecycle_qualification });
   }
   const resourceProcess = await registerDaemonProcess(config, {
     kind: "zcode-daemon", owner: `zcode:${path.basename(paths.dir)}`, operation: `zcode-daemon:${path.basename(paths.dir)}`,
@@ -228,7 +230,7 @@ export class DaemonRuntime {
     const known = this.sessions.get(params.sessionId);
     const adapter = params.adapterSessionId ?? known?.adapter_session_id ?? params.sessionId;
     const generation = this.activeGeneration ?? this.controlGeneration ?? 0;
-    return { ...this.state.config, ...params, adapterSessionId: adapter, daemonId: this.state.daemon_id, allowBackground: true, liveSession: this.liveAdapters.has(adapter), assertDispatch: () => { if (generation !== (this.controlGeneration ?? 0)) throw new DaemonError("operation_cancelled", "ZCode prompt was cancelled before native dispatch"); } };
+    return { ...this.state.config, ...params, knownChildSessionIds: known?.known_child_session_ids ?? [], adapterSessionId: adapter, daemonId: this.state.daemon_id, allowBackground: true, liveSession: this.liveAdapters.has(adapter), assertDispatch: () => { if (generation !== (this.controlGeneration ?? 0)) throw new DaemonError("operation_cancelled", "ZCode prompt was cancelled before native dispatch"); } };
   }
 
   track(result, topology = result?.evidence?.subagents) {
@@ -244,6 +246,7 @@ export class DaemonRuntime {
       parent_provider_session_id: parent,
       root_provider_session_id: existing?.root_provider_session_id ?? (parent ? parentRoot : result.provider_session_id),
       topology: topology ?? existing?.topology ?? null,
+      known_child_session_ids: [...new Set([...(existing?.known_child_session_ids ?? zcodeChildSessionIds(existing?.topology)), ...zcodeChildSessionIds(topology)])],
       completed_turns: existing?.completed_turns ?? 0,
       close_receipt: result.close?.closed === true ? result : existing?.close_receipt ?? null,
     }); }
@@ -321,7 +324,17 @@ export class DaemonRuntime {
       const closed = this.sessions.get(params.sessionId)?.close_receipt;
       if (closed) {
         if (operation === "session.resume") throw new DaemonError("session_closed", "Closed Session requires explicit recovery");
-        return { ...closed, read: { projection: { status: "stopped" } }, subagents: closed.after, settled: closed.settled === true };
+        const topology = closed.topology;
+        if (topology?.root_session_id !== params.sessionId || !Array.isArray(topology.child_session_ids) || topology.child_session_ids.some(id => typeof id !== "string" || !id)) return { ...closed, settled: false, observation_error: { code: "topology_incomplete", message: "closed Session has no native topology identity" } };
+        const previous = this.state.settlement_observations?.[params.sessionId];
+        const known = [...new Set([...topology.child_session_ids, ...(previous?.topology?.child_session_ids ?? [])])];
+        const observation = { ...closed, ...await observeClosedZcodeTree(this.bridge, params.sessionId, known), observed_at: new Date().toISOString() };
+        // Observations are not ownership inventory: their timestamps must not
+        // invalidate a drain fence on every read.
+        this.state.settlement_observations ??= {};
+        this.state.settlement_observations[params.sessionId] = observation;
+        await this.persist();
+        return observation;
       }
       const adapter = params.adapterSessionId ?? params.sessionId;
       if (!this.liveAdapters.has(adapter) && this.activeProductive) {
@@ -367,7 +380,8 @@ export class DaemonRuntime {
     const unsettled = [];
     for (const session of this.sessions.values()) {
       if (session.close_receipt) {
-        if (!session.close_receipt.settled) unsettled.push(session.provider_session_id);
+        const observed = await this.dispatch("session.inspect", { sessionId: session.provider_session_id });
+        if (observed.settled !== true) unsettled.push(session.provider_session_id);
         continue;
       }
       const options = this.options({ sessionId: session.provider_session_id, adapterSessionId: session.adapter_session_id });

package/dist/harness-runtime/lib/dd-zcode.mjs

@@ -199,11 +199,14 @@ export class AcpBridge {
     if (message.method === "session/update" && this.options.onLifecycleNotification) {
       const observer = this.options.onLifecycleNotification;
       const pending = Promise.resolve().then(() => observer(message)).catch(async error => {
-        if (!this.notificationError || (fatalLifecycleError(error) && !fatalLifecycleError(this.notificationError))) this.notificationError = error;
+        // A validated no-effect rejection is returned through the invocation
+        // ledger. It is evidence, not a poisoned ACP Session.
+        const fatal = fatalLifecycleError(error);
+        if (!this.notificationError || fatal) this.notificationError = error;
         // A missing/foreign authority is not a recoverable CLI validation
         // result. Stop admitting productive requests immediately; the managed
         // controller still owns physical stop/drain and evidence capture.
-        if (fatalLifecycleError(error)) this.rejectAll(error);
+        if (fatal) this.rejectAll(error);
         try {
           await this.journal.write("notification_failure", { code: error.code ?? "invocation_observation_failed", message: error.message,
             session_id: message.params?.sessionId ?? null, tool_call_id: update?.toolCallId ?? null, event_time: now(), delivery_stage: "lifecycle_receipt", completeness: "incomplete" });
@@ -429,7 +432,50 @@ export function latestAssistantText(read) {
   return null;
 }
 
-async function cancelTree(bridge, sessionId, before, providerSessionId) {
+export function zcodeChildSessionIds(snapshot) {
+  return [...new Set([
+    ...(Array.isArray(snapshot?.childSessionIds) ? snapshot.childSessionIds : []),
+    ...(Array.isArray(snapshot?.running) ? snapshot.running : []).map(child => child?.childSessionId),
+    ...(Array.isArray(snapshot?.ended?.items) ? snapshot.ended.items : []).map(child => child?.childSessionId),
+  ].filter(id => typeof id === "string" && id))];
+}
+
+// Read residency BEFORE each durable topology snapshot. An inactive node cannot
+// add descendants; a resident node never proves settlement, even when idle.
+// No resolve/read/subagents extension here: those may implicitly resume.
+export async function observeClosedZcodeTree(bridge, root, retainedChildren = []) {
+  const pending = new Set([root, ...retainedChildren]), residents = [], snapshots = [];
+  const deadline = performance.now() + 30_000;
+  try {
+    for (const sessionId of pending) {
+      if (pending.size > 1024 || performance.now() >= deadline) throw new Error("Closed tree observation limit exceeded");
+      const timeout = () => Math.max(1, Math.min(5000, deadline - performance.now()));
+      const resident = await bridge.request("zcode/session/resident", { sessionId }, timeout());
+      if (resident?.sessionId !== sessionId || typeof resident.resident !== "boolean") throw new Error("Invalid residency identity or state");
+      residents.push(resident);
+      const retained = await bridge.request("zcode/session/retainedSubagents", { sessionId }, timeout());
+      const tree = retained?.topology;
+      if (retained?.sessionId !== sessionId || !Array.isArray(tree?.childSessionIds)
+        || tree.childSessionIds.some(id => typeof id !== "string" || !id || id === sessionId)
+        || !Array.isArray(tree?.running) || !Array.isArray(tree?.ended?.items)
+        || !Number.isSafeInteger(tree.ended.total) || tree.ended.total < 0
+        || tree.ended.total > tree.childSessionIds.length
+        || [...tree.running, ...tree.ended.items].some(child => !tree.childSessionIds.includes(child?.childSessionId))) throw new Error("Incomplete retained native topology");
+      snapshots.push({ sessionId, ...tree });
+      for (const child of tree.childSessionIds) pending.add(child);
+    }
+    return { topology: { root_session_id: root, child_session_ids: [...pending].filter(id => id !== root), complete: true }, residents, snapshots, settled: residents.every(item => item.resident === false) };
+  } catch (error) {
+    return { topology: { root_session_id: root, child_session_ids: [...pending].filter(id => id !== root), complete: false }, residents, snapshots, settled: false, observation_error: { code: error.code ?? "topology_observation_failed", message: error.message } };
+  }
+}
+
+async function cancelTree(bridge, sessionId, before, providerSessionId, retainedChildren = []) {
+  const knownChildren = new Set(retainedChildren);
+  const remember = snapshot => {
+    for (const id of zcodeChildSessionIds(snapshot)) knownChildren.add(id);
+  };
+  remember(before);
   const cancellations = [];
   for (const child of before.running ?? []) {
     const taskId = child.taskId ?? child.agentId;
@@ -452,27 +498,20 @@ async function cancelTree(bridge, sessionId, before, providerSessionId) {
       bridge.request("zcode/session/read", { sessionId }, timeout).catch(error => ({ observation_error: { code: error.code, message: error.message } })),
     ]);
     root_status = read?.projection?.status ?? read?.session?.status ?? null;
+    remember(after);
     if (after.observation_error || read?.observation_error) break;
     if (Array.isArray(after.running) && !after.running.length && !(read?.projection?.activeToolCalls ?? []).length && ["idle", "completed", "cancelled", "failed", "stopped"].includes(root_status)) {
-      return { cancellations, before, after, root_status, cancellation_requested: false, settled: true, close_requested: false };
+      // Idle is only a turn-level observation. Close the owned resident before
+      // proving the transitive tree cannot create another child.
+      break;
     }
   }
   let close = null;
   try { close = await bridge.request("zcode/session/close", { sessionId }); }
   catch (error) { close = { closed: false, error: { code: error.code ?? "close_failed", message: error.message } }; }
-  const knownChildren = [...new Set([...(before.running ?? []), ...(after.running ?? [])].map(child => child.childSessionId).filter(Boolean))];
-  const residents = close?.closed === true ? await Promise.all([providerSessionId, ...knownChildren].map(async id => {
-    try {
-      const observed = await bridge.request("zcode/session/resident", { sessionId: id }, 5000);
-      if (observed.sessionId !== id) throw Object.assign(new Error("Residency evidence belongs to another Session"), { code: "session_identity_mismatch" });
-      return observed;
-    }
-    catch (error) { return { sessionId: id, observation_error: { code: error.code, message: error.message } }; }
-  })) : [];
-  const completeTopology = !before.observation_error && Array.isArray(before.running) && !after.observation_error && Array.isArray(after.running)
-    && [...(before.running ?? []), ...after.running].every(child => typeof child.childSessionId === "string");
-  return { cancellations, before, after, root_status, cancellation_requested: true, close_requested: true, close, residents,
-    settled: close?.closed === true && completeTopology && residents.length > 0 && residents.every(item => item.resident === false) };
+  const observation = close?.closed === true ? await observeClosedZcodeTree(bridge, providerSessionId, [...knownChildren])
+    : { topology: { root_session_id: providerSessionId, child_session_ids: [...knownChildren], complete: false }, settled: false };
+  return { cancellations, before, after, root_status, cancellation_requested: true, close_requested: true, close, ...observation };
 }
 
 // Cancel one known child without cancelling its parent turn.  The parent keeps
@@ -642,8 +681,9 @@ async function forwardUsage(options, providerSessionId, usage, toolCalls) {
 export function zcodeLifecycleQualification(sha256, bridgeCommit, harnessContract) {
   // Behavioural evidence: dd-eval production-invocations probe, 2026-09-13.
   // Pin both providers of native event identity, not a string in the bundle.
+  // 60af0d3 adds retainedSubagents without changing native event forwarding.
   const qualified = sha256 === "e9f1868c0fdb863537ed910ee3828b9be96b8c2fd805473f63b439e1113266b8"
-    && bridgeCommit === "e0600fe3c46e215695f257e65aa6f674ced998d8" && harnessContract === ZCODE_HARNESS_CONTRACT;
+    && ["e0600fe3c46e215695f257e65aa6f674ced998d8", "60af0d31e13076a313d9770f10aa70f7c94742cf"].includes(bridgeCommit) && harnessContract === ZCODE_HARNESS_CONTRACT;
   return { status: qualified ? "qualified" : "unqualified", mechanism: "cli-invocation@1", sha256,
     capabilities: qualified ? ["root", "concurrent_children", "child_continuation"] : [],
     native_nested_children: false, reason: qualified ? null : "native_event_contract_unqualified" };
@@ -749,7 +789,7 @@ export async function cancelSessionWithBridge(bridge, options) {
   requireJournal(options);
   const identity = await controlledIdentity(bridge, options);
   const before = await bridge.request("zcode/session/subagents", { sessionId: identity.adapterSessionId }).catch(error => ({ observation_error: { code: error.code, message: error.message } }));
-  return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...await cancelTree(bridge, identity.adapterSessionId, before, identity.providerSessionId) });
+  return receipt(options, { harness: "zcode-acp", provider_session_id: identity.providerSessionId, adapter_session_id: identity.adapterSessionId, ...await cancelTree(bridge, identity.adapterSessionId, before, identity.providerSessionId, options.knownChildSessionIds) });
 }
 
 export async function forkSession(options) {

package/dist/services/harness-adapter.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { AppError } from "../shared/errors.js";
+import { recoveryRpcTimeout } from "./recovery-observation-budget.js";
 const maxAdapterOutputBytes = 1_000_000;
 /** Native hooks need a real executable, not a PATH-dependent shell expression. */
 export function prepareHarnessFlowExecutable(context, stateDir) {
@@ -37,7 +38,7 @@ export function prepareHarnessFlowExecutable(context, stateDir) {
 }
 /** Runs one harness command with the lifecycle guarantees shared by agent services. */
 export function runHarnessAdapter(input) {
-    const timeoutMs = input.timeoutMs ?? 120_000;
+    const timeoutMs = recoveryRpcTimeout(input.timeoutMs ?? 120_000);
     if (!input.operationId.trim())
         throw new AppError("operation_id_required", "Harness calls require a scoped operation id", 2);
     // The current adapter transport uses this name; its identity is runtime-owned,

package/dist/services/hooks.js

@@ -9,7 +9,7 @@ import { ensureDir, resolveProjectRoot } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { nativeSessionIdentity, storageSessionId } from "./session-identity.js";
 import { assertRecoveryHookCurrent } from "./run-recovery.js";
-import { observeLifecycleInvocation } from "./lifecycle-invocations.js";
+import { observeLifecycleInvocation, settleLifecycleNoEffectRejection } from "./lifecycle-invocations.js";
 import { commandHasOption, commandOption, commandPosition, shellSuffixOffset, parseLifecycleCommand, unwrapShellCommand } from "./lifecycle-command.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { activeFlowSessionsForProject, bindObservedFlowSession, flowSessionPayloadFromRegisterCommand, recordFlowSessionObservation } from "./sessions.js";
@@ -433,9 +433,9 @@ export function handleZcodeEvent(context, input) {
         }) }, commandOption(parsed.invocation, "invocation-id"));
 }
 /**
- * Accept the synchronous native ZCode PreToolUse callback.  ACP notifications
- * are retained as evidence, but cannot be an admission signal: they arrive
- * after the tool call and may be serialized behind unrelated work.
+ * Accept the synchronous native ZCode PreToolUse callback. Invocation-ID
+ * commands instead rendezvous with their ACP event while the CLI awaits
+ * admission; the native hook must not create a competing receipt for them.
  */
 export function handleZcodeHook(context, input) {
     return recordZcodeLifecycle(context, input);
@@ -455,9 +455,6 @@ function recordZcodeLifecycle(context, input, invocationId) {
         return { ok: true, observed: false, reason: "event_not_participating" };
     if (!invocationId && commandOption(lifecycle.invocation, "invocation-id"))
         return { ok: true, observed: false, reason: "cli_invocation_owns_admission" };
-    if (lifecycle.analysis.kind === "compound") {
-        throw new AppError("compound_lifecycle_command", "dd-flow lifecycle commands must be a standalone ZCode Bash tool call", 1, { standalone_command: lifecycle.invocation.command });
-    }
     const expectedRoot = resolveProjectRoot(input.projectRoot);
     if (lifecycle.commandProjectRoot && resolveProjectRoot(lifecycle.commandProjectRoot) !== expectedRoot) {
         throw new AppError("project_mismatch", "ZCode lifecycle command project root does not match the controlled workspace", 1, { expected: expectedRoot, actual: lifecycle.commandProjectRoot });
@@ -477,6 +474,17 @@ function recordZcodeLifecycle(context, input, invocationId) {
     const toolUseId = stringValue(hook.tool_use_id) ?? stringValue(hook.toolUseId) ?? stringValue(hook.event_id) ?? stringValue(hook.eventId);
     if (!toolUseId)
         throw new AppError("zcode_hook_event_missing", "ZCode native hook has no tool-use ID", 1);
+    if (lifecycle.analysis.kind === "compound") {
+        if (lifecycle.analysis.reason !== "shell_composition")
+            throw new AppError("compound_lifecycle_command", "Ambiguous shell cannot authorize a lifecycle replacement", 1, { reason: lifecycle.analysis.reason });
+        if (invocationId) {
+            const error = { code: "compound_lifecycle_command", message: "dd-flow lifecycle commands must be a standalone ZCode Bash tool call", exitCode: 1,
+                details: { standalone_command: lifecycle.invocation.command } };
+            settleLifecycleNoEffectRejection(context, invocationId, lifecycle.invocation.command, error, { daemonId, rootSessionId: rootProviderSessionId, sessionId: providerSessionId, parentSessionId: parentProviderSessionId ?? null, toolCallId: toolUseId });
+            return { ok: true, observed: false, invocation_id: invocationId, no_effect: true, error };
+        }
+        throw new AppError("compound_lifecycle_command", "dd-flow lifecycle commands must be a standalone ZCode Bash tool call", 1, { standalone_command: lifecycle.invocation.command });
+    }
     const eventKey = crypto.createHash("sha256").update(JSON.stringify(["zcode-acp", daemonId, providerSessionId, toolUseId])).digest("hex");
     const rewritten = invocationId ? command : commandWithHookEvent(command, eventKey);
     if (!invocationId && rewritten === command && commandOption(lifecycle.invocation, "hook-event-id") !== eventKey)

package/dist/services/lifecycle-invocations.js

@@ -69,7 +69,7 @@ export function lifecycleRetryCommands(context, stage) {
                 return [];
             const successor = load(context, commandOption(invocation(retry), "invocation-id") ?? "");
             const latest = context.db.get("SELECT * FROM lifecycle_invocations WHERE scope_json = ? AND fingerprint = ? ORDER BY rowid DESC LIMIT 1", [row.scope_json, row.fingerprint]);
-            return successor.id === latest?.id && successor.status === "issued" ? [retry] : [];
+            return successor.id === latest?.id && successor.status === "issued" && (successor.deadline === null || successor.deadline > Date.now()) ? [retry] : [];
         }
         catch {
             return [];
@@ -109,6 +109,7 @@ export function managedLifecycleCommand(context, command) {
             throw new AppError("invocation_scope_mismatch", "Lifecycle attempt belongs to another managed scope", 1, { invocation_id: suppliedId });
         }
         checkCommand(retained, command);
+        assertRenderableInvocation(retained);
         return command;
     }
     if (!context.db.writable || context.env.DD_FLOW_INVOCATION_READONLY === "1") {
@@ -143,21 +144,67 @@ export function retryLifecycleInvocationCommand(context, id) {
     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);
+}
+/** A predecessor may publish exactly one successor only while the caller has
+ * proved that no lifecycle effect was admitted.  This is shared by ordinary
+ * command validation and the native pre-execution rejection path. */
+function successorLifecycleInvocationCommand(context, prior) {
     const parsed = invocation(prior.command);
     const argv = [...parsed.argv];
     const at = argv.indexOf("--invocation-id");
-    if (at < 0 || argv[at + 1] !== id)
+    if (at < 0 || argv[at + 1] !== prior.id)
         throw new AppError("invocation_command_invalid", "Retained issued command lost its invocation marker", 1);
     // The parser proves the marker belongs to argv. Remove that one rendered
     // token from the retained text so response-file/stdin/heredoc presentation
     // remains byte-for-byte stable across a retry.
-    const marker = ` --invocation-id ${id}`;
+    const marker = ` --invocation-id ${prior.id}`;
     const markerAt = prior.command.indexOf(marker);
     if (markerAt < 0 || prior.command.indexOf(marker, markerAt + marker.length) >= 0)
         throw new AppError("invocation_command_invalid", "Retained issued command has an ambiguous invocation marker", 1);
     const command = `${prior.command.slice(0, markerAt)}${prior.command.slice(markerAt + marker.length)}`;
-    return managedLifecycleCommand({ ...context, env: { ...context.env, DD_FLOW_INVOCATION_SCOPE: prior.scope_json, DD_FLOW_CURRENT_INVOCATION: id } }, command);
+    return managedLifecycleCommand({ ...context, env: { ...context.env, DD_FLOW_INVOCATION_SCOPE: prior.scope_json, DD_FLOW_CURRENT_INVOCATION: prior.id } }, command);
+}
+/** A native observer can reject a malformed tool call before the CLI claims
+ * execution.  Persist that fact and its sole replacement atomically: waiting
+ * callers must never time out merely because the observer rejected syntax. */
+export function settleLifecycleNoEffectRejection(context, id, command, error, identity) {
+    storage(context);
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        const prior = load(context, id);
+        checkCommand(prior, command);
+        const scope = JSON.parse(prior.scope_json);
+        checkNativeIdentity(scope, identity, id);
+        if (prior.status === "settled") {
+            context.db.exec("COMMIT");
+            return;
+        }
+        if (scope.runId)
+            assertLifecycleInvocationCurrent(context, scope, command);
+        if (prior.status !== "issued")
+            throw new AppError("invocation_rejection_conflict", "A lifecycle rejection arrived after execution admission", 1, { invocation_id: id });
+        settleUnadmittedInvocation(context, prior, error);
+        context.db.exec("COMMIT");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
 }
+// Caller holds the write transaction and has checked authority. Issued (or
+// legacy expired) attempts have never admitted an effect; observed/executing
+// attempts must never receive an automatic replacement.
+function settleUnadmittedInvocation(context, prior, error) {
+    if (!["issued", "expired"].includes(prior.status))
+        throw new AppError("invocation_rejection_conflict", "Attempt already admitted native execution", 1);
+    const details = { ...error.details, retry_command: successorLifecycleInvocationCommand(context, prior),
+        retry_instruction: "Use retry_command as one standalone lifecycle command. The rejected command did not change lifecycle state." };
+    if (context.db.run("UPDATE lifecycle_invocations SET status = 'settled', outcome_json = ?, updated_at = ? WHERE id = ? AND status = ?", [JSON.stringify({ error: { ...error, details } }), context.now(), prior.id, prior.status]).changes !== 1) {
+        throw new AppError("invocation_settlement_conflict", "Lifecycle rejection could not be committed", 1, { invocation_id: prior.id });
+    }
+}
+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 } });
 /** 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. */
@@ -291,7 +338,13 @@ function commandWithInvocationId(command, id) {
 /** The attempt owns authority; the caller owns presentation-only shell input.
  * Preserve current stdin/heredoc/response-file text while validating that it
  * still names the exact persisted operation and project. */
+function assertRenderableInvocation(row) {
+    if (row.status === "expired" || row.status === "issued" && row.deadline !== null && row.deadline <= Date.now()) {
+        throw new AppError("invocation_expired", "Retained lifecycle attempt has expired; inspection cannot grant a new attempt", 1, { invocation_id: row.id, status: row.status, outcome: row.outcome_json ? JSON.parse(row.outcome_json) : null });
+    }
+}
 function renderInvocationCommand(row, command) {
+    assertRenderableInvocation(row);
     const parsed = invocation(command);
     if (commandOption(parsed, "invocation-id"))
         throw new AppError("invocation_command_invalid", "Rendered lifecycle command already has an invocation id", 1);
@@ -301,6 +354,13 @@ function renderInvocationCommand(row, command) {
 }
 /** Native observer and receipt writer commit together. Never await I/O inside
  * this transaction; the callback must write to this same SQLite connection. */
+function checkNativeIdentity(scope, identity, id) {
+    if (identity.daemonId !== scope.daemonId || identity.rootSessionId !== scope.rootSessionId
+        || !identity.sessionId || !identity.toolCallId
+        || (identity.sessionId === scope.rootSessionId ? identity.parentSessionId !== null : !identity.parentSessionId)) {
+        throw new AppError("invocation_identity_mismatch", "Native identity does not belong to the issued managed scope", 1, { invocation_id: id });
+    }
+}
 export function observeLifecycleInvocation(context, input) {
     const initial = load(context, input.id);
     checkCommand(initial, input.command);
@@ -311,11 +371,7 @@ export function observeLifecycleInvocation(context, input) {
         return { eventKey: initial.event_key, duplicate: true };
     const scope = JSON.parse(initial.scope_json);
     const identity = input.identity;
-    if (identity.daemonId !== scope.daemonId || identity.rootSessionId !== scope.rootSessionId
-        || !identity.sessionId || !identity.toolCallId
-        || (identity.sessionId === scope.rootSessionId ? identity.parentSessionId !== null : !identity.parentSessionId)) {
-        throw new AppError("invocation_identity_mismatch", "Native identity does not belong to the issued managed scope", 1, { invocation_id: input.id });
-    }
+    checkNativeIdentity(scope, identity, input.id);
     const identityJson = JSON.stringify([identity.daemonId, identity.rootSessionId, identity.sessionId, identity.parentSessionId, identity.toolCallId]);
     context.db.exec("BEGIN IMMEDIATE");
     try {
@@ -325,7 +381,11 @@ export function observeLifecycleInvocation(context, input) {
             return { eventKey: row.event_key, duplicate: true };
         }
         if (row.status === "expired" || (row.deadline !== null && row.deadline <= Date.now() && !row.event_key)) {
-            throw new AppError("invocation_expired", "Late observation cannot revive an expired lifecycle attempt", 1, { invocation_id: input.id });
+            if (scope.runId)
+                assertLifecycleInvocationCurrent(context, scope, input.command);
+            settleUnadmittedInvocation(context, row, receiptTimeout(input.id));
+            context.db.exec("COMMIT");
+            return { eventKey: row.event_key, duplicate: true };
         }
         if (row.identity_json) {
             if (row.identity_json !== identityJson)
@@ -370,10 +430,20 @@ export async function awaitLifecycleInvocation(context, input) {
             continue;
         }
         if (row.status === "expired" || (row.deadline !== null && row.deadline <= Date.now())) {
-            const expired = context.db.run("UPDATE lifecycle_invocations SET status = 'expired', updated_at = ? WHERE id = ? AND status = 'issued'", [context.now(), input.id]);
-            if (!expired.changes && row.status !== "expired")
-                continue;
-            throw new AppError("invocation_receipt_timeout", "No native confirmation before the receipt deadline; lifecycle state was not changed", 1, { invocation_id: input.id });
+            context.db.exec("BEGIN IMMEDIATE");
+            try {
+                const current = load(context, input.id);
+                if (["issued", "expired"].includes(current.status)) {
+                    input.assertCurrent(JSON.parse(current.scope_json));
+                    settleUnadmittedInvocation(context, current, receiptTimeout(input.id));
+                }
+                context.db.exec("COMMIT");
+            }
+            catch (error) {
+                context.db.exec("ROLLBACK");
+                throw error;
+            }
+            continue;
         }
         await delay(Math.min(25, Math.max(1, (row.deadline ?? Date.now() + 25) - Date.now())));
     }

package/dist/services/native-session-control.js

@@ -8,15 +8,17 @@ export async function cancelControlledNativeSession(input) {
     if (input.observe && (reply.operation_id !== input.operationId || reply.operation !== "session.cancel" || reply.session_id !== input.sessionId))
         throw new AppError("controller_operation_mismatch", "Cancellation observation belongs to another operation or Session", 1);
     const result = input.observe ? reply.state === "completed" ? reply.result : null : reply;
+    // A completed cancel command is an immutable ACK, not proof that the
+    // provider tree has stopped. Callers must use a separate fresh inspection.
     if (!input.observe || reply.state === "completed")
-        assertNativeCancellationReceipt(result, input.sessionId, input.requireSettled);
+        assertNativeCancellationReceipt(result, input.sessionId);
     input.assertCurrent();
     return { status: result ? "completed" : "outcome_unknown", receipt: (result ?? reply) };
 }
-export function assertNativeCancellationReceipt(value, sessionId, requireSettled = false) {
+export function assertNativeCancellationReceipt(value, sessionId) {
     const identity = adapterSessionId(value);
-    if (!value || typeof value !== "object" || Array.isArray(value) || identity && identity !== sessionId || (requireSettled && value.settled !== true))
-        throw new AppError("controller_operation_mismatch", requireSettled ? "Cancellation receipt has no terminal settlement for its target Session" : "Cancellation receipt has no valid result for its target Session", 1);
+    if (!value || typeof value !== "object" || Array.isArray(value) || identity && identity !== sessionId)
+        throw new AppError("controller_operation_mismatch", "Cancellation receipt has no valid result for its target Session", 1);
 }
 /** Native observation is shared by RUN and non-Work EVAL owners. */
 export async function inspectControlledNativeSession(input) {

package/dist/services/recovery-observation-budget.js

@@ -0,0 +1,53 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { AppError } from "../shared/errors.js";
+export const recoveryObservationBudgetMs = 120_000;
+const activeObservation = new AsyncLocalStorage();
+export const withRecoveryObservation = (budget, action) => activeObservation.run(budget, action);
+export const recoveryRpcTimeout = (maximum) => activeObservation.getStore()?.timeout(maximum) ?? maximum;
+/** Call only while holding the existing owner-claim transaction. A replay of
+ * an explicit request never replenishes time, even after another request. */
+export function renewRecoveryObservation(snapshot, requestId) {
+    if (!requestId.trim() || requestId.length > 200)
+        throw new AppError("usage", "Reconciliation requires a nonempty request ID of at most 200 characters", 2);
+    const previous = snapshot.recovery_observation;
+    const ids = previous?.reconciliation_ids ?? [];
+    if (!Array.isArray(ids) || ids.some(id => typeof id !== "string"))
+        throw new AppError("recovery_observation_invalid", "Retained reconciliation identities are malformed", 1);
+    if (ids.includes(requestId))
+        return snapshot;
+    return { ...snapshot, recovery_observation: { budget_ms: recoveryObservationBudgetMs, remaining_ms: recoveryObservationBudgetMs, reconciliation_ids: [...ids, requestId], poll_index: 0 } };
+}
+/**
+ * Measures only time this owner can actually observe. Large scheduler gaps
+ * reset the sample instead of turning host sleep into evidence about a remote
+ * process. Persisting the remaining budget makes a recovered owner continue
+ * reconciliation rather than silently receiving a new unlimited wait.
+ */
+export function recoveryObservationBudget(saved, monotonic = () => performance.now()) {
+    const prior = saved && typeof saved === "object" ? saved.recovery_observation : null;
+    let remaining = typeof prior?.remaining_ms === "number" && Number.isFinite(prior.remaining_ms)
+        ? Math.max(0, Math.min(recoveryObservationBudgetMs, prior.remaining_ms))
+        : prior == null ? recoveryObservationBudgetMs : 0;
+    let last = monotonic();
+    let pollIndex = Number.isSafeInteger(prior?.poll_index) && prior.poll_index >= 0 ? prior.poll_index : 0;
+    const observation = {
+        exhausted: () => {
+            const current = monotonic();
+            const elapsed = current - last;
+            last = current;
+            // A gap means this process was not observing; it never proves progress
+            // or death and therefore does not consume the reconciliation budget.
+            if (elapsed >= 0 && elapsed <= 60_000)
+                remaining = Math.max(0, remaining - elapsed);
+            return remaining === 0;
+        },
+        state: () => ({ budget_ms: recoveryObservationBudgetMs, remaining_ms: Math.ceil(remaining), reconciliation_ids: prior?.reconciliation_ids ?? [], poll_index: pollIndex }),
+        timeout: (maximum = 30_000) => {
+            if (observation.exhausted())
+                throw new AppError("recovery_observation_budget_exhausted", "Recovery observation budget exhausted; explicit reconciliation is required", 1);
+            return Math.max(1, Math.min(maximum, Math.ceil(remaining)));
+        },
+        nextDelay: () => Math.min([1000, 2000, 5000, 10000][Math.min(pollIndex++, 3)], Math.ceil(remaining)),
+    };
+    return observation;
+}

package/dist/services/run-control-worker.js

@@ -13,6 +13,17 @@ import { confirmManagedProcess, finishManagedProcess, heartbeatManagedProcess, m
 import { interruptControlledSessions, observeControlledSessions, recordRunControlIntent, runControlStatus } from "./run-control.js";
 import { recoveryGuard, recordRecoveryCapture, sealRunRecovery } from "./run-recovery.js";
 import { createEvalRunSnapshot, verifyRecoverySnapshot } from "./eval-snapshots.js";
+import { recoveryObservationBudget, renewRecoveryObservation, withRecoveryObservation } from "./recovery-observation-budget.js";
+export async function reconcileRunControl(context, input) {
+    const status = runControlStatus(context, input);
+    const control = status.control;
+    if (!control?.current || !["requested", "settled"].includes(control.status))
+        throw new AppError("run_control_state_changed", "Reconciliation requires the current draining/sealed control", 1);
+    renewRecoveryObservation({}, input.requestId); // Validate before claiming anything.
+    if (control.status === "requested")
+        await launchControlWorker(context, { ...input, reconcileId: input.requestId });
+    return runControlStatus(context, input);
+}
 /** The caller publishes intent and launches a control owner; it never owns drain. */
 export async function requestRunControl(context, input) {
     if (input.waitMs !== undefined && (!Number.isSafeInteger(input.waitMs) || input.waitMs < 0 || input.waitMs > 60_000))
@@ -24,7 +35,7 @@ export async function requestRunControl(context, input) {
     };
     if (!receipt.control_id || receipt.status !== "requested")
         return projectReceipt();
-    const scope = { projectRoot: input.projectRoot, runId: input.runId, controlId: String(receipt.control_id) };
+    const scope = { projectRoot: input.projectRoot, runId: input.runId, controlId: String(receipt.control_id), ...(input.reconcileId ? { reconcileId: input.reconcileId } : {}) };
     await launchControlWorker(context, scope);
     const deadline = performance.now() + (input.waitMs ?? 0);
     while (performance.now() < deadline) {
@@ -49,8 +60,11 @@ async function launchControlWorker(context, input) {
     context.db.exec("BEGIN IMMEDIATE");
     try {
         claimed = context.db.run("INSERT OR IGNORE INTO run_control_workers (control_id, owner_token, status, resource_home, state_dir, created_at, updated_at) VALUES (?, ?, 'starting', ?, ?, ?, ?)", [input.controlId, token, home, directory, now, now]).changes === 1;
-        if (claimed)
+        if (claimed) {
             recordControlLauncher(context, input.controlId, token);
+            if (input.reconcileId)
+                context.db.run("UPDATE run_control_workers SET snapshot_json = ? WHERE control_id = ?", [JSON.stringify(renewRecoveryObservation({}, input.reconcileId)), input.controlId]);
+        }
         context.db.exec("COMMIT");
     }
     catch (error) {
@@ -93,6 +107,10 @@ function reclaimControlWorker(context, input, projectId, token, home) {
     const previous = context.db.get("SELECT * FROM run_control_workers WHERE control_id = ?", [input.controlId]);
     if (!previous || !["starting", "running", "failed"].includes(previous.status) || previous.resource_home !== home)
         return false;
+    const saved = JSON.parse(previous.snapshot_json ?? "{}");
+    const requested = input.reconcileId ? renewRecoveryObservation(saved, input.reconcileId) : saved;
+    if (recoveryObservationBudget(requested).state().remaining_ms === 0)
+        return false;
     const registry = fs.existsSync(path.join(home, "runtime.sqlite")) ? getResourceDatabase(home) : null;
     let record = previous.process_id ? registry?.get("SELECT * FROM managed_processes WHERE id = ?", [previous.process_id]) : null;
     const operationId = launchOperationId(input.controlId, previous.owner_token);
@@ -157,6 +175,10 @@ function reclaimControlWorker(context, input, projectId, token, home) {
             context.db.exec("ROLLBACK");
             return false;
         }
+        if (input.reconcileId) {
+            const snapshot = renewRecoveryObservation(JSON.parse(previous.snapshot_json ?? "{}"), input.reconcileId);
+            context.db.run("UPDATE run_control_workers SET snapshot_json = ?, error_json = NULL WHERE control_id = ? AND owner_token = ?", [JSON.stringify(snapshot), input.controlId, token]);
+        }
         const now = context.now();
         context.db.run("INSERT INTO run_control_operations (operation_id, control_id, target_json, status, receipt_json, created_at, updated_at) VALUES (?, ?, ?, 'completed', ?, ?, ?)", [`${launchOperationId(input.controlId, previous.owner_token)}:reconciled`, input.controlId, JSON.stringify({ kind: "control_worker_reconciliation", process_id: record?.id ?? null, resource_home: home }), JSON.stringify({ process_id: record?.id ?? null, pid: record?.pid ?? null, pid_started_at: record?.pid_started_at ?? null, prior_status: previous.status, snapshot: JSON.parse(previous.snapshot_json ?? "null"), error: JSON.parse(previous.error_json ?? "null") }), now, now]);
         recordControlLauncher(context, input.controlId, token);
@@ -216,6 +238,14 @@ export async function serveRunControl(context, input) {
         if (!worker.process_lease_token)
             throw new AppError("run_control_owner_mismatch", "Control owner has no resource lease", 1);
         confirmManagedProcess(resourceContext, { id: worker.process_id, leaseToken: worker.process_lease_token, pid: process.pid, processGroupId: process.pid, ownerPid: process.pid });
+        let priorObservation = null;
+        try {
+            priorObservation = worker.snapshot_json ? JSON.parse(worker.snapshot_json) : null;
+        }
+        catch { /* A malformed prior snapshot cannot grant a new budget. */
+            priorObservation = { recovery_observation: { remaining_ms: 0 } };
+        }
+        const observation = recoveryObservationBudget(priorObservation);
         for (;;) {
             if (leaseLost)
                 throw new AppError("run_control_lease_lost", "Control worker lost its physical ownership lease", 1);
@@ -226,6 +256,18 @@ export async function serveRunControl(context, input) {
                 context.db.run("UPDATE run_control_workers SET status = ?, updated_at = ? WHERE control_id = ? AND owner_token = ?", [status, context.now(), input.controlId, worker.owner_token]);
                 return { ok: true, control_id: input.controlId, status };
             }
+            if (observation.exhausted()) {
+                const latest = context.db.get("SELECT snapshot_json FROM run_control_workers WHERE control_id = ?", [input.controlId]);
+                let retained = {};
+                try {
+                    retained = JSON.parse(latest?.snapshot_json ?? "{}") ?? {};
+                }
+                catch { /* Retain a blocked status even when the old projection is malformed. */ }
+                const snapshot = { ...retained, status: "recovery_blocked", settled: false, pending_reasons: ["recovery_observation_budget_exhausted"],
+                    error: { code: "recovery_observation_budget_exhausted", message: "Control settlement has no confirmed result within the active observation budget" }, recovery_observation: observation.state() };
+                context.db.run("UPDATE run_control_workers SET status = 'failed', snapshot_json = ?, error_json = ?, updated_at = ? WHERE control_id = ? AND owner_token = ? AND status = 'running'", [JSON.stringify(snapshot), JSON.stringify(snapshot.error), context.now(), input.controlId, worker.owner_token]);
+                return { ok: true, control_id: input.controlId, ...snapshot };
+            }
             if (guard.status === "sealed") {
                 // Capture retries are local evidence work. Never dispatch another
                 // native interrupt/inspect merely because publication previously failed.
@@ -250,14 +292,15 @@ export async function serveRunControl(context, input) {
               AND EXISTS (SELECT 1 FROM run_recovery_guards g WHERE g.recovery_id = run_controls.recovery_id AND g.status = 'sealed' AND g.capture_path = ? AND g.generation = (SELECT MAX(generation) FROM run_recovery_guards WHERE project_id = g.project_id AND run_id = g.run_id))`, [context.now(), input.controlId, guard.recovery_id, worker.owner_token, capture]);
                     if (applied.changes !== 1)
                         throw new AppError("run_control_state_changed", "Control changed before its capture could be acknowledged", 1);
-                    const snapshot = { ...settlement, status: "settled", capture_path: capture };
+                    const snapshot = { ...settlement, status: "settled", capture_path: capture, recovery_observation: observation.state() };
                     context.db.run("UPDATE run_control_workers SET status = 'completed', snapshot_json = ?, error_json = NULL, updated_at = ? WHERE control_id = ? AND owner_token = ?", [JSON.stringify(snapshot), context.now(), input.controlId, worker.owner_token]);
                     return { ok: true, control_id: input.controlId, ...snapshot };
                 }
                 catch (error) {
-                    const snapshot = { ...settlement, status: "requested", capture: { status: "pending", error: failure(error) }, pending_reasons: ["recovery_capture_required"] };
+                    observation.exhausted();
+                    const snapshot = { ...settlement, status: "requested", capture: { status: "pending", error: failure(error) }, pending_reasons: ["recovery_capture_required"], recovery_observation: observation.state() };
                     context.db.run("UPDATE run_control_workers SET snapshot_json = ?, error_json = ?, updated_at = ? WHERE control_id = ? AND owner_token = ? AND status = 'running'", [JSON.stringify(snapshot), JSON.stringify(failure(error)), context.now(), input.controlId, worker.owner_token]);
-                    await delay(5_000);
+                    await delay(observation.nextDelay());
                     continue;
                 }
             }
@@ -265,12 +308,16 @@ export async function serveRunControl(context, input) {
             const interrupt = current.action === "stop" || request.escalate === "interrupt" && Date.now() >= Date.parse(current.created_at) + (request.grace_ms ?? 30_000);
             let snapshot;
             try {
-                const cancellation = interrupt ? await interruptControlledSessions(context, input) : null;
-                snapshot = { ...await observeControlledSessions(context, input), ...(cancellation ? { cancellation } : {}) };
+                snapshot = await withRecoveryObservation(observation, async () => {
+                    const cancellation = interrupt ? await interruptControlledSessions(context, input) : null;
+                    return { ...await observeControlledSessions(context, input), ...(cancellation ? { cancellation } : {}) };
+                });
             }
             catch (error) {
                 snapshot = { ok: true, control_id: input.controlId, status: "requested", settled: false, pending_reasons: ["control_observation_failed"], error: failure(error) };
             }
+            observation.exhausted();
+            snapshot = { ...snapshot, recovery_observation: observation.state() };
             context.db.run("UPDATE run_control_workers SET snapshot_json = ?, updated_at = ? WHERE control_id = ? AND owner_token = ? AND status = 'running'", [JSON.stringify(snapshot), context.now(), input.controlId, worker.owner_token]);
             if (snapshot.settled === true) {
                 try {
@@ -281,7 +328,7 @@ export async function serveRunControl(context, input) {
                     context.db.run("UPDATE run_control_workers SET snapshot_json = ?, error_json = ?, updated_at = ? WHERE control_id = ? AND owner_token = ? AND status = 'running'", [JSON.stringify({ ...snapshot, pending_reasons: ["recovery_seal_required"], error: failure(error) }), JSON.stringify(failure(error)), context.now(), input.controlId, worker.owner_token]);
                 }
             }
-            await delay(1_000);
+            await delay(observation.nextDelay());
         }
     }
     catch (error) {

package/dist/services/run-control.js

@@ -413,10 +413,29 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         }
         unresolved.push({ check_id: check.id, status: "pending", reason });
     }
+    const uncreatedDirectories = new Map();
     const sessionNodes = Promise.all([...targets.values()].map(async ({ session, executable, harness }) => {
         const env = { ...context.env, DD_FLOW_HOME: context.ddFlowHome };
         delete env.DD_FLOW_CONTROLLER_TOKEN;
         delete env.DD_FLOW_CONTROL_TOKEN;
+        // An explicit pre-registration rejection proves there is no Session to
+        // cancel. A missing id or an arbitrary startup failure does not.
+        if (!session.id && !session.create_operation_id && !daemonInventories.has(session.state_dir) && !unsafeDaemons.has(canonicalPath(session.state_dir, false)) && !fs.existsSync(path.join(session.state_dir, "daemon.json"))) {
+            const operations = context.db.all("SELECT o.operation_id, o.input_json FROM run_controller_operations o JOIN run_controllers c ON c.controller_id = o.controller_id WHERE c.project_id = ? AND c.run_id = ? AND json_extract(o.input_json, '$.state_dir') = ?", [project.id, input.runId, session.state_dir]);
+            if (operations.length === 1)
+                try {
+                    const operation = operations[0];
+                    const saved = JSON.parse(operation.input_json);
+                    const journal = retainedDaemonOperations(session.state_dir);
+                    const receipt = journal.length === 1 ? journal[0] : null;
+                    const error = receipt?.error;
+                    if (saved.executable === executable && saved.owner === session.owner.owner_id && saved.args?.[0] === "daemon" && saved.args?.[1] === "start" && receipt?.operation_id === operation.operation_id && receipt.operation === "daemon.start" && receipt.predecessor_daemon_id === null && receipt.state === "failed" && error?.details?.startup_resources === "not_created" && !registeredProcesses.some(({ record }) => JSON.parse(record.metadata_json).state_dir === session.state_dir)) {
+                        uncreatedDirectories.set(session.state_dir, JSON.stringify(journal));
+                        return { state_dir: session.state_dir, status: "completed", receipt: { source: "startup_resources_not_created", operation_id: operation.operation_id, error } };
+                    }
+                }
+                catch { /* Incomplete evidence retains the normal unknown outcome. */ }
+        }
         if (!session.id && session.create_operation_id) {
             try {
                 assertCurrent();
@@ -457,20 +476,32 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         assertCurrent();
         const inserted = context.db.run("INSERT OR IGNORE INTO run_control_operations (operation_id, control_id, target_json, status, created_at, updated_at) VALUES (?, ?, ?, 'dispatching', ?, ?)", [operationId, observationId, JSON.stringify({ session_id: session.id, state_dir: session.state_dir, executable }), now, now]);
         const prior = context.db.get("SELECT status, receipt_json FROM run_control_operations WHERE operation_id = ?", [operationId]);
+        let cancellation;
+        let cancellationError;
         try {
             if (!inserted.changes && prior.status === "completed") {
                 const saved = JSON.parse(prior.receipt_json);
-                assertNativeCancellationReceipt(saved, session.id, harness === "zcode-acp");
-                return { operation_id: operationId, session_id: session.id, status: prior.status, receipt: saved, reused: true };
+                assertNativeCancellationReceipt(saved, session.id);
+                cancellation = saved;
+            }
+            else {
+                const { status, receipt } = await cancelControlledNativeSession({ executable, sessionId: session.id, stateDir: session.state_dir, env, operationId, observe: !inserted.changes, assertCurrent });
+                context.db.run("UPDATE run_control_operations SET status = ?, receipt_json = ?, error_json = NULL, updated_at = ? WHERE operation_id = ?", [status, JSON.stringify(receipt), context.now(), operationId]);
+                cancellation = receipt;
             }
-            const { status, receipt } = await cancelControlledNativeSession({ executable, sessionId: session.id, stateDir: session.state_dir, env, operationId, observe: !inserted.changes, assertCurrent, requireSettled: harness === "zcode-acp" });
-            context.db.run("UPDATE run_control_operations SET status = ?, receipt_json = ?, error_json = NULL, updated_at = ? WHERE operation_id = ?", [status, JSON.stringify(receipt), context.now(), operationId]);
-            return { operation_id: operationId, session_id: session.id, status, receipt };
         }
         catch (error) {
-            const failure = { code: error instanceof AppError ? error.code : "control_observation_failed", message: String(error) };
-            context.db.run("UPDATE run_control_operations SET status = 'outcome_unknown', error_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify(failure), context.now(), operationId]);
-            return { operation_id: operationId, session_id: session.id, status: "outcome_unknown", error: failure };
+            cancellationError = { code: error instanceof AppError ? error.code : "control_observation_failed", message: String(error) };
+            context.db.run("UPDATE run_control_operations SET status = 'outcome_unknown', error_json = ?, updated_at = ? WHERE operation_id = ? AND status != 'completed'", [JSON.stringify(cancellationError), context.now(), operationId]);
+            if (cancellationError.code === "controller_operation_mismatch")
+                return { operation_id: operationId, session_id: session.id, status: "outcome_unknown", error: cancellationError };
+        }
+        try {
+            const observed = await inspectControlledNativeSession({ executable, sessionId: session.id, stateDir: session.state_dir, harness, env, operationId: `${observationId}:inspect:${crypto.randomUUID()}`, assertCurrent });
+            return { operation_id: operationId, session_id: session.id, status: observed.settled === true ? "completed" : "pending", receipt: observed, cancellation, reused: !inserted.changes, ...(cancellationError ? { cancellation_error: cancellationError } : {}) };
+        }
+        catch (error) {
+            return { operation_id: operationId, session_id: session.id, status: "pending", cancellation, cancellation_error: cancellationError, error: { code: error instanceof AppError ? error.code : "control_observation_failed", message: String(error) } };
         }
     }));
     const processResults = Promise.all(processTargets.map(async ({ home, record }) => {
@@ -533,7 +564,17 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         const executable = directoryAdapters.get(directory) ?? (leader && JSON.parse(leader.metadata_json).adapter_executable);
         if (!daemonId || !leader || !executable)
             return { state_dir: directory, status: "pending", reason: "daemon_close_owner_unproven" };
-        const operationId = `${observationId}:close-daemon:${crypto.createHash("sha256").update(JSON.stringify([directory, daemonId])).digest("hex")}`;
+        let operationId = `${observationId}:close-daemon:${crypto.createHash("sha256").update(JSON.stringify([directory, daemonId])).digest("hex")}`;
+        const nativeOperations = retainedDaemonOperations(directory);
+        const targetList = [...targets.values()];
+        const sessionsSettled = ids.every(id => nodes.some((node, index) => targetList[index]?.session.state_dir === directory && targetList[index]?.session.id === id && node.status === "completed"));
+        // A confirmed failed tree guard admits a new shutdown attempt only after
+        // fresh tree settlement. Unknown outcomes retain their original ID.
+        if (sessionsSettled) {
+            while (nativeOperations.some(operation => operation.operation_id === operationId && operation.daemon_id === daemonId && operation.operation === "daemon.stop"
+                && operation.state === "failed" && operation.error?.code === "tree_not_settled"))
+                operationId += ":finalize";
+        }
         assertCurrent();
         const inserted = context.db.run("INSERT OR IGNORE INTO run_control_operations (operation_id, control_id, target_json, status, created_at, updated_at) VALUES (?, ?, ?, 'dispatching', ?, ?)", [operationId, observationId, JSON.stringify({ state_dir: directory, daemon_id: daemonId, executable, cancel_tree: true }), context.now(), context.now()]);
         const prior = context.db.get("SELECT status, receipt_json FROM run_control_operations WHERE operation_id = ?", [operationId]);
@@ -600,7 +641,7 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         };
         bindings = readBindings();
         for (const target of targets.values())
-            if (!daemonInventories.has(target.session.state_dir))
+            if (!daemonInventories.has(target.session.state_dir) && !uncreatedDirectories.has(target.session.state_dir))
                 unresolved.push({ state_dir: target.session.state_dir, status: "pending", reason: "runtime_inventory_unverified" });
         for (const node of nodes)
             if ("harness" in node && "session_id" in node && typeof node.session_id === "string" && bindings.some(binding => foreign(binding) && underRoot(binding, node.session_id, node.harness ?? null)))
@@ -625,6 +666,9 @@ async function reconcileOwnedSessions(context, input, interrupt, boundary) {
         const processVersion = (items) => JSON.stringify(items.map(({ home, record }) => [home, record.id, record.kind, record.owner_id, record.project_id, record.run_id, record.work_id, record.check_id, record.operation_id, record.pid, record.pid_started_at, record.lease_token, record.state, record.metadata_json]).sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right))));
         verifyInventory = () => {
             assertCurrent();
+            for (const [directory, journal] of uncreatedDirectories)
+                if (fs.existsSync(path.join(directory, "daemon.json")) || JSON.stringify(retainedDaemonOperations(directory)) !== journal)
+                    throw new AppError("owned_inventory_changed", "Rejected startup acquired new runtime evidence", 1);
             const currentProcesses = [...resourceHomes].flatMap(home => managedProcessStatus({ ...context, env: { ...context.env, DD_FLOW_RESOURCE_HOME: home } }).filter(record => record.project_id === project.id && record.run_id === input.runId && [null, context.ddFlowHome].includes(managedProcessRuntimeHome(record, context))).map(record => ({ home, record })));
             if (initialDatabaseVersion !== databaseVersion() || processVersion(registeredProcesses) !== processVersion(currentProcesses) || [...nativeVersions].some(([directory, version]) => version !== nativeInventoryVersion(directory)) || [...importVersions].some(([file, version]) => crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") !== version))
                 throw new AppError("owned_inventory_changed", "Owned writers changed after their settlement observation", 1);

package/dist/services/run-controller-capture.js

@@ -7,6 +7,7 @@ import { observeControllerBoundary } from "./run-control.js";
 import { assertRunMutationAllowed, recoveryGuard } from "./run-recovery.js";
 import { appendEvent, digest, errorRecord, requireController, requireRun } from "./run-controller-state.js";
 import { getFlowRunStatus } from "./runs.js";
+import { recoveryObservationBudget, withRecoveryObservation } from "./recovery-observation-budget.js";
 /** Capture is performed by the productive owner, before it releases the next
  * Stage. An observer never races the controller to copy a completed boundary. */
 export async function captureControllerBoundary(context, row, manifest, stage, nextStage, assertPhysicalOwner) {
@@ -63,6 +64,14 @@ export async function captureControllerBoundary(context, row, manifest, stage, n
         if (nextStage ? continuation.kind !== "start_stage" || continuation.stage !== nextStage : continuation.kind !== "terminal")
             throw new AppError("controller_boundary_changed", "Stage successor changed after its capture fence", 1);
     };
+    let priorObservation = null;
+    try {
+        priorObservation = prior?.receipt_json ? JSON.parse(prior.receipt_json) : null;
+    }
+    catch {
+        priorObservation = { recovery_observation: { remaining_ms: 0 } };
+    }
+    const observationBudget = recoveryObservationBudget(priorObservation);
     try {
         let receipt;
         if (fs.existsSync(output)) {
@@ -72,9 +81,13 @@ export async function captureControllerBoundary(context, row, manifest, stage, n
         else {
             let lastPending = "";
             for (;;) {
+                if (observationBudget.exhausted()) {
+                    context.db.run("UPDATE run_controller_operations SET receipt_json = json_set(COALESCE(receipt_json, '{}'), '$.recovery_observation', json(?)), updated_at = ? WHERE operation_id = ?", [JSON.stringify(observationBudget.state()), context.now(), operationId]);
+                    throw new AppError("recovery_observation_budget_exhausted", "Boundary capture has no stable settlement within the active observation budget", 1, { recovery_observation: observationBudget.state() });
+                }
                 assertCurrent();
                 let verify = () => { throw new AppError("controller_boundary_unsettled", "Boundary has no stable writer observation", 1); };
-                const observation = await observeControllerBoundary(context, { ...scope, controllerId: row.controller_id, operationId, assertCurrent, retainVerification: value => { verify = value; } });
+                const observation = await withRecoveryObservation(observationBudget, () => observeControllerBoundary(context, { ...scope, controllerId: row.controller_id, operationId, assertCurrent, retainVerification: value => { verify = value; } }));
                 if (observation.settled === true) {
                     try {
                         createEvalRunSnapshot(context, { ...scope, output, ...(nextStage ? { stageEntry: nextStage } : { candidate: true }), boundary: { controllerId: row.controller_id, operationId, boundaryKey, observation, verify } });
@@ -88,13 +101,15 @@ export async function captureControllerBoundary(context, row, manifest, stage, n
                         observation.pending_reasons = [error.code];
                     }
                 }
+                observationBudget.exhausted();
+                const published = { ...observation, recovery_observation: observationBudget.state() };
                 const pending = digest(observation.pending_reasons);
+                context.db.run("UPDATE run_controller_operations SET receipt_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify(published), context.now(), operationId]);
                 if (pending !== lastPending) {
-                    context.db.run("UPDATE run_controller_operations SET receipt_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify(observation), context.now(), operationId]);
                     appendEvent(context, row.controller_id, "boundary_capture_pending", { operation_id: operationId, pending_reasons: observation.pending_reasons });
                     lastPending = pending;
                 }
-                await delay(1000);
+                await delay(observationBudget.nextDelay());
             }
         }
         context.db.exec("BEGIN IMMEDIATE");
@@ -111,6 +126,8 @@ export async function captureControllerBoundary(context, row, manifest, stage, n
         }
     }
     catch (error) {
+        observationBudget.exhausted();
+        context.db.run("UPDATE run_controller_operations SET receipt_json = json_set(COALESCE(receipt_json, '{}'), '$.recovery_observation', json(?)) WHERE operation_id = ?", [JSON.stringify(observationBudget.state()), operationId]);
         context.db.run("UPDATE run_controller_operations SET status = 'failed', error_json = ?, updated_at = ? WHERE operation_id = ?", [JSON.stringify(errorRecord(error)), context.now(), operationId]);
         throw error;
     }

package/dist/services/run-controller-state.js

@@ -16,7 +16,7 @@ export function requireController(context, id) {
 export function controllerReceipt(row) {
     const state = JSON.parse(row.state_json);
     const manifest = JSON.parse(row.manifest_json);
-    return { ok: true, schema_id: "dd-flow/run-controller-receipt@1", controller: { controller_id: row.controller_id, request_id: row.request_id, project_id: row.project_id, run_id: row.run_id, generation: row.generation, runtime_budget: manifest.budget ?? null, status: row.status, process_id: row.process_id, owner_pid: row.owner_pid, state_dir: row.state_dir, stage: state.stage, sessions: state.sessions.map(session => ({ session_id: session.id, harness: runtimeHarness(session.profile), profile_id: session.profile.id, state_dir: session.state_dir, stopped: session.stopped === true })), error: row.last_error_json ? JSON.parse(row.last_error_json) : null } };
+    return { ok: true, schema_id: "dd-flow/run-controller-receipt@1", controller: { controller_id: row.controller_id, request_id: row.request_id, project_id: row.project_id, run_id: row.run_id, generation: row.generation, runtime_budget: manifest.budget ?? null, status: row.status, process_id: row.process_id, owner_pid: row.owner_pid, state_dir: row.state_dir, stage: state.stage, sessions: state.sessions.map(session => ({ session_id: session.id, harness: runtimeHarness(session.profile), profile_id: session.profile.id, state_dir: session.state_dir, journal: session.journal, stopped: session.stopped === true })), error: row.last_error_json ? JSON.parse(row.last_error_json) : null } };
 }
 export function appendEvent(context, id, type, data) { context.db.run("INSERT INTO run_controller_events (controller_id, event_type, data_json, created_at) VALUES (?, ?, ?, ?)", [id, type, JSON.stringify(data), context.now()]); }
 export function saveState(context, row, state) { context.db.run("UPDATE run_controllers SET state_json = ?, updated_at = ? WHERE controller_id = ? AND owner_token = ?", [JSON.stringify(state), context.now(), row.controller_id, row.owner_token]); }

package/dist/services/runtime-scope-control.js

@@ -235,7 +235,7 @@ export async function controlRuntimeScopeNativeOwners(context, scopeId, generati
             const sessions = await Promise.all(ids.map(async (id) => {
                 try {
                     let cancellation;
-                    let cancellationAcknowledged = action !== "stop";
+                    let cancellationError;
                     if (action === "stop") {
                         const operationId = `scope-cancel:${crypto.createHash("sha256").update(JSON.stringify([scopeId, generation, record.id, state.daemon_id, id])).digest("hex")}`;
                         const now = context.now();
@@ -255,22 +255,34 @@ export async function controlRuntimeScopeNativeOwners(context, scopeId, generati
                             if (saved.status === "completed") {
                                 assertNativeCancellationReceipt(saved.receipt, id);
                                 cancellation = saved.receipt;
-                                cancellationAcknowledged = true;
+                            }
+                            else if (saved.status === "failed") {
+                                cancellation = saved.receipt;
+                                try {
+                                    cancellationError = JSON.parse(saved.error ?? "");
+                                }
+                                catch {
+                                    cancellationError = { code: "cancellation_outcome_unknown", message: saved.error ?? "Retained cancellation has no conclusive outcome" };
+                                }
                             }
                             else {
                                 const result = await cancelControlledNativeSession({ executable: metadata.adapter_executable, sessionId: id, stateDir: metadata.state_dir, env, operationId, observe: !inserted, assertCurrent: assertOwner });
                                 registry.run("UPDATE managed_resources SET metadata_json = json_set(metadata_json, '$.status', ?, '$.receipt', json(?)), updated_at = ? WHERE resource_kind = 'scope-control-operation' AND resource_key = ?", [result.status, JSON.stringify(result.receipt), context.now(), operationId]);
                                 cancellation = result.receipt;
-                                cancellationAcknowledged = result.status === "completed";
                             }
                         }
                         catch (error) {
-                            registry.run("UPDATE managed_resources SET metadata_json = json_set(metadata_json, '$.status', 'outcome_unknown', '$.error', ?), updated_at = ? WHERE resource_kind = 'scope-control-operation' AND resource_key = ?", [String(error), context.now(), operationId]);
-                            throw error;
+                            cancellationError = { code: error instanceof AppError ? error.code : "cancellation_outcome_unknown", message: String(error) };
+                            registry.run("UPDATE managed_resources SET metadata_json = json_set(metadata_json, '$.status', 'outcome_unknown', '$.error', ?), updated_at = ? WHERE resource_kind = 'scope-control-operation' AND resource_key = ?", [JSON.stringify(cancellationError), context.now(), operationId]);
                         }
+                        if (cancellationError?.code === "controller_operation_mismatch")
+                            throw new AppError("controller_operation_mismatch", "Cancellation evidence belongs to another operation or Session", 1);
                     }
                     const receipt = await inspectControlledNativeSession({ executable: metadata.adapter_executable, sessionId: id, stateDir: metadata.state_dir, env, operationId: `scope:${scopeId}:${generation}:inspect:${crypto.randomUUID()}`, assertCurrent: assertOwner });
-                    return { session_id: id, settled: receipt.settled === true && cancellationAcknowledged, receipt, ...(cancellation ? { cancellation } : {}) };
+                    // Physical settlement is determined by this fresh inspection. A past
+                    // cancel ACK (or an inconclusive cancel outcome) is retained as
+                    // evidence, never substituted for the state of the native tree.
+                    return { session_id: id, settled: receipt.settled === true, receipt, ...(cancellation ? { cancellation } : {}), ...(cancellationError ? { cancellation_error: cancellationError } : {}) };
                 }
                 catch (error) {
                     return { session_id: id, settled: false, reason: error instanceof AppError ? error.code : "runtime_scope_session_control_failed", message: String(error) };
@@ -294,7 +306,7 @@ export async function controlRuntimeScopeNativeOwners(context, scopeId, generati
     }));
 }
 /** Scope routing only: existing RUN workers own physical drain and capture. */
-export async function controlRuntimeScopeRuns(context, scopeId, requestId, mode) {
+export async function controlRuntimeScopeRuns(context, scopeId, requestId, mode, reconcileId) {
     const control = requestRuntimeScopeControl(context, scopeId, requestId, mode);
     const registry = getResourceDatabase(resourceHome(context));
     const inventory = runtimeBudgetStatus(context, scopeId).processes;
@@ -341,7 +353,7 @@ export async function controlRuntimeScopeRuns(context, scopeId, requestId, mode)
                 throw error;
             }
             seen.add(key);
-            const receipt = await requestRunControl(target, { ...input, waitMs: 0 });
+            const receipt = await requestRunControl(target, { ...input, waitMs: 0, ...(reconcileId ? { reconcileId: crypto.createHash("sha256").update(JSON.stringify([scopeId, control.generation, reconcileId])).digest("hex") } : {}) });
             runs.push({ runtime_home: metadata.dd_flow_home, project_id: record.project_id, run_id: record.run_id, request_id: input.requestId, receipt });
         }
         catch (error) {

package/dist/services/runtime-scope-worker.js

@@ -10,6 +10,7 @@ import { confirmManagedProcess, finishManagedProcess, heartbeatManagedProcess, p
 import { publicRuntimeScopeWorker, requestRuntimeScopeControl, runtimeBudgetStatus } from "./runtime-budget.js";
 import { controlRuntimeScopeRuns } from "./runtime-scope-control.js";
 import { prepareRuntimeScopeResume, recordRuntimeScopeResume } from "./runtime-scope-resume.js";
+import { recoveryObservationBudget, renewRecoveryObservation, withRecoveryObservation } from "./recovery-observation-budget.js";
 export async function launchRuntimeScopeResume(context, input) {
     const resume = recordRuntimeScopeResume(context, input);
     if (!resume.current)
@@ -19,7 +20,7 @@ export async function launchRuntimeScopeResume(context, input) {
     const control = runtimeBudgetStatus(context, input.scopeId).control;
     if (control?.generation !== input.generation)
         throw new AppError("runtime_scope_control_superseded", "Scope resume source changed before owner launch", 1);
-    const owner = await launchRuntimeScopeControl(context, input.scopeId, control.request_id, control.requested_mode);
+    const owner = await launchRuntimeScopeControl(context, input.scopeId, control.request_id, control.requested_mode, undefined, undefined, input.requestId);
     return { ...owner, resume, dispatch_blocked: true, settled: false };
 }
 const keyFor = (scope, generation) => crypto.createHash("sha256").update(JSON.stringify([scope, generation])).digest("hex");
@@ -29,7 +30,14 @@ function birth() {
         throw new AppError("runtime_scope_owner_unknown", "Scope owner birth identity is unavailable", 1);
     return { pid: process.pid, pid_started_at: started };
 }
-export async function launchRuntimeScopeControl(context, scopeId, requestId, mode, manifest) {
+export async function reconcileRuntimeScopeControl(context, scopeId, generation, requestId) {
+    const control = runtimeBudgetStatus(context, scopeId).control;
+    if (!control || control.generation !== generation)
+        throw new AppError("runtime_scope_control_superseded", "Reconciliation requires the current controlled scope generation", 1);
+    renewRecoveryObservation({}, requestId);
+    return launchRuntimeScopeControl(context, scopeId, control.request_id, control.requested_mode, undefined, requestId);
+}
+export async function launchRuntimeScopeControl(context, scopeId, requestId, mode, manifest, reconcileId, resumeId) {
     const control = requestRuntimeScopeControl(context, scopeId, requestId, mode, manifest), db = getResourceDatabase(resourceHome(context)), key = keyFor(scopeId, control.generation);
     let worker;
     db.exec("BEGIN IMMEDIATE");
@@ -50,7 +58,18 @@ export async function launchRuntimeScopeControl(context, scopeId, requestId, mod
             db.exec("COMMIT");
             return { scope_id: scopeId, control, current: true, settled: false, worker: publicRuntimeScopeWorker(existing) };
         }
-        worker = { scope_id: scopeId, generation: control.generation, request_id: requestId, mode, token: crypto.randomUUID(), status: "starting", launcher: birth() };
+        if (existing?.status === "completed" && !reconcileId && !resumeId) {
+            db.exec("COMMIT");
+            return { scope_id: scopeId, control, current: true, settled: false, worker: publicRuntimeScopeWorker(existing) };
+        }
+        const renewal = resumeId ? `resume:${resumeId}` : reconcileId;
+        const snapshot = renewal ? renewRecoveryObservation(existing?.snapshot ?? {}, renewal) : existing?.snapshot;
+        if (existing && recoveryObservationBudget(snapshot).state().remaining_ms === 0) {
+            db.exec("COMMIT");
+            return { scope_id: scopeId, control, current: true, settled: false, worker: publicRuntimeScopeWorker(existing) };
+        }
+        const cleanupRequest = resumeId ? undefined : reconcileId ?? existing?.reconcile_id;
+        worker = { scope_id: scopeId, generation: control.generation, request_id: requestId, mode, token: crypto.randomUUID(), status: "starting", launcher: birth(), ...(snapshot ? { snapshot } : {}), ...(cleanupRequest ? { reconcile_id: cleanupRequest } : {}) };
         const now = context.now();
         db.run("INSERT INTO managed_resources (resource_kind,resource_key,owner_id,lease_token,lease_expires_at,process_id,metadata_json,created_at,updated_at) VALUES ('scope-control-worker',?,?,?,?,NULL,?,?,?) ON CONFLICT(resource_kind,resource_key) DO UPDATE SET lease_token = excluded.lease_token, metadata_json = excluded.metadata_json, updated_at = excluded.updated_at", [key, scopeId, worker.token, now, JSON.stringify(worker), now, now]);
         db.exec("COMMIT");
@@ -107,6 +126,10 @@ export async function serveRuntimeScopeControl(context, scopeId, generation) {
         throw error;
     }
     let heartbeat;
+    // A fence must never be held indefinitely by an observer that cannot obtain
+    // fresh provider evidence. A later operator request continues the retained
+    // budget; this owner records why it stopped without claiming settlement.
+    const observation = recoveryObservationBudget(worker.snapshot);
     try {
         const record = registerManagedProcess(context, { kind: "scope-control", ownerId: key, operationId: `scope-control:${key}:${token}`, ownerPid: process.pid, metadata: { role: "control", scope_id: scopeId, generation } });
         worker.process_id = record.id;
@@ -125,6 +148,19 @@ export async function serveRuntimeScopeControl(context, scopeId, generation) {
         for (;;) {
             if (leaseLost)
                 throw new AppError("runtime_scope_owner_changed", "Scope worker lost its managed lease", 1);
+            if (observation.exhausted()) {
+                worker.status = "failed";
+                worker.error = "recovery_observation_budget_exhausted";
+                worker.snapshot = {
+                    ...(worker.snapshot ?? {}),
+                    status: "recovery_blocked",
+                    settled: false,
+                    pending_reasons: ["recovery_observation_budget_exhausted"],
+                    error: { code: "recovery_observation_budget_exhausted", message: "Scope recovery observation exceeded its 120 second budget" },
+                    recovery_observation: observation.state(),
+                };
+                return { scope_id: scopeId, generation, status: "recovery_blocked", settled: false, error: worker.error };
+            }
             const status = runtimeBudgetStatus(context, scopeId);
             const release = status.release;
             if (release?.current === true && release.generation === generation) {
@@ -137,9 +173,16 @@ export async function serveRuntimeScopeControl(context, scopeId, generation) {
                 break;
             }
             const resume = status.resume;
-            worker.snapshot = await prepareRuntimeScopeResume(context, scopeId, generation, resume?.generation === generation ? resume.request_id : undefined) ?? await controlRuntimeScopeRuns(context, scopeId, worker.request_id, worker.mode);
+            const outcome = await withRecoveryObservation(observation, async () => (worker.reconcile_id ? null : await prepareRuntimeScopeResume(context, scopeId, generation, resume?.generation === generation ? resume.request_id : undefined))
+                ?? await controlRuntimeScopeRuns(context, scopeId, worker.request_id, worker.mode, worker.reconcile_id));
+            observation.exhausted();
+            worker.snapshot = { ...outcome, recovery_observation: observation.state() };
             db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(worker), context.now(), key, token]);
-            await delay(1_000);
+            if (worker.snapshot.drain?.physical_settled === true) {
+                worker.status = "completed";
+                break;
+            }
+            await delay(observation.nextDelay());
         }
         return { scope_id: scopeId, generation, status: worker.status };
     }
@@ -158,6 +201,8 @@ export async function serveRuntimeScopeControl(context, scopeId, generation) {
     finally {
         if (heartbeat)
             clearInterval(heartbeat);
+        observation.exhausted();
+        worker.snapshot = { ...(worker.snapshot ?? {}), recovery_observation: observation.state() };
         db.run("UPDATE managed_resources SET metadata_json = ?, updated_at = ? WHERE resource_kind = 'scope-control-worker' AND resource_key = ? AND lease_token = ?", [JSON.stringify(worker), context.now(), key, token]);
         if (worker.process_id && worker.process_lease_token)
             finishManagedProcess(context, { id: worker.process_id, leaseToken: worker.process_lease_token, state: worker.status === "failed" ? "failed" : "stopped", reason: "scope_owner_exited" });

package/package.json

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