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

package/dist/harness-runtime/lib/driver-recovery.mjs

@@ -7,11 +7,21 @@ import { reportedError } from "./operation-errors.mjs";
 import { ObservationClock } from "./observation-clock.mjs";
 import { runtimeProcess } from "./managed-daemon.mjs";
 
+function cleanShutdownConfirmed(state) {
+  const proof = state.shutdown;
+  return state.shutdown_state === "clean" && state.active_tree === false
+    && proof?.schema_id === "dd-flow/daemon-shutdown@1" && proof.daemon_id === state.daemon_id
+    && proof.result?.clean === true && Array.isArray(proof.required_phases)
+    && proof.required_phases.length >= 3 && proof.required_phases.includes("tree")
+    && proof.required_phases.includes("daemon_resource")
+    && proof.required_phases.every(phase => typeof phase === "string" && proof.phases?.[phase] === true);
+}
+
 /** Explicit same-Session restart retains native stores and the old daemon
  * receipt; it does not turn a terminal directory into a new execution. */
 export async function authorizeRetainedDaemonResume(root, previous, sessionId, config) {
   const sessions = [...(previous.sessions ?? []), ...(previous.root_session_id ? [previous.root_session_id] : [])];
-  if (previous.shutdown_state !== "clean" || previous.active_tree === true || typeof sessionId !== "string" || !sessions.some(session => (typeof session === "string" ? session : session.provider_session_id) === sessionId)) throw Object.assign(new Error("terminal daemon restart requires a retained, settled Session identity"), { code: "daemon_state_terminal" });
+  if (!cleanShutdownConfirmed(previous) || typeof sessionId !== "string" || !sessions.some(session => (typeof session === "string" ? session : session.provider_session_id) === sessionId)) throw Object.assign(new Error("terminal daemon restart requires a retained, settled Session identity and complete shutdown proof"), { code: "daemon_state_terminal" });
   for (const key of ["cwd", "projectRoot", "ddFlowHome", "ddFlowBin", "provider", "model", "reasoning", "mode", "variant", "agent", "bin", "noFlow"]) {
     if ((previous.config?.[key] ?? null) !== (config[key] ?? null)) throw Object.assign(new Error(`retained daemon configuration changed: ${key}`), { code: "daemon_config_mismatch" });
   }
@@ -43,7 +53,7 @@ export async function recoverySettlement(driversRoot) {
       }
       else if (entry.name === "daemon.json") {
         const state = JSON.parse(await readFile(file, "utf8"));
-        if (state.shutdown_state !== "clean" || state.active_tree === true) throw Object.assign(new Error("provider tree has no clean shutdown receipt"), { code: "recovery_settlement_unconfirmed" });
+        if (!cleanShutdownConfirmed(state)) throw Object.assign(new Error("provider tree has no complete clean shutdown receipt"), { code: "recovery_settlement_unconfirmed" });
         await assertDaemonReplaceable(directory);
         await reconcileDriverReplies(directory);
         if (state.config?.resourceHome && state.resource_process?.id) {

package/dist/harness-runtime/lib/lease-renewal.d.mts

@@ -0,0 +1,8 @@
+export const RENEWAL_POLICY: Readonly<{ budgetMs: number; attemptMs: number }>;
+export type RenewalState = { uncertainSince: number | null; attempt: number; exhausted: boolean };
+export function createRenewalState(): RenewalState;
+export function renewalRemaining(state: RenewalState, now?: number): number;
+export function renewalFailure(state: RenewalState, now?: number): number;
+export function renewalDelay(state: RenewalState): number;
+export function renewalConfirmed(state: RenewalState, now?: number): boolean;
+export function maintenanceRetryable(error: unknown): boolean;

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

@@ -0,0 +1,11 @@
+import type { ChildProcess } from "node:child_process";
+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>;