@deksden-com/dd-flow-cli 0.9.0-beta.107 → 0.9.0-beta.108

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.108
+
+### Patch Changes
+
+- Route native tool hooks through the prepared hook store and skip storage entirely for unrelated tools. Give ZCode daemon readiness a bounded 30-second window and clean up the exact registered provider process if any managed daemon fails to start, preserving the primary startup error.
+
 ## 0.9.0-beta.107
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.107",
-  "cli_commit": "b1e4fba26b8d9dea7b9b4f6de05aec6be3e21dc2",
-  "built_at": "2026-09-27T03:02:31.051Z",
+  "cli_version": "0.9.0-beta.108",
+  "cli_commit": "0df3cd1e7201f27baeeb07f1c4f2b69ed6e2399b",
+  "built_at": "2026-09-27T04:24:32.044Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",

package/dist/cli/native-hook-ingress.js

@@ -0,0 +1,48 @@
+import { AppError, errorRecord } from "../shared/errors.js";
+import { parseCommandArgs } from "../services/lifecycle-command.js";
+/** These ingress commands consume a prepared store; they never prepare it. */
+export function isNativeHookIngress(args) {
+    return args[2] === "handle" && ((args[1] === "event" && ["agy", "grok", "droid", "opencode", "zcode"].includes(args[0] ?? ""))
+        || args[0] === "zcode" && args[1] === "hook");
+}
+export async function dispatchNativeHook(args, stdin, env) {
+    const parsed = parseCommandArgs(args.slice(3));
+    const projectRoot = parsed.options.get("project-root")?.[0];
+    if (!isNativeHookIngress(args) || parsed.positional.length || !projectRoot || projectRoot === "__dd_flow_flag__")
+        throw new AppError("usage", "Native hook requires --project-root", 2);
+    for (const [name, values] of parsed.options)
+        if (!["project-root", "json"].includes(name) || values.length !== 1 || name === "json" && values[0] !== "__dd_flow_flag__")
+            throw new AppError("usage", `Invalid native hook option: ${name}`, 2);
+    const [hooks, { createContext }, { resolveDdFlowHome }] = await Promise.all([
+        import("../services/hooks.js"), import("../runtime/context.js"), import("../storage/paths.js")
+    ]);
+    let opened;
+    // Reuse the actual envelope validators and shell parser. They return for
+    // unrelated tools before their first DB access, without duplicating policy.
+    const context = {
+        env, ddFlowHome: resolveDdFlowHome(env), now: () => new Date().toISOString(),
+        get db() { return (opened ??= createContext(env, "hook")).db; }
+    };
+    const handler = args[0] === "agy" ? hooks.handleAgyEvent : args[0] === "grok" ? hooks.handleGrokEvent
+        : args[0] === "droid" ? hooks.handleDroidEvent : args[0] === "opencode" ? hooks.handleOpenCodeEvent
+            : args[1] === "hook" ? hooks.handleZcodeHook : hooks.handleZcodeEvent;
+    try {
+        return await handler(context, { projectRoot, stdin });
+    }
+    finally {
+        opened?.db.close?.();
+    }
+}
+export async function runNativeHookIngress(args) {
+    try {
+        const { readNativeHookInput, hookBudget } = await import("../harness-runtime/lib/native-hook-command.mjs");
+        const stdin = await readNativeHookInput(process.stdin, hookBudget());
+        process.stdout.write(`${JSON.stringify(await dispatchNativeHook(args, stdin, process.env))}\n`);
+        return 0;
+    }
+    catch (error) {
+        const record = errorRecord(error);
+        process.stderr.write(`${JSON.stringify({ ok: false, error: record })}\n`);
+        return record.exitCode;
+    }
+}

package/dist/cli/run-cli.js

@@ -8,6 +8,7 @@ import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../servic
 import { verifyCodexHookDelivery } from "../services/codex-hook-delivery.js";
 import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, bindLifecyclePublishedPacket, expandLifecycleInvocationArgs, issueLifecycleInvocation, prepareLifecycleIssuance, lifecycleInvocationScope, observedLifecycleDiagnostic, observedLifecycleInvocation, resolveObservedLifecycleArgs, retainObservedLifecycleSemantics, settleLifecycleInvocation, settleLifecyclePreparationRejection, settleLifecycleRejection, validateLifecyclePathAliases } from "../services/lifecycle-invocations.js";
 import { createContext, createRouterContext } from "../runtime/context.js";
+import { dispatchNativeHook, isNativeHookIngress } from "./native-hook-ingress.js";
 import { migrateStoreWriter } from "../storage/writer-migration.js";
 import { helpForArgs } from "./help.js";
 import { AppError, isAppError } from "../shared/errors.js";
@@ -129,6 +130,10 @@ export async function runCli(args, io = defaultIo, env = process.env) {
             return 0;
         }
         const suppliedInvocationId = optionalOption(parseArgs(output.args.slice(2)), "invocation-id");
+        if (isNativeHookIngress(output.args)) {
+            writeJson(io.stdout, await dispatchNativeHook(output.args, await readStdin(io.stdin), env));
+            return 0;
+        }
         if (output.args[0] === "run" && ["drive", "control"].includes(output.args[1] ?? "")) {
             const controlArgs = parseArgs(output.args.slice(2));
             requiredOption(controlArgs, "run");
@@ -411,6 +416,8 @@ function resolveProjectRootBeforeRouting(args, env) {
     }
 }
 function databaseModeForCommand(args, classification) {
+    if (isNativeHookIngress(args))
+        return "hook";
     const [family, command] = args;
     // Managed attempts are issued only from a prepared store. Opening that
     // existing writer must not run migrations before their input is admitted.

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
+import { isNativeHookIngress } from "./cli/native-hook-ingress.js";
 const args = process.argv.slice(2);
 const managedHook = Boolean(process.env.DD_FLOW_CODEX_STATE_DIR) && args.slice(0, 3).join(" ") === "codex hook handle" && !args.includes("--help") && !args.includes("-h");
 const exitCode = managedHook
     ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
-    : await (await import("./cli/run-cli.js")).runCli(args);
+    : isNativeHookIngress(args) && !args.includes("--help") && !args.includes("-h")
+        ? await (await import("./cli/native-hook-ingress.js")).runNativeHookIngress(args)
+        : await (await import("./cli/run-cli.js")).runCli(args);
 process.exitCode = exitCode;
-export {};

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

@@ -12,7 +12,7 @@ import { durableDaemonDispatch } from "./daemon-operations.mjs";
 import path from "node:path";
 import { observeModel } from "./model-observations.mjs";
 import { AgyError, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, runtimeProcess, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
 class DaemonError extends AgyError {}
@@ -206,12 +206,7 @@ export async function startDaemon(options) {
     }
     throw new DaemonError("daemon_start_failed", "Antigravity daemon did not become ready", true);
   } catch (error) {
-    await cleanupFailedStart(config, resourceProcess, child, error);
-    const persisted = await readState(paths.dir).catch(() => null);
-    if (persisted?.provider_process) {
-      try { await runtimeProcess(config, "stop", { id: persisted.provider_process.id, "lease-token": persisted.provider_process.lease_token }); }
-      catch (cleanup) { error.details = { ...error.details, provider_cleanup_failed: errorPayload(cleanup), provider_process_id: persisted.provider_process.id }; }
-    }
+    await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), config.daemonId);
     throw error;
   }
 }
@@ -251,7 +246,10 @@ export class Runtime {
     void this.readyPromise.catch(() => {});
     this.providerProcess = await registerDaemonProcess(this.config, { kind: "agy-provider", owner: `agy:${path.basename(this.paths.dir)}`, operation: `agy-provider:${path.basename(this.paths.dir)}`, stdout: this.paths.log, stderr: this.paths.log });
     const providerProcess = this.providerProcess;
-    this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] });
+    try { await this.persist({ provider_process: providerProcess }); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
+    try { this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] }); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
     const providerChild = this.child;
     let allowProviderFinalization;
     const providerRegistered = new Promise(resolve => { allowProviderFinalization = resolve; });
@@ -283,7 +281,7 @@ export class Runtime {
       });
     });
     void this.providerFinalization.catch(() => {});
-    try { await confirmDaemonProcess(this.config, providerProcess, this.child); await heartbeatDaemonProcess(this.config, providerProcess); await this.persist({ provider_process: providerProcess, provider_pid: this.child.pid }); }
+    try { await confirmDaemonProcess(this.config, providerProcess, this.child); await this.persist({ provider_pid: this.child.pid }); await heartbeatDaemonProcess(this.config, providerProcess); }
     catch (error) { await cleanupFailedStart(this.config, providerProcess, this.child, error); throw error; }
     finally { allowProviderFinalization(); }
     let readyTimer;

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

@@ -9,7 +9,7 @@ import { spawn } from "node:child_process";
 import { waitForSettlement } from "./session-settlement.mjs";
 import { errorRecord } from "./operation-errors.mjs";
 import { CodexBridge, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 const requestSchema = "dd-codex/daemon-request@1";
 const responseSchema = "dd-codex/daemon-response@1";
@@ -90,7 +90,7 @@ export async function startDaemon(options) {
   await removeSocket(paths.socket); const resourceProcess = await registerDaemonProcess(config, { kind: "codex-daemon", owner: `codex:${path.basename(paths.dir)}`, operation: `codex-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log }); const state = { schema_id: stateSchema, daemon_id: randomUUID(), pid: null, cwd: config.cwd, journal: config.journal, config, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", sessions: previous?.sessions ?? [], resource_process: resourceProcess }; await writeState(paths.state, state);
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [options.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 60_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed" }); }
-  catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.state), state.daemon_id); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs); }
 

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

@@ -12,7 +12,7 @@ import path from "node:path";
 
 import { AcpBridge } from "./dd-zcode.mjs";
 import { cancelSessionWithBridge, createSessionWithBridge, doctor, forkSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge } from "./dd-grok.mjs";
-import { prepareRuntimeOwner, cleanupFailedStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 const REQUEST_SCHEMA = "dd-grok/daemon-request@1";
 const RESPONSE_SCHEMA = "dd-grok/daemon-response@1";
@@ -171,7 +171,7 @@ export async function startDaemon(options) {
   const state = { descendants: previous?.descendants ?? [], schema_id: STATE_SCHEMA, daemon_id: daemonId, pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config: { ...config, daemonId }, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
   await writeState(paths.state, state); const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [absolute(options.entryPath, "dd-grok entry"), "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(state.config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 30_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { const status = await callDaemon(paths.dir, "daemon.ready", {}, 5000); if (status.ready) return status; } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
-  catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), daemonId); throw error; }
 }
 export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs); }
 

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

@@ -5,7 +5,7 @@ import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "
 import net from "node:net";
 import { durableDaemonDispatch } from "./daemon-operations.mjs";
 import path from "node:path";
-import { prepareRuntimeOwner, cleanupFailedStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
 
 import {
   AcpBridge,
@@ -197,7 +197,7 @@ export async function startDaemon(options) {
   await log.close();
   try {
     await confirmDaemonProcess(config, resourceProcess, child);
-    const deadline = Date.now() + 15_000;
+    const deadline = Date.now() + 30_000;
     while (Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 100));
       try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); }
@@ -205,7 +205,7 @@ export async function startDaemon(options) {
     }
     throw new DaemonError("daemon_start_failed", "daemon did not become ready", true);
   } catch (error) {
-    await cleanupFailedStart(config, resourceProcess, child, error);
+    await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), state.daemon_id);
     throw error;
   }
 }

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

@@ -196,14 +196,17 @@ export async function startManagedBridge({ config, state, bridge, kind, publish
   state.pid = process.pid;
   await publish(state);
   const provider = config.runtime_owner ? await registerDaemonProcess(config, { kind, owner: config.runtime_owner.owner_id, operation: kind }) : null;
-  bridge.options.onSpawn = async child => {
-    await confirmDaemonProcess(config, provider, child);
-    await heartbeatDaemonProcess(config, provider);
-    state.provider_pid = child.pid;
+  try {
     state.provider_process = provider;
     await publish(state);
-  };
-  try { return await bridge.start(); }
+    bridge.options.onSpawn = async child => {
+      await confirmDaemonProcess(config, provider, child);
+      state.provider_pid = child.pid;
+      await publish(state);
+      await heartbeatDaemonProcess(config, provider);
+    };
+    return await bridge.start();
+  }
   catch (error) { await cleanupFailedStart(config, provider, bridge.child, error); throw error; }
 }
 
@@ -260,6 +263,25 @@ export async function cleanupFailedStart(config, record, child, original) {
   }
 }
 
+/** The provider has its own process group. A failed daemon start must settle
+ * that exact retained process as well as the daemon; PID-only cleanup is unsafe. */
+export async function cleanupFailedDaemonStart(config, daemonRecord, daemonChild, original, readState, daemonId) {
+  await cleanupFailedStart(config, daemonRecord, daemonChild, original);
+  if (!daemonRecord) return;
+  try {
+    const state = await readState();
+    const owner = config.runtime_owner;
+    if (!state || state.daemon_id !== daemonId || state.resource_process?.id !== daemonRecord.id || state.resource_process?.lease_token !== daemonRecord.lease_token
+      || (owner && (state.config?.runtime_owner?.owner_id !== owner.owner_id || path.resolve(state.config?.runtime_owner?.state_dir ?? "") !== path.resolve(owner.state_dir)))) {
+      throw Object.assign(new Error("Failed daemon state no longer matches the startup owner"), { code: "daemon_cleanup_identity_mismatch" });
+    }
+    const provider = state.provider_process;
+    if (provider) await runtimeProcess(config, "stop", { id: provider.id, "lease-token": provider.lease_token });
+  } catch (cleanup) {
+    original.details = { ...original.details, provider_cleanup_failed: errorRecord(cleanup) };
+  }
+}
+
 export async function stopProcessGroup(child, graceMs = 1_000) {
   if (!child?.pid) return;
   // Harness bridges are detached on Unix, so their own process group is the

package/dist/harness-runtime/lib/native-hook-command.d.mts

@@ -1 +1,3 @@
 export function invokeNativeHook(input: { bin: string; args: string[]; payload: unknown; home?: string | undefined; timeoutMs?: number }): Promise<Record<string, unknown> & { timing?: Record<string, number> }>;
+export function hookBudget(timeoutMs?: number, deadlineAt?: number | null): { remaining(phase: string): number };
+export function readNativeHookInput(stream: NodeJS.ReadStream, budget: { remaining(phase: string): number }, maxBytes?: number): Promise<string>;

package/package.json

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