@deksden-com/dd-flow-cli 0.9.0-beta.124 → 0.9.0-beta.127

package/dist/harness-runtime/lib/lease-renewal.mjs

@@ -0,0 +1,23 @@
+/** Shared policy only; transports and owner-specific fences stay at callsites. */
+export const RENEWAL_POLICY = Object.freeze({ budgetMs: 30_000, attemptMs: 5_000 });
+export function createRenewalState() { return { uncertainSince: null, attempt: 0, exhausted: false }; }
+export function renewalRemaining(state, now = performance.now()) {
+  const remaining = state.exhausted ? 0 : state.uncertainSince === null ? RENEWAL_POLICY.budgetMs : Math.max(0, RENEWAL_POLICY.budgetMs - (now - state.uncertainSince));
+  if (remaining === 0) state.exhausted = true;
+  return remaining;
+}
+export function renewalFailure(state, now = performance.now()) { state.uncertainSince ??= now; state.attempt++; return renewalRemaining(state, now); }
+export function renewalDelay(state) { return Math.min(2_000, 250 * 2 ** Math.min(3, Math.max(0, state.attempt - 1))); }
+export function renewalConfirmed(state, now = performance.now()) { if (!renewalRemaining(state, now)) return false; state.uncertainSince = null; state.attempt = 0; return true; }
+export function maintenanceRetryable(error) {
+  let retryable = false;
+  // Inspect only bounded typed causes from our maintenance transport, never text.
+  for (let depth = 0; error && depth < 8; depth++, error = error.cause ?? error.details?.cause) {
+    if (error.details?.cleanup_unconfirmed === true) return false;
+    if (["process_lease_lost", "controller_lease_lost", "process_maintenance_receipt_invalid", "runtime_owner_mismatch"].includes(error.code)) return false;
+    if (error.code === "process_ownership_unknown" && error.details?.reason === "physical_identity_unavailable" && ["process_confirmation", "observer_registration"].includes(error.details.phase) && error.details.effect === "no_effect" && error.details.native_dispatch_started === false) retryable = true;
+    if (["process_heartbeat_timeout", "process_maintenance_timeout", "hook_deadline_exceeded", "native_hook_timeout", "SQLITE_BUSY", "SQLITE_LOCKED"].includes(error.code)) retryable = true;
+    if (error.code === "ERR_SQLITE_ERROR" && [5, 6].includes((error.details?.sqlite_extended_code ?? error.sqlite_extended_code ?? error.errcode) & 255)) retryable = true;
+  }
+  return retryable;
+}

package/dist/harness-runtime/lib/lifecycle-command.d.mts

@@ -5,13 +5,13 @@ export interface LifecycleInvocation {
   operation: LifecycleOperation; executable: string; launcher?: string; argv: string[]; env: Record<string, string>; args: ParsedCommandArgs; command: string;
   rewriteSafe: boolean; wrapped: boolean; heredoc: boolean; sourceRange?: { start: number; end: number }; contexts?: string[]; expectedCwd?: string;
 }
-export type LifecycleAnalysis =
+export type LifecycleAnalysis = ({ participation: "none" | "lifecycle" | "auxiliary" | "unproven"; auxiliary?: { operation: string; args: ParsedCommandArgs; expectedCwd?: string } } & (
   | { kind: "none"; unresolved?: true; reason?: string }
   | { kind: "standalone"; invocation: LifecycleInvocation; supported?: boolean; invocations?: LifecycleInvocation[] }
-  | { kind: "compound"; invocation: LifecycleInvocation; reason: string; supported?: boolean; invocations?: LifecycleInvocation[] };
+  | { kind: "compound"; invocation: LifecycleInvocation; reason: string; supported?: boolean; invocations?: LifecycleInvocation[] }));
 export function lifecycleCommandFromPayload(payload: { command?: unknown; tool_input?: unknown }): string | undefined;
 export function parseLifecycleCommand(command: string): LifecycleAnalysis;
-export function continuationCommand(command: string): { operation: string; args: ParsedCommandArgs } | null;
+export function continuationCommand(command: string): { operation: string; args: ParsedCommandArgs; expectedCwd?: string } | null;
 export function unwrapShellCommand(command: string): string;
 export function parseCommandArgs(argv: string[]): ParsedCommandArgs;
 export function commandOption(invocation: LifecycleInvocation, name: string): string | undefined;

package/dist/harness-runtime/lib/lifecycle-command.mjs

@@ -1,13 +1,21 @@
 import path from "node:path";
-import Parser from "tree-sitter";
-import Bash from "tree-sitter-bash";
+import { createRequire } from "node:module";
 import { parse, quote } from "shell-quote";
 import { lifecycleOperationForArgv } from "./lifecycle-contract.mjs";
 
 // One grammar owns structure. shell-quote decodes identified command words;
 // neither parser grants authority or executes expansions.
-const parser = new Parser();
-parser.setLanguage(Bash);
+const require = createRequire(import.meta.url);
+let parser;
+function shellParser() {
+  if (!parser) {
+    const Parser = require("tree-sitter"), Bash = require("tree-sitter-bash");
+    const initialized = new Parser();
+    initialized.setLanguage(Bash);
+    parser = initialized;
+  }
+  return parser;
+}
 const shells = new Set(["bash", "sh", "zsh"]);
 const repeatedContexts = new Set(["for_statement", "while_statement", "function_definition", "c_style_for_statement"]);
 const dynamicTypes = ["command_substitution", "process_substitution", "arithmetic_expansion", "brace_expression", "extglob_pattern"];
@@ -97,15 +105,48 @@ function invocationFromWords(values, node, wrapped, env) {
   return { operation, executable, ...(launcher ? { launcher } : {}), argv, env, args: parseCommandArgs(argv.slice(operation === "recovery_accept" ? 3 : 2)),
     command: quote(values), rewriteSafe: !wrapped, wrapped, heredoc, contexts, ...(!wrapped ? { sourceRange: { start: node.startIndex, end: node.endIndex } } : {}) };
 }
-export function parseLifecycleCommand(command) { return analyze(command, false, 0); }
+export function parseLifecycleCommand(command) {
+  const result = analyze(command, false, 0);
+  return { ...result, participation: result.kind !== "none" ? "lifecycle" : result.participation ?? (result.auxiliary ? "auxiliary" : result.unresolved ? "unproven" : "none") };
+}
+function auxiliaryFromWords(values) {
+  const env = {}, index = launcherIndex(values, env);
+  let start = index;
+  if (path.basename(values[start] ?? "") === "node" && (path.basename(values[start + 1] ?? "") === "cli.js" || values[start + 1] === "$DD_FLOW_BIN")) start++;
+  if (!(path.basename(values[start] ?? "") === "dd-flow" || values[start] === "$DD_FLOW_BIN" || start !== index && path.basename(values[start] ?? "") === "cli.js")) return null;
+  const args = parseCommandArgs(values.slice(start + 1)), route = args.positional.slice(0, 3).join(" ");
+  const operation = route === "work repair add" ? "work_repair_add" : args.positional[0] === "stage" && args.positional[1] === "block" ? "stage_block" : null;
+  return operation ? { operation, args } : null;
+}
+// Recognition is not admission: recovered commands never provide argv authority.
+function recognizedParticipation(root, depth) {
+  for (const node of root.descendantsOfType("command")) {
+    const name = node.childForFieldName("name");
+    if (!name || name.type === "ERROR" || dynamicWord(name)) continue;
+    const values = words(node.text);
+    if (!values) continue;
+    if (invocationFromWords(values, node, true, {})) return "lifecycle";
+    if (auxiliaryFromWords(values)) return "auxiliary";
+    const index = launcherIndex(values, {});
+    if (values[index] === "eval" && depth < 8) {
+      const payload = node.namedChildren[index + 1];
+      if (payload && !dynamicWord(payload)) {
+        const nested = analyze(values.slice(index + 1).join(" "), true, depth + 1);
+        if (nested.kind !== "none" || nested.participation === "lifecycle") return "lifecycle";
+        if (nested.auxiliary || nested.participation === "auxiliary") return "auxiliary";
+      }
+    }
+  }
+  return "unproven";
+}
 function analyze(command, wrapped, depth) {
   if (depth > 8 || command.length > 1_000_000) return { kind: "none", unresolved: true, reason: "shell_input_limit" };
-  const tree = parser.parse(command);
+  const tree = shellParser().parse(command);
   if (!tree) return { kind: "none", unresolved: true, reason: "shell_parse_error" };
   try {
     const root = tree.rootNode;
-    if (root.hasError) return { kind: "none", unresolved: true, reason: "shell_parse_error" };
-    const nodes = root.descendantsOfType("command"), found = [];
+    if (root.hasError) return { kind: "none", unresolved: true, participation: recognizedParticipation(root, depth), reason: "shell_parse_error" };
+    const nodes = root.descendantsOfType("command"), found = [], auxiliaries = [];
     let unsupported;
     for (const node of nodes) {
       const name = node.childForFieldName("name"), values = words(node.text);
@@ -122,6 +163,13 @@ function analyze(command, wrapped, depth) {
         }
       }
       const direct = invocationFromWords(values, node, wrapped, inherited);
+      const auxiliary = auxiliaryFromWords(values);
+      if (auxiliary) {
+        const route = executionCwd(node, nodes);
+        if (dynamicWord(node) || backgroundContext(node) || ancestors(node).some(type => repeatedContexts.has(type) || ["command_substitution", "process_substitution"].includes(type)) || route.unresolved) unsupported ??= "unsupported_auxiliary_execution";
+        auxiliaries.push({ ...auxiliary, ...(route.cwd ? { expectedCwd: route.cwd } : {}) });
+        continue;
+      }
       if (direct) {
         if (backgroundContext(node)) unsupported ??= "background_lifecycle_execution";
         if (node.namedChildren.some(dynamicWord)) unsupported ??= "unresolved_lifecycle_word";
@@ -140,6 +188,7 @@ function analyze(command, wrapped, depth) {
         if (values[nestedIndex] === "--") nestedIndex++;
         if (wrapper === "timeout" && /^\d+(?:\.\d+)?[smhd]?$/.test(values[nestedIndex] ?? "")) nestedIndex++;
         const nested = analyze(quote(values.slice(nestedIndex)), true, depth + 1);
+        if (nested.auxiliary || ["lifecycle", "auxiliary"].includes(nested.participation)) return { kind: "none", participation: nested.auxiliary ? "auxiliary" : nested.participation, unresolved: true, reason: "opaque_execution_wrapper" };
         if (nested.kind !== "none") { found.push(...(nested.invocations ?? [nested.invocation])); unsupported ??= "opaque_execution_wrapper"; continue; }
         if (nested.unresolved) unsupported ??= nested.reason;
       }
@@ -148,6 +197,12 @@ function analyze(command, wrapped, depth) {
         if (!payloadNode || dynamicWord(payloadNode)) { unsupported ??= "dynamic_shell_payload"; continue; }
         if (node.namedChildren.some(child => child !== payloadNode && dynamicWord(child))) unsupported ??= "unresolved_shell_environment";
         const nested = analyze(values[shellIndex + 2], true, depth + 1);
+        if (nested.auxiliary) {
+          const route = executionCwd(node, nodes);
+          if (route.unresolved || backgroundContext(node) || ancestors(node).some(type => repeatedContexts.has(type) || ["command_substitution", "process_substitution"].includes(type))) unsupported ??= "unsupported_auxiliary_execution";
+          auxiliaries.push({ ...nested.auxiliary, ...(route.cwd && !nested.auxiliary.expectedCwd ? { expectedCwd: route.cwd } : {}) });
+        }
+        if (nested.participation && ["lifecycle", "auxiliary"].includes(nested.participation) && nested.unresolved) return { kind: "none", unresolved: true, participation: nested.participation, reason: nested.reason };
         if (nested.kind !== "none") {
           const route = executionCwd(node, nodes);
           if (route.unresolved) unsupported ??= "unresolved_execution_cwd";
@@ -162,10 +217,18 @@ function analyze(command, wrapped, depth) {
           if (nested.supported === false) unsupported ??= nested.reason ?? "unsupported_wrapper";
         }
         else if (nested.unresolved) unsupported ??= nested.reason;
-      } else if (values[shellIndex] === "eval") unsupported ??= "dynamic_eval";
+      } else if (values[shellIndex] === "eval") {
+        const participation = recognizedParticipation(root, depth);
+        if (participation !== "unproven") return { kind: "none", unresolved: true, participation, reason: "dynamic_eval" };
+        unsupported ??= "dynamic_eval";
+      }
       else if (values[shellIndex] === "coproc") unsupported ??= "background_lifecycle_execution";
       else if (dynamicWord(name)) unsupported ??= "dynamic_executable";
     }
+    if (auxiliaries.length) {
+      if (found.length || auxiliaries.length !== 1) unsupported ??= "multiple_lifecycle_invocations";
+      if (!found.length) return { kind: "none", participation: "auxiliary", ...(unsupported ? { unresolved: true, reason: unsupported } : { auxiliary: auxiliaries[0] }) };
+    }
     if (!found.length) return unsupported ? { kind: "none", unresolved: true, reason: unsupported } : { kind: "none" };
     if (found.length > 1) unsupported ??= "multiple_lifecycle_invocations";
     const invocation = found[0];
@@ -180,20 +243,11 @@ export function lifecycleCommandFromPayload(payload) {
   return typeof command === "string" ? unwrapShellCommand(command) : undefined;
 }
 export function continuationCommand(command) {
-  const values = words(command); if (!values) return null;
-  const start = values.findIndex(word => ["stage", "work"].includes(word)); if (start < 1) return null;
-  const launcher = values.slice(0, start);
-  while (launcher[0] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(launcher[0])) launcher.shift();
-  const direct = launcher.length === 1 && (path.basename(launcher[0]) === "dd-flow" || launcher[0] === "$DD_FLOW_BIN");
-  const node = launcher.length === 2 && path.basename(launcher[0]) === "node" && (path.basename(launcher[1]) === "cli.js" || launcher[1] === "$DD_FLOW_BIN");
-  if (!direct && !node) return null;
-  const args = parseCommandArgs(values.slice(start)), route = args.positional.slice(0, 3).join(" ");
-  const operation = route === "work repair add" ? "work_repair_add" : args.positional[0] === "stage" && args.positional[1] === "block" ? "stage_block" : null;
-  return operation ? { operation, args } : null;
+  return parseLifecycleCommand(command).auxiliary ?? null;
 }
 export function unwrapShellCommand(command) {
   const values = words(command); if (!values || values.length !== 3 || !shells.has(path.basename(values[0])) || !/^-(?:l?c|cl)$/.test(values[1])) return command;
-  const tree = parser.parse(command);
+  const tree = shellParser().parse(command);
   try { const node = tree?.rootNode.namedChildren[0]?.namedChildren[2]; return node && !dynamicWord(node) ? values[2] : command; }
   finally { /* Native Tree lifetime is managed by the Node binding. */ }
 }

package/dist/harness-runtime/lib/managed-daemon.d.mts

@@ -1,2 +1,11 @@
 import type { ChildProcess } from "node:child_process";
-export function stopProcessGroup(child: ChildProcess | null | undefined, graceMs?: number, options?: { detached?: boolean }): Promise<void>;
+type RuntimeConfig = Record<string, unknown>;
+type ProcessBinding = { id: string; lease_token: string; kind?: string; lease_expires_at?: string; registration_sha256?: string };
+export function runtimeProcess(config: RuntimeConfig, action: string, options?: Record<string, unknown>, transport?: { timeoutMs?: number; signal?: AbortSignal }): Promise<Record<string, unknown> | null>;
+export function registerDaemonProcess(config: RuntimeConfig, input: { kind: string; [key: string]: unknown }): Promise<ProcessBinding | null>;
+export function confirmDaemonProcess(config: RuntimeConfig, record: ProcessBinding | null | undefined, child: Pick<ChildProcess, "pid"> | null | undefined): Promise<void>;
+export function assertDaemonOwnership(stateDir: string, dispatch?: Record<string, unknown>, assertCurrent?: () => void): Promise<void>;
+export function heartbeatDaemonProcess(config: RuntimeConfig, record: ProcessBinding | null | undefined): Promise<void>;
+export function finishDaemonProcess(config: RuntimeConfig, record: ProcessBinding | null | undefined, state?: string, reason?: string): Promise<void>;
+export function completeBudgetOperation(stateDir: string, request: { id: string; operation: string; params?: { sessionId?: string } }, result: unknown, observe?: () => Promise<Record<string, unknown>>): Promise<Record<string, unknown>>;
+export function stopProcessGroup(child: ChildProcess | null | undefined, graceMs?: number, options?: { detached?: boolean; settlementMs?: number }): Promise<void>;

package/dist/harness-runtime/lib/managed-daemon.mjs

@@ -5,8 +5,13 @@ import { commandJson } from "./process-json.mjs";
 import { errorRecord } from "./operation-errors.mjs";
 import { writeJsonAtomic } from "./runner-events.mjs";
 import { runBoundedCommand } from "./native-hook-command.mjs";
+import { createRenewalState, maintenanceRetryable, renewalConfirmed, renewalDelay, renewalFailure, renewalRemaining, RENEWAL_POLICY } from "./lease-renewal.mjs";
 
 const leases = new Map();
+// A rejected Promise is not physical exit. Do not start another writer for
+// this exact binding after an unconfirmed maintenance subtree cleanup.
+const maintenancePoison = new Map();
+const maintenanceFlights = new Map();
 
 /** Freeze resource ownership independently of whether Subject hooks are enabled. */
 export function bindRuntimeOwner(config, env = process.env) {
@@ -38,6 +43,7 @@ export function bindRuntimeOwner(config, env = process.env) {
 
 /** Reject rebinding before provider setup, including the already-running path. */
 export async function prepareRuntimeOwner(config, stateDir, env = process.env) {
+  config.stateDir = path.resolve(stateDir);
   const owner = bindRuntimeOwner(config, env);
   if (owner && path.resolve(owner.state_dir) !== path.resolve(stateDir)) {
     throw Object.assign(new Error("runtime owner belongs to another state directory"), { code: "runtime_owner_mismatch" });
@@ -52,27 +58,44 @@ export async function prepareRuntimeOwner(config, stateDir, env = process.env) {
   return owner;
 }
 
-export async function assertDaemonOwnership(stateDir, dispatch = {}, assertCurrent = () => {}) {
-  for (const lease of leases.values()) if (!lease.stateDir && lease.error) throw lease.error;
+export async function assertDaemonOwnership(stateDir, dispatch = {}, assertCurrent = () => {}, progress = async () => {}, waiting = async () => {}) {
+  const gate = async () => {
+    assertCurrent();
+    for (const lease of leases.values()) {
+      if (lease.stateDir !== path.resolve(stateDir)) continue;
+      await reconfirmLease(lease, assertCurrent);
+      assertCurrent();
+    }
+  };
+  await gate();
+  await progress('ownership_confirmed');
   const state = JSON.parse(await readFile(path.join(stateDir, "daemon.json"), "utf8"));
   const owner = bindRuntimeOwner({ runtime_owner: state.config?.runtime_owner ?? null }, {});
   if (!owner) return;
   const record = state.resource_process;
   if (owner.state_dir !== stateDir || !record?.id || !record.lease_token) throw Object.assign(new Error("owned daemon has no confirmed resource binding"), { code: "process_ownership_unknown" });
-  for (const lease of leases.values()) {
-    if (lease.stateDir !== stateDir) continue;
-    if (Date.now() >= lease.expiresAt) throw Object.assign(new Error("managed process renewal is overdue"), { code: "process_ownership_unknown", details: { process_id: lease.record.id, cause: lease.error ? errorRecord(lease.error) : null } });
-    // A failed renewal is not a lost lease. Reconfirm before productive work;
-    // never dispatch on the old lease merely because it has time remaining.
-    if (lease.error && !lease.lost) await heartbeatDaemonProcess(lease.config, lease.record);
-    if (lease.error) throw lease.error;
-  }
+  scheduleDaemonProcessHeartbeat(state.config, record);
+  const admissionRenewal = createRenewalState();
   for (;;) {
+    await gate();
+    admissionRenewal.uncertainSince ??= performance.now();
+    let result;
+    try { result = await runtimeProcess(state.config, "admission", { id: record.id, "lease-token": record.lease_token, owner: owner.owner_id, "state-dir": stateDir, "daemon-id": state.daemon_id ?? state.config?.daemonId, ...dispatch }, { timeoutMs: renewalRemaining(admissionRenewal) }); }
+    catch (error) {
+      if (!maintenanceRetryable(error) || !renewalFailure(admissionRenewal)) throw error;
+      await new Promise(resolve => setTimeout(resolve, Math.min(renewalDelay(admissionRenewal), renewalRemaining(admissionRenewal))));
+      continue;
+    }
     assertCurrent();
-    const result = await runtimeProcess(state.config, "admission", { id: record.id, "lease-token": record.lease_token, owner: owner.owner_id, "state-dir": stateDir, "daemon-id": state.daemon_id ?? state.config?.daemonId, ...dispatch });
-    assertCurrent();
-    if (result?.ok === true && result.admitted === true && result.process_id === record.id) return;
-    if (result?.ok !== true || result.reason !== "provider_capacity" || result.process_id !== record.id) throw Object.assign(new Error("productive runtime admission was not confirmed"), { code: "process_ownership_unknown" });
+    if (result?.ok !== true || result.process_id !== record.id || result.admitted !== true && result.reason !== "provider_capacity") throw Object.assign(new Error("productive runtime admission was not confirmed"), { code: "process_ownership_unknown" });
+    requireTimelyMaintenance(admissionRenewal, "admission", result, record);
+    // This bound ACK ends admission uncertainty. The post-ACK lease checks
+    // have their own episodes; successful renewal must not exhaust an already
+    // confirmed admission while the provider/daemon still retain ownership.
+    if (!renewalConfirmed(admissionRenewal)) requireTimelyMaintenance(admissionRenewal, "admission", result, record);
+    await gate();
+    await waiting({ ...result, lease_expires_at: result.lease_expires_at ?? record.lease_expires_at });
+    if (result.admitted === true) { await progress('admission_confirmed'); return; }
     const predecessor = result.blocking_turns?.find(turn => turn?.process_id === record.id
       && turn?.session_id === dispatch["native-session-id"]
       && turn?.operation_id !== dispatch["operation-id"]);
@@ -153,20 +176,92 @@ async function budgetState(stateDir) {
 
 async function releaseBudget(state, options) {
   const record = state.resource_process, owner = state.config.runtime_owner;
-  const receipt = await runtimeProcess(state.config, "release-turn", { id: record.id, "lease-token": record.lease_token, owner: owner.owner_id, "daemon-id": state.daemon_id ?? state.config?.daemonId, ...options });
+  const receipt = await retryBookkeeping(timeoutMs => runtimeProcess(state.config, "release-turn", { id: record.id, "lease-token": record.lease_token, owner: owner.owner_id, "daemon-id": state.daemon_id ?? state.config?.daemonId, ...options }, { timeoutMs }));
   if (receipt?.ok !== true) throw Object.assign(new Error("runtime budget release was not confirmed"), { code: "runtime_budget_release_unconfirmed" });
 }
 
-export async function runtimeProcess(config, action, options = {}) {
+export async function runtimeProcess(config, action, options = {}, { timeoutMs = RENEWAL_POLICY.budgetMs, signal } = {}) {
+  const resourceHome = config.runtime_owner?.resource_home ?? config.resourceHome;
+  if (action === "status" || !options.id || !resourceHome) return executeRuntimeProcess(config, action, options, { timeoutMs, signal });
+  const key = JSON.stringify([path.resolve(resourceHome), options.id, options["lease-token"] ?? null]);
+  const validBudget = Number.isFinite(timeoutMs) && timeoutMs > 0;
+  const deadline = performance.now() + (validBudget ? timeoutMs : 0);
+  const prior = maintenanceFlights.get(key);
+  let started = false;
+  let settle;
+  const flight = new Promise(resolve => { settle = resolve; });
+  maintenanceFlights.set(key, flight);
+  try {
+    if (!validBudget) throw Object.assign(new Error("Managed maintenance budget is invalid or exhausted before dispatch"), { code: "process_maintenance_timeout", details: { effect: "no_effect", native_dispatch_started: false } });
+    if (prior) {
+      let timer;
+      try {
+        await Promise.race([prior, new Promise((_, reject) => {
+          const expire = () => {
+            const remaining = deadline - performance.now();
+            // A timer wakeup is not proof that its monotonic deadline passed.
+            if (remaining > 0) { timer = setTimeout(expire, Math.min(2_147_483_647, Math.ceil(remaining))); return; }
+            reject(Object.assign(new Error("managed maintenance queue deadline expired"), { code: "process_maintenance_timeout", details: { effect: "no_effect" } }));
+          };
+          expire();
+        })]);
+      } finally { clearTimeout(timer); }
+    }
+    const remaining = deadline - performance.now();
+    if (remaining <= 0) throw Object.assign(new Error("managed maintenance queue deadline expired"), { code: "process_maintenance_timeout", details: { effect: "no_effect" } });
+    started = true;
+    return await executeRuntimeProcess(config, action, options, { timeoutMs: remaining, signal });
+  } catch (error) {
+    const lease = leases.get(key);
+    const text = value => typeof value === "string" ? value.slice(0, 128) : undefined;
+    const request = { phase: started ? "request" : "queue", action, process_id: text(options.id), operation_id: text(options["operation-id"] ?? config.runtime_owner?.operation_id), role: text(lease?.record.kind ?? config.runtime_owner?.role), attempt_kind: prior ? "join" : "fresh", attempt: (lease?.renewal.attempt ?? 0) + 1, remaining_ms: Math.max(0, Math.round(deadline - performance.now())), native_dispatch_started: false, maintenance_effect: started ? "unknown" : "no_effect" };
+    // Parent queue/import failures precede any child trace. Keep only bounded,
+    // credential-free context and the existing child phase allowlist.
+    const childPhases = Array.isArray(error.details?.hook_diagnostics) ? error.details.hook_diagnostics : [];
+    error.details = { ...error.details, hook_diagnostics: [request, ...childPhases.slice(-15)] };
+    throw error;
+  } finally {
+    // Even a waiter whose deadline expires must retain its predecessor's
+    // physical fence until that predecessor settles.
+    const finish = () => {
+      settle();
+      if (maintenanceFlights.get(key) === flight) maintenanceFlights.delete(key);
+    };
+    if (prior) void prior.then(finish); else finish();
+  }
+}
+
+async function executeRuntimeProcess(config, action, options = {}, { timeoutMs, signal }) {
   const owner = config.runtime_owner;
   const resourceHome = owner?.resource_home ?? config.resourceHome;
   const ddFlowHome = owner?.dd_flow_home ?? config.ddFlowHome;
   const ddFlowBin = owner?.dd_flow_bin ?? config.ddFlowBin;
   if (!resourceHome || !ddFlowHome || !ddFlowBin) return null;
+  const poisonKey = token => JSON.stringify([path.resolve(resourceHome), options.id, token ?? null]);
+  if (action !== "status" && options.id) {
+    const poison = maintenancePoison.get(poisonKey(options["lease-token"])) ?? maintenancePoison.get(poisonKey(null));
+    if (poison) throw poison;
+  }
   const args = ["runtime", "process", action];
   for (const [key, value] of Object.entries(options)) if (value !== null && value !== undefined) args.push(`--${key}`, String(value));
-  if (action === "heartbeat") return JSON.parse(await runBoundedCommand({ bin: ddFlowBin, args: [...args, "--json"], cwd: config.cwd,
-    env: { ...(config.env ?? {}), DD_FLOW_HOME: ddFlowHome, DD_FLOW_RESOURCE_HOME: resourceHome }, timeoutMs: 15_000, timeoutCode: "process_heartbeat_timeout" }));
+  if (["register", "confirm", "heartbeat", "admission", "check-admission", "finish", "release-turn", "status"].includes(action)) {
+    const maintenanceStarted = performance.now();
+    process.stderr.write(`${JSON.stringify({ kind: "process_maintenance_phase", phase: "request", observed_at: new Date().toISOString(), operation_id: options['operation-id'] ?? config.runtime_owner?.operation_id ?? null, action, process_id: options.id ?? null, remaining_ms: Math.round(timeoutMs), native_dispatch_started: false })}\n`);
+    let output;
+    try { output = await runBoundedCommand({ bin: ddFlowBin, args: [...args, "--json"], cwd: config.cwd,
+      env: { ...(config.env ?? {}), DD_FLOW_HOME: ddFlowHome, DD_FLOW_RESOURCE_HOME: resourceHome }, timeoutMs,
+      timeoutCode: action === "heartbeat" ? "process_heartbeat_timeout" : "process_maintenance_timeout", inheritDeadline: false, cleanupWithinBudget: true,
+      maintenanceProgress: { action, processId: options.id ?? null, inactivityMs: RENEWAL_POLICY.attemptMs }, signal }); }
+    catch (error) {
+      if (action !== "status" && options.id && error.details?.cleanup_unconfirmed) maintenancePoison.set(poisonKey(options["lease-token"]), error);
+      throw error;
+    }
+    let result;
+    try { result = JSON.parse(output); } catch { throw Object.assign(new Error("Invalid managed process maintenance response"), { code: "process_maintenance_receipt_invalid", details: { action } }); }
+    if (result?.ok === false && result.error?.code) throw Object.assign(new Error(result.error.message ?? "Managed process maintenance failed"), { code: result.error.code, details: result.error.details });
+    process.stderr.write(`${JSON.stringify({ kind: "process_maintenance_phase", phase: "ack", observed_at: new Date().toISOString(), duration_ms: Math.round(performance.now() - maintenanceStarted), operation_id: options['operation-id'] ?? config.runtime_owner?.operation_id ?? null, action, process_id: options.id ?? null, lease_expires_at: result.lease_expires_at ?? result.process?.lease_expires_at ?? null, native_dispatch_started: false })}\n`);
+    return result;
+  }
   return await commandJson(ddFlowBin, args, {
     cwd: config.cwd,
     env: { ...(config.env ?? {}), DD_FLOW_HOME: ddFlowHome, DD_FLOW_RESOURCE_HOME: resourceHome }
@@ -177,8 +272,38 @@ export async function registerDaemonProcess(config, input) {
   const owner = bindRuntimeOwner(config);
   const harness = ({ "codex-daemon": "codex-desktop", "codex-provider": "codex-desktop", "zcode-daemon": "zcode-acp", "zcode-provider": "zcode-acp", "grok-daemon": "grok-acp", "grok-provider": "grok-acp", "agy-daemon": "antigravity-cli", "opencode-daemon": "opencode-server", "droid-daemon": "droid-cli" })[input.kind];
   const scope = owner ? { owner: owner.owner_id, "project-id": owner.project_id, run: owner.run_id, work: owner.work_id, role: owner.role, "state-dir": owner.state_dir, "adapter-executable": owner.adapter_executable, ...(owner.budget ? { "budget-json": JSON.stringify(owner.budget), harness } : {}), ...(owner.project_id && owner.run_id || owner.budget ? { "dispatch-barrier": "run-generation@1" } : {}), operation: `${owner.operation_id}:${input.operation ?? input.kind}` } : {};
-  const result = await runtimeProcess(config, "register", { ...input, ...scope, "owner-pid": process.pid, "lease-ms": 300_000 });
-  return result?.process ? { id: result.process.id, lease_token: result.process.lease_token, kind: input.kind } : null;
+  const options = { ...input, ...scope, id: `PROC-${input.kind}-${randomUUID()}`, "owner-pid": process.pid, "lease-ms": 300_000 };
+  const renewal = createRenewalState();
+  renewal.uncertainSince = performance.now();
+  let result;
+  for (;;) {
+    try { result = await runtimeProcess(config, "register", options, { timeoutMs: renewalRemaining(renewal) }); break; }
+    catch (error) {
+      if (!maintenanceRetryable(error) || !renewalFailure(renewal)) throw error;
+      // The child has exited before a timeout is retryable. Reconcile the exact
+      // startup identity, not an arbitrary PID or another operation's owner.
+      let status;
+      try { status = await retryBookkeeping(timeoutMs => runtimeProcess(config, "status", {}, { timeoutMs }), renewal); }
+      catch (reconciliationError) {
+        // Retain the failed write's phases without changing the reconciliation
+        // failure's classification or authorizing another startup attempt.
+        reconciliationError.details = { ...reconciliationError.details, registration_error: errorRecord(error) };
+        throw reconciliationError;
+      }
+      const retained = status?.processes?.find(record => record.id === options.id);
+      if (retained) {
+        let metadata; try { metadata = JSON.parse(retained.metadata_json); } catch { /* Invalid binding below. */ }
+        if (retained.kind !== options.kind || retained.owner_id !== options.owner || retained.operation_id !== options.operation || retained.state !== "starting" || metadata?.owner_pid !== process.pid) throw Object.assign(new Error("Startup reconciliation changed managed process binding"), { code: "process_maintenance_receipt_invalid" });
+        result = { process: retained }; break;
+      }
+      if (!Array.isArray(status?.processes)) throw Object.assign(new Error("Startup reconciliation has no registry proof"), { code: "process_maintenance_receipt_invalid" });
+      await new Promise(resolve => setTimeout(resolve, Math.min(renewalDelay(renewal), renewalRemaining(renewal))));
+    }
+  }
+  if (!result) return null;
+  if (result.process?.id !== options.id || !result.process.lease_token) throw Object.assign(new Error("Managed startup receipt belongs to another registration"), { code: "process_maintenance_receipt_invalid" });
+  requireTimelyMaintenance(renewal, "register", result, result.process);
+  return { id: result.process.id, lease_token: result.process.lease_token, kind: input.kind, lease_expires_at: result.process.lease_expires_at };
 }
 
 export async function confirmDaemonProcess(config, record, child) {
@@ -187,7 +312,11 @@ export async function confirmDaemonProcess(config, record, child) {
     await finishDaemonProcess(config, record, "failed", "daemon_spawn_missing_pid");
     return;
   }
-  await runtimeProcess(config, "confirm", { id: record.id, "lease-token": record.lease_token, pid: child.pid, "process-group-id": child.pid, "owner-pid": record.kind?.endsWith("-daemon") ? child.pid : process.pid, "lease-ms": 300_000 });
+  const renewal = createRenewalState();
+  const result = await retryBookkeeping(timeoutMs => runtimeProcess(config, "confirm", { id: record.id, "lease-token": record.lease_token, pid: child.pid, "process-group-id": child.pid, "owner-pid": record.kind?.endsWith("-daemon") ? child.pid : process.pid, "lease-ms": 300_000 }, { timeoutMs }), renewal);
+  if (!result?.process || result.process.id !== record.id || result.process.lease_token !== record.lease_token) throw Object.assign(new Error("Managed process confirmation binding is invalid"), { code: "process_maintenance_receipt_invalid" });
+  retainReceipt(record, result.process);
+  requireTimelyMaintenance(renewal, "confirm", result, record);
 }
 
 /** Provider bridges use a different process group from their daemon. Publish
@@ -217,29 +346,40 @@ export async function closeManagedBridge(config, state, bridge) {
 
 export function scheduleDaemonProcessHeartbeat(config, record) {
   if (!record?.id || !record.lease_token) return;
-  if (leases.has(record.id)) return;
-  const lease = { pending: null, error: null, timer: null, lost: false, expiresAt: Date.now() + 300_000, stateDir: config.runtime_owner?.state_dir, config, record };
-  leases.set(record.id, lease);
-  lease.timer = setInterval(() => { void heartbeatDaemonProcess(config, record).catch(() => {}); }, 60_000);
+  const key = leaseKey(config, record);
+  if (leases.has(key)) return;
+  const lease = { pending: null, error: null, timer: null, lost: false, closing: false, expiresAt: Date.parse(record.lease_expires_at ?? ""), renewal: createRenewalState(), stateDir: path.resolve(config.runtime_owner?.state_dir ?? config.stateDir ?? config.cwd), config, record };
+  leases.set(key, lease);
+  // Retry inside the same uncertainty episode while native work is active.
+  // Waiting for the next 60s tick would exhaust the 30s budget after one BUSY.
+  lease.timer = setInterval(() => reconfirmLease(lease, () => {}).catch(() => {}), 60_000);
   lease.timer.unref();
 }
 
 export async function heartbeatDaemonProcess(config, record) {
   if (!record?.id || !record.lease_token) return;
   scheduleDaemonProcessHeartbeat(config, record);
-  const lease = leases.get(record.id);
+  const lease = leases.get(leaseKey(config, record));
+  if (lease.closing) throw Object.assign(new Error("Managed process is closing"), { code: "process_closing" });
   if (lease.lost) throw lease.error;
+  if (lease.error && !maintenanceRetryable(lease.error)) throw lease.error;
+  if (!renewalRemaining(lease.renewal)) throw lease.error;
   if (lease.pending) return await lease.pending;
   lease.pending = (async () => {
     try {
-      const result = await runtimeProcess(config, "heartbeat", { id: record.id, "lease-token": record.lease_token, "lease-ms": 300_000 });
-      if (result?.ok !== true) {
+      lease.renewal.uncertainSince ??= performance.now();
+      const result = await runtimeProcess(config, "heartbeat", { id: record.id, "lease-token": record.lease_token, "lease-ms": 300_000 }, { timeoutMs: renewalRemaining(lease.renewal) });
+      if (result?.ok === false) {
         lease.lost = true; clearInterval(lease.timer);
         throw Object.assign(new Error("managed process lease is no longer owned; new productive operations are blocked"), { code: "process_lease_lost", details: { process_id: record.id } });
       }
-      lease.error = null;
-      lease.expiresAt = Date.now() + 300_000;
+      if (result?.ok !== true || result.process_id !== record.id) throw Object.assign(new Error("Managed renewal response belongs to another process"), { code: "process_maintenance_receipt_invalid", details: { process_id: record.id } });
+      if (!lease.closing) {
+        if (!renewalConfirmed(lease.renewal)) requireTimelyMaintenance(lease.renewal, "heartbeat", result, record);
+        retainReceipt(record, result); lease.error = null; lease.expiresAt = Date.parse(record.lease_expires_at);
+      }
     } catch (cause) {
+      if (!lease.closing) renewalFailure(lease.renewal);
       lease.error = cause.code === "process_lease_lost" ? cause : Object.assign(new Error("cannot confirm managed process ownership"), { code: "process_ownership_unknown", cause, details: { process_id: record.id, cause: errorRecord(cause) } });
       throw lease.error;
     }
@@ -249,13 +389,59 @@ export async function heartbeatDaemonProcess(config, record) {
 
 export async function finishDaemonProcess(config, process, state = "stopped", reason = "daemon_stopped") {
   if (process?.id && process.lease_token) {
-    const lease = leases.get(process.id); if (lease) clearInterval(lease.timer);
-    const result = await runtimeProcess(config, "finish", { id: process.id, "lease-token": process.lease_token, state, reason });
+    const settlement = createRenewalState(); settlement.uncertainSince = performance.now();
+    const key = leaseKey(config, process), lease = leases.get(key);
+    if (lease) { lease.closing = true; clearInterval(lease.timer); await lease.pending?.catch(() => {}); if (lease.error?.cause?.details?.cleanup_unconfirmed) throw lease.error; }
+    const result = await retryBookkeeping(timeoutMs => runtimeProcess(config, "finish", { id: process.id, "lease-token": process.lease_token, state, reason }, { timeoutMs }), settlement);
     if (result?.ok !== true) throw Object.assign(new Error("managed process finish was not accepted"), { code: "process_lease_lost", details: { process_id: process.id } });
-    leases.delete(process.id);
+    leases.delete(key);
   }
 }
 
+function leaseKey(config, record) { return JSON.stringify([path.resolve(config.runtime_owner?.resource_home ?? config.resourceHome), record.id, record.lease_token]); }
+function retainReceipt(record, receipt) {
+  const expiresAt = Date.parse(receipt.lease_expires_at ?? "");
+  if (!Number.isFinite(expiresAt) || !/^[a-f0-9]{64}$/.test(receipt.registration_sha256 ?? "") || record.registration_sha256 && record.registration_sha256 !== receipt.registration_sha256) throw Object.assign(new Error("Managed lease receipt has no authoritative expiry/binding"), { code: "process_maintenance_receipt_invalid", details: { process_id: record.id } });
+  record.lease_expires_at = receipt.lease_expires_at;
+  record.registration_sha256 = receipt.registration_sha256;
+}
+async function reconfirmLease(lease, assertCurrent) {
+  for (;;) {
+    assertCurrent();
+    if (lease.closing || lease.lost) throw lease.error ?? Object.assign(new Error("Managed process is closing"), { code: "process_closing" });
+    try { await heartbeatDaemonProcess(lease.config, lease.record); }
+    catch (error) {
+      if (!maintenanceRetryable(error) || !renewalRemaining(lease.renewal)) throw error;
+      await new Promise(resolve => setTimeout(resolve, Math.min(renewalDelay(lease.renewal), renewalRemaining(lease.renewal))));
+      continue;
+    }
+    assertCurrent();
+    if (lease.closing || lease.error || !Number.isFinite(lease.expiresAt) || Date.now() >= lease.expiresAt) throw lease.error ?? Object.assign(new Error("Committed lease receipt expired before admission"), { code: "process_ownership_unknown" });
+    return;
+  }
+}
+async function retryBookkeeping(action, renewal = createRenewalState()) {
+  renewal.uncertainSince ??= performance.now();
+  for (;;) {
+    try { return await action(renewalRemaining(renewal)); }
+    catch (error) { if (!maintenanceRetryable(error) || !renewalFailure(renewal)) throw error; await new Promise(resolve => setTimeout(resolve, Math.min(renewalDelay(renewal), renewalRemaining(renewal)))); }
+  }
+}
+
+// A committed ACK is evidence, but cannot revive an expired authority episode.
+// Cleanup-only finish/release receipts remain facts, not productive grants.
+function requireTimelyMaintenance(renewal, action, receipt, record) {
+  if (renewalRemaining(renewal)) return;
+  const safeText = value => typeof value === "string" ? value.slice(0, 128) : undefined;
+  const hash = receipt?.process?.registration_sha256 ?? receipt?.registration_sha256 ?? record?.registration_sha256;
+  throw Object.assign(new Error("Managed ownership confirmation arrived after its uncertainty budget"), {
+    code: "process_ownership_unknown", details: { action, process_id: safeText(record?.id ?? receipt?.process_id),
+      registration_sha256: typeof hash === "string" && /^[a-f0-9]{64}$/.test(hash) ? hash : undefined,
+      lease_expires_at: safeText(receipt?.process?.lease_expires_at ?? receipt?.lease_expires_at ?? record?.lease_expires_at),
+      effect: action === "admission" && receipt?.admitted !== true ? "no_effect" : "committed", native_dispatch_started: false }
+  });
+}
+
 /** Preserve the startup error and retain the lease/resources if cleanup cannot
  * prove termination. A failed cleanup is not a terminal managed process. */
 export async function cleanupFailedStart(config, record, child, original) {
@@ -287,7 +473,7 @@ export async function cleanupFailedDaemonStart(config, daemonRecord, daemonChild
 }
 
 const processStops = new WeakMap();
-export async function closeBridgeProcess(bridge, drain) {
+export async function closeBridgeProcess(bridge, drain, stopOptions = {}) {
   if (bridge.closePending) return await bridge.closePending;
   const pending = (async () => {
     let primary;
@@ -301,7 +487,7 @@ export async function closeBridgeProcess(bridge, drain) {
             const timer = setTimeout(done, 2_000); child.once("exit", done);
           });
         }
-        await stopProcessGroup(child, 2_000);
+        await stopProcessGroup(child, 2_000, stopOptions);
         bridge.physicallyClosed = true;
       }
     } catch (error) { primary = error; }
@@ -316,14 +502,14 @@ export async function closeBridgeProcess(bridge, drain) {
   finally { bridge.closePending = null; }
 }
 
-export async function stopProcessGroup(child, graceMs = 1_000, { detached = true } = {}) {
+export async function stopProcessGroup(child, graceMs = 1_000, { detached = true, settlementMs = 10_000 } = {}) {
   if (!child?.pid) return;
   if (processStops.has(child)) return await processStops.get(child);
-  const pending = stopOwnedChild(child, graceMs, detached);
+  const pending = stopOwnedChild(child, graceMs, detached, settlementMs);
   processStops.set(child, pending);
   try { return await pending; } finally { processStops.delete(child); }
 }
-async function stopOwnedChild(child, graceMs, detached) {
+async function stopOwnedChild(child, graceMs, detached, settlementMs) {
   const target = process.platform === "win32" || !detached ? child.pid : -child.pid;
   const details = signal => ({ pid: child.pid, pgid: target < 0 ? child.pid : null, signal, platform: process.platform, exit_code: child.exitCode ?? null, signal_code: child.signalCode ?? null, observed_at: new Date().toISOString() });
   const alive = () => { try { process.kill(target, 0); return true; } catch (error) { if (error.code === "ESRCH") return false; if (error.code === "EPERM") return true; throw error; } };
@@ -351,8 +537,10 @@ async function stopOwnedChild(child, graceMs, detached) {
   if (!alive()) return;
   const leaderExited = () => child.exitCode != null || child.signalCode != null;
   const observeLeaderless = async () => {
-    if (await gone(Math.max(1_000, graceMs))) return;
-    throw Object.assign(new Error("process group remains after its leader exited; ownership cannot be proven from this child handle"), { code: "process_group_ownership_unknown", details: details(null) });
+    // Signal grace is not a drain deadline. Helpers can retire naturally after
+    // their leader exits; observing them does not authorize another signal.
+    if (await gone(Math.max(1_000, graceMs, settlementMs))) return;
+    throw Object.assign(new Error("process group remains after its leader exited; ownership cannot be proven from this child handle"), { code: "process_group_ownership_unknown", details: { ...details(null), settlement_ms: Math.max(1_000, graceMs, settlementMs) } });
   };
   if (leaderExited()) return await observeLeaderless();
   if (!await signal("SIGTERM")) return;