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

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

@@ -1,11 +1,13 @@
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { admitNativeRequestBuffer, nativeObservationError } from "./native-streams.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, open, unlink, realpath } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import net from "node:net";
 import os from "node:os";
 import { DroidError, DroidRuntime, absolute, droidPaths, droidVersion, prepareDroidHome, readJson, removeDroidAuth, processSnapshot } from "./dd-droid.mjs";
-import { durableDaemonDispatch, inspectDaemonOperation, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
-import { observedTimeout } from "./observation-clock.mjs";
+import { durableDaemonDispatch, inspectDaemonOperation, settleDaemonOperation, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
+import { ObservationClock, validateObservationDuration } from "./observation-clock.mjs";
 import { writeJsonAtomic } from "./runner-events.mjs";
 import { errorRecord } from "./operation-errors.mjs";
 import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess } from "./managed-daemon.mjs";
@@ -13,25 +15,18 @@ import { prepareRuntimeOwner, cleanupFailedStart, confirmDaemonProcess, confirmD
 const REQUEST = "dd-droid/daemon-request@1", RESPONSE = "dd-droid/daemon-response@1";
 async function removeSocket(file) { try { if (!(await lstat(file)).isSocket()) throw new DroidError("unsafe_socket", "Refusing to replace non-socket daemon path"); await unlink(file); } catch (error) { if (error.code !== "ENOENT") throw error; } }
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000, operationId = process.env.DD_EVAL_OPERATION_ID ?? randomUUID()) {
-  const paths = droidPaths(stateDir), request = { schema_id: REQUEST, id: operationId, operation, params };
-  return await new Promise((resolve, reject) => {
-    const client = net.createConnection(paths.socket); let buffer = "", settled = false;
-    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); client.destroy(); error ? reject(error) : resolve(value); };
-    const timer = operation === "session.prompt" ? null : observedTimeout(() => finish(new DroidError("daemon_timeout", `${operation} response was not observed`, { operation_id: operationId })), timeoutMs);
-    client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`));
-    client.on("error", error => finish(new DroidError("daemon_not_running", error.message)));
-    client.on("end", () => finish(new DroidError("daemon_connection_closed", "Droid daemon closed the connection before its reply")));
-    client.on("close", () => finish(new DroidError("daemon_connection_closed", "Droid daemon connection closed")));
-    client.on("data", chunk => { buffer += chunk; const index = buffer.indexOf("\n"); if (index < 0) return; try { const response = JSON.parse(buffer.slice(0, index)); if (response.schema_id !== RESPONSE || response.id !== operationId) throw new DroidError("daemon_protocol", "Droid daemon returned an unrelated response"); response.ok ? finish(null, response.result) : finish(Object.assign(new Error(response.error.message), response.error)); } catch (error) { finish(error); } });
-  });
+  const request = { schema_id: REQUEST, id: operationId, operation, params };
+  return await callDaemonObserved({ stateDir, socket: droidPaths(stateDir).socket, request, responseSchema: RESPONSE, harness: 'droid', timeoutMs });
 }
-function sameConfig(a, b) { return ["cwd", "bin", "model", "reasoning", "mode", "provider", "ddFlowBin", "ddFlowHome", "resourceHome", "projectRoot", "noFlow"].every(key => a?.[key] === b[key]); }
+function sameConfig(a, b) { return ["cwd", "bin", "model", "reasoning", "mode", "provider", "ddFlowBin", "ddFlowHome", "resourceHome", "projectRoot", "noFlow","inactivityMs"].every(key => a?.[key] === b[key]); }
 export async function startDaemon(options) {
   const paths = droidPaths(options.stateDir), noFlow = options.noFlow === true || (!options.ddFlowBin && !options.ddFlowHome);
   const config = { stateDir: paths.dir, home: paths.home, bin: options.bin ?? process.env.DD_DROID_BIN ?? "droid", cwd: absolute(options.cwd, "--cwd"), projectRoot: absolute(options.projectRoot ?? options.cwd, "--project-root"), journal: absolute(options.journal ?? `${paths.dir}/events.jsonl`, "--journal"), entryPath: absolute(options.entryPath, "adapter entry"), authHome: absolute(options.authHome ?? os.homedir(), "auth home"), model: options.model ?? "gpt-5.6-sol", reasoning: options.reasoning ?? "high", mode: options.mode ?? "auto-high", provider: options.provider ?? "openai", noFlow, ddFlowBin: noFlow ? null : absolute(options.ddFlowBin, "--dd-flow-bin"), ddFlowHome: noFlow ? null : absolute(options.ddFlowHome, "--dd-flow-home"), resourceHome: noFlow ? null : process.env.DD_FLOW_RESOURCE_HOME ?? null, inactivityMs: options.timeoutMs ?? 600_000 };
   await prepareRuntimeOwner(config, paths.dir);
   config.cwd = await realpath(config.cwd); config.projectRoot = await realpath(config.projectRoot);
   if (config.mode !== "auto-high") throw new DroidError("droid_mode_unsupported", "The qualified Droid profile requires auto-high");
+  config.inactivityMs = options.livenessTimeoutMs ?? options.timeoutMs ?? 600_000;
+  validateObservationDuration(config.inactivityMs);
   await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
   let previous = await readJson(paths.state); assertDaemonRestartable(previous);
   try { const live = await callDaemon(paths.dir, "daemon.status", {}, 1_000); if (!sameConfig(live.config, config)) throw new DroidError("daemon_config_mismatch", "Droid daemon already uses another configuration"); return { ...live, already_running: true }; } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; }
@@ -49,8 +44,8 @@ export async function startDaemon(options) {
   const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [config.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, resource, child);
-    const deadline = Date.now() + 30_000;
-    while (Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 100)); const saved = await readJson(paths.state); if (saved?.startup_error) throw Object.assign(new Error(saved.startup_error.message), saved.startup_error); try { return await callDaemon(paths.dir, "daemon.status", {}, 1_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } }
+    const startupClock = new ObservationClock({ timeoutMs: 30_000 });
+    while (!startupClock.sample()) { await new Promise(resolve => setTimeout(resolve, 100)); const saved = await readJson(paths.state); if (saved?.startup_error) throw Object.assign(new Error(saved.startup_error.message), saved.startup_error); try { return await callDaemon(paths.dir, "daemon.status", {}, 1_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } }
     throw new DroidError("daemon_start_failed", "Droid daemon did not become ready");
   } catch (error) { await cleanupFailedStart(config, resource, child, error); throw error; }
 }
@@ -97,15 +92,15 @@ export async function serveDaemon(stateDir) {
       assertDaemonDispatch(paths.dir);
       if (operation === "session.create") { if (params.prompt) throw new DroidError("invalid_create", "create does not execute a prompt"); return await runtime.create(request.id); }
       if (operation === "session.resume") return await runtime.resume(params.sessionId);
-      if (["session.prompt", "session.start"].includes(operation)) return await runtime.prompt(params.sessionId, params.prompt, request.id);
+      if (["session.prompt", "session.start"].includes(operation)) return await runtime.prompt(params.sessionId, params.prompt, request.id, params.livenessTimeoutMs ?? runtime.config.inactivityMs);
       throw new DroidError("unknown_operation", `Unknown Droid operation: ${operation}`);
     } finally { busy = null; await save({ active_operation: null }); }
   };
   await removeSocket(paths.socket);
-  const server = net.createServer(socket => { socket.setEncoding("utf8"); let buffer = "", consumed = false; socket.on("error", () => {}); socket.on("data", chunk => { if (consumed) return; buffer += chunk; const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
+  const server = net.createServer(socket => { socket.setEncoding("utf8"); let buffer = "", consumed = false; socket.on("error", () => {}); socket.on("data", chunk => { if (consumed) return; buffer += chunk; if (!admitNativeRequestBuffer(buffer, socket, RESPONSE)) { consumed = true; return; } const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
     void (async () => { let request; try { request = JSON.parse(buffer.slice(0, at)); if (request.schema_id !== REQUEST || typeof request.id !== "string" || typeof request.operation !== "string") throw new DroidError("daemon_protocol", "Malformed Droid daemon request"); let result;
       if (request.operation === "operation.inspect") {
-        result = await inspectDaemonOperation(paths.dir, request.params?.operationId);
+        result = request.params?.settle === true ? await settleDaemonOperation(paths.dir, request.params?.operationId) : await inspectDaemonOperation(paths.dir, request.params?.operationId);
         if (!["completed", "failed"].includes(result.state)) {
           const recovered = await runtime.recoverOperation(request.params.operationId);
           if (recovered) {

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

@@ -4,22 +4,23 @@ export { processSnapshot } from "./process-snapshot.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { appendFile, chmod, copyFile, mkdir, readFile, readdir, realpath, stat, unlink, writeFile } from "node:fs/promises";
-import { spawn, execFile } from "node:child_process";
-import { promisify } from "node:util";
+import { spawn } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
-import { ObservationClock, observedTimeout } from "./observation-clock.mjs";
+import { ObservationClock, observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
+import { operationProgressReporter } from "./operation-progress.mjs";
 import { writeJsonAtomic } from "./runner-events.mjs";
-import { errorRecord, reportedError } from "./operation-errors.mjs";
+import { errorRecord, reportedError, isObservationLoss } from "./operation-errors.mjs";
 import { hookBudget, invokeNativeHook } from "./native-hook-command.mjs";
 import { checkObservedProfile, observeModel } from "./model-observations.mjs";
+import { readNativeLines, streamNativeDiagnostics, nativeObservationError } from "./native-streams.mjs";
+import { commandText } from "./process-json.mjs";
 import { DroidMetadataReader, readDroidRoutingLog } from "./droid-observation.mjs";
 const metadataReaders = new Map();
 function metadataReader(factory) { if (!metadataReaders.has(factory)) metadataReaders.set(factory, new DroidMetadataReader(factory)); return metadataReaders.get(factory); }
 import { confirmDaemonProcess, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
 import { renderAdapterPolicy, lifecycleRetryInstruction } from "./delegation-instructions.mjs";
 
-const run = promisify(execFile);
 export const DROID_CONTRACT = "dd-droid-harness@1";
 export const DROID_PROTOCOL = "1.201.0";
 const LATE_RESPONSE_GRACE_MS = 5_000;
@@ -41,7 +42,8 @@ export function droidPaths(stateDir) {
 export function droidEnvironment(config) {
   const env = { ...process.env, FACTORY_HOME_OVERRIDE: config.home, FACTORY_DROID_AUTO_UPDATE_ENABLED: "false", ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome, DD_FLOW_BIN: config.ddFlowBin } : {}) };
   // This adapter deliberately uses the operator's existing Factory login.
-  for (const key of Object.keys(env)) if (key.endsWith("API_KEY")) delete env[key];
+  // Undefined is a tombstone: downstream env overlays must not resurrect keys.
+  for (const key of Object.keys(env)) if (key.endsWith("API_KEY")) env[key] = undefined;
   return env;
 }
 export async function prepareDroidHome(config) {
@@ -63,7 +65,7 @@ export async function prepareDroidHome(config) {
 export async function removeDroidAuth(config) {
   for (const name of ["auth.encrypted", "auth.v2.key", "auth.v2.file", "auth.json"]) await unlink(path.join(config.home, ".factory", name)).catch(error => { if (error.code !== "ENOENT") throw error; });
 }
-export async function droidVersion(bin) { const target = executable(bin, ["--version"]); return (await run(target.command, target.args, { timeout: 10_000 })).stdout.trim(); }
+export async function droidVersion(bin) { const target = executable(bin, ["--version"]); return await commandText(target.command, target.args, { timeoutMs: 10_000, phase: "native-version" }); }
 
 /** The qualified OpenAI profile reports uncached input separately from caches;
  * output already includes thinking. Keep native counters alongside normalization. */
@@ -101,7 +103,7 @@ export class DroidRuntime {
     this.config = config; this.state = state; this.paths = droidPaths(config.stateDir); this.persist = persist; this.pending = new Map(); this.lateResponses = new Map(); this.active = null; this.child = null; this.closed = true; this.loaded = false; this.ownedProcesses = state.owned_processes ?? []; this.closing = false; this.workingState = "idle"; this.protocol = null; this.rootId = state.root_session_id ?? null; this.topology = new Map(state.descendants?.map(child => [child.provider_session_id, child]) ?? []); this.draining = Promise.resolve(); this.journalling = Promise.resolve(); this.activity = 0; this.providerProcess = null; this.cancelled = false; this.lastResult = state.last_result ?? null; this.metadata = metadataReader(this.paths.factory); this.fatalError = state.fatal_error ? reportedError(state.fatal_error) : null;
   }
   async journal(kind, payload) { const line = JSON.stringify({ schema_id: "dd-droid/event@1", observed_at: new Date().toISOString(), kind, ...payload }); this.journalling = this.journalling.then(() => appendFile(this.config.journal, `${line}\n`, { mode: 0o600 })); return await this.journalling; }
-  async save(patch = {}) { return await this.persist({ root_session_id: this.rootId, descendants: [...this.topology.values()], working_state: this.workingState, last_activity: this.activity, ...patch }); }
+  async save(patch = {}) { return await this.persist({ root_session_id: this.rootId, sessions: this.rootId ? [this.rootId] : [], descendants: [...this.topology.values()], working_state: this.workingState, last_activity: this.activity, ...patch }); }
   async start() {
     if (this.child && !this.closed) return;
     this.closed = false; this.loaded = false; this.closing = false; this.protocol = null; this.buffer = "";
@@ -109,10 +111,14 @@ export class DroidRuntime {
     const target = executable(this.config.bin, args);
     this.providerProcess = await registerDaemonProcess(this.config, { kind: "droid-provider", owner: `droid:${this.config.daemonId}`, operation: `droid-provider:${randomUUID()}`, stdout: this.paths.log, stderr: this.paths.log });
     this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: droidEnvironment(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] });
-    this.child.stdout.setEncoding("utf8").on("data", chunk => { this.buffer += chunk; let at; while ((at = this.buffer.indexOf("\n")) >= 0) { const line = this.buffer.slice(0, at); this.buffer = this.buffer.slice(at + 1); this.draining = this.draining.then(async () => { if (!line.trim()) return; await this.event(JSON.parse(line)); }).catch(async error => { await this.handleObservationError(error); if (!this.fatalError) this.rejectPending(error); }); } });
-    this.child.stderr.setEncoding("utf8").on("data", chunk => { void this.journal("stderr", { text: chunk.slice(0, 4000) }).catch(() => {}); });
+    const observationFailure = async error => {
+      if (error.code === "operation_observation_lost") { this.observationError = error; this.rejectPending(error); return; }
+      await this.handleObservationError(error); if (!this.fatalError) this.rejectPending(error);
+    };
+    this.nativeDrain = readNativeLines(this.child.stdout, line => this.draining = this.event(JSON.parse(line)), observationFailure);
+    this.diagnostics = streamNativeDiagnostics(this.child.stderr, chunk => this.journal("stderr", { text: chunk }), observationFailure);
     this.child.on("error", error => this.rejectPending(error));
-    this.child.on("close", (code, signal) => { this.closed = true; void this.draining.finally(() => { const error = new DroidError("operation_observation_lost", "Droid process exited before a confirmed reply", { code, signal }); this.rejectPending(error); }); });
+    this.child.on("close", (code, signal) => { this.closed = true; void Promise.all([this.nativeDrain, this.diagnostics]).finally(() => { const error = new DroidError("operation_observation_lost", "Droid process exited before a confirmed reply", { code, signal }); this.rejectPending(error); }); });
     await this.captureProcesses(); await confirmDaemonProcess(this.config, this.providerProcess, this.child); scheduleDaemonProcessHeartbeat(this.config, this.providerProcess); await this.save({ provider_pid: this.child.pid, provider_process: this.providerProcess });
     clearInterval(this.processObserver);
     this.processObserver = setInterval(() => { if (!this.processObservation) this.processObservation = this.captureProcesses().catch(error => { this.ownershipError = error; }).finally(() => { this.processObservation = null; }); }, 1_000);
@@ -145,22 +151,59 @@ export class DroidRuntime {
     if (event.method !== "droid.session_notification") return;
     const { sessionId, notification: n } = event.params ?? {}; if (!n) return;
     const fingerprint = createHash("sha256").update(JSON.stringify(event.params)).digest("hex");
-    if (fingerprint !== this.lastEvent) { this.activity += 1; this.lastEvent = fingerprint; }
     if (sessionId && this.rootId && sessionId !== this.rootId && !this.topology.has(sessionId)) throw new DroidError("session_identity_mismatch", "Unrelated native Session notification");
+    const current = this.active;
+    const scoped = current && sessionId && (sessionId === this.rootId || this.topology.get(sessionId)?.operation_id === current.operationId)
+      && (!n.turnId || n.turnId === current.turnId) && (!n.requestId || n.requestId === current.requestId);
+    let productive = ["assistant_text_delta", "assistant_thought_delta"].includes(n.type) && Boolean(n.textDelta ?? n.thoughtDelta)
+      || ["agent_turn_completed", "create_message"].includes(n.type);
+    if (scoped && ["agent_turn_completed", "create_message"].includes(n.type)) {
+      current.lifecycleProgress ??= new Set();
+      const key = JSON.stringify([sessionId, n.type, n.requestId ?? null, n.turnId ?? null, n.message?.id ?? null]);
+      if (current.lifecycleProgress.has(key)) productive = false;
+      else {
+        if (current.lifecycleProgress.size >= 1_024) current.lifecycleProgress.delete(current.lifecycleProgress.values().next().value);
+        current.lifecycleProgress.add(key);
+      }
+    }
+    if (scoped && ["tool_call_started", "tool_call_update", "tool_call_completed"].includes(n.type)) {
+      const toolId = n.toolUseId ?? n.toolCallId ?? n.toolCall?.id;
+      current.toolProgress ??= new Set();
+      const key = `${sessionId}:${toolId}`, semantic = JSON.stringify({ type: n.type, toolCall: n.toolCall, status: n.status, input: n.input, output: n.output, content: n.content, error: n.error });
+      // Keep fixed-size fingerprints, not 1,024 copies of growing tool output.
+      const snapshot = createHash("sha256").update(JSON.stringify([key, semantic])).digest("hex");
+      if (toolId && !current.toolProgress.has(snapshot)) {
+        productive = n.type !== "tool_call_update" || n.status !== undefined || n.output !== undefined || n.content !== undefined || n.toolCall !== undefined || n.error !== undefined;
+        if (productive) {
+          // ponytail: retain the latest 1,024 snapshots for replay detection,
+          // not a lifetime progress quota. Native sequence IDs can extend proof.
+          if (current.toolProgress.size >= 1_024) current.toolProgress.delete(current.toolProgress.values().next().value);
+          current.toolProgress.add(snapshot);
+        }
+      }
+    }
+    if (scoped && productive) {
+      this.activity += 1; this.progress = { cursor: this.activity, observed_at: Date.now() };
+      const pending = this.pending.get(current.requestId);
+      if (pending?.method === "droid.add_user_message") {
+        pending.progress = this.progress;
+      }
+      await current.publish?.("native_progress", { native_request_id: String(current.requestId), session_id: this.rootId, observed_at: new Date(this.progress.observed_at).toISOString() });
+    }
     if (n.type === "droid_working_state_changed" && (!sessionId || sessionId === this.rootId)) this.workingState = n.newState;
     if (n.type === "child_session_available") {
       if (!this.rootId || sessionId !== this.rootId || !n.childSessionId || !n.toolUseId) throw new DroidError("droid_child_identity_invalid", "Native child event lacks physical parent or tool identity");
-      this.topology.set(n.childSessionId, { provider_session_id: n.childSessionId, parent_provider_session_id: sessionId, tool_use_id: n.toolUseId, status: "running", source: "droid.child_session_available" }); await this.save();
+      this.topology.set(n.childSessionId, { provider_session_id: n.childSessionId, parent_provider_session_id: sessionId, tool_use_id: n.toolUseId, operation_id: current?.operationId ?? null, status: "running", source: "droid.child_session_available" }); await this.save();
     }
     if (n.type === "settings_updated" && this.loaded) await this.observeSettings(sessionId ?? this.rootId, n.settings, { kind: "native.settings_updated", event_sha256: fingerprint });
-    const current = this.active;
     if (n.type === "create_message" && n.requestId === current?.requestId) {
       if (n.message?.id !== current.turnId) throw new DroidError("droid_turn_identity_mismatch", "Droid did not preserve the requested message ID");
       current.accepted = true; await this.saveBinding(current, { accepted: true });
     }
-    if (n.type === "assistant_text_delta" && current) current.text += n.textDelta ?? "";
+    if (n.type === "assistant_text_delta" && scoped && sessionId === this.rootId) current.text += n.textDelta ?? "";
     if (n.type === "agent_turn_completed" && current && n.turnId === current.turnId && (!sessionId || sessionId === this.rootId)) {
       current.outcome = n; this.lastResult = n; await this.saveBinding(current, { native_outcome: n, assistant_text: current.text }); current.resolve(n);
+      if (current.observerReturned && this.active === current) { this.active = null; await this.save({ active_tree: this.workingState !== "idle" }); }
     }
   }
   request(method, params, id = randomUUID(), timeoutMs = 30_000) {
@@ -171,11 +214,11 @@ export class DroidRuntime {
         pending.timedOut = true;
         const timeoutError = new DroidError("rpc_timeout", `${method} has no observed reply`, { request_id: id, timeout_ms: timeoutMs, grace_ms: LATE_RESPONSE_GRACE_MS });
         void this.journal("request_deadline", { method, request_id: id, timeout_ms: timeoutMs, grace_ms: LATE_RESPONSE_GRACE_MS });
-        pending.timer = observedTimeout(() => { if (this.pending.get(id) !== pending) return; this.pending.delete(id); reject(timeoutError); }, LATE_RESPONSE_GRACE_MS);
-      }, timeoutMs);
+        pending.timer = observedTimeout(() => { if (this.pending.get(id) !== pending) return; this.pending.delete(id); reject(timeoutError); }, LATE_RESPONSE_GRACE_MS, { progress: () => pending.progress });
+      }, timeoutMs, { progress: () => this.pending.get(id)?.progress });
       this.pending.set(id, { resolve, reject, timer, method });
-      try { this.send({ jsonrpc: "2.0", type: "request", factoryApiVersion: "1.0.0", factoryProtocolVersion: DROID_PROTOCOL, id, method, params }, error => { if (error) { clearTimeout(timer); this.pending.delete(id); reject(error); } }); }
-      catch (error) { clearTimeout(timer); this.pending.delete(id); reject(error); }
+      try { this.send({ jsonrpc: "2.0", type: "request", factoryApiVersion: "1.0.0", factoryProtocolVersion: DROID_PROTOCOL, id, method, params }, error => { if (error) { clearTimeout(timer); this.pending.delete(id); reject(nativeObservationError(error)); } }); }
+      catch (error) { clearTimeout(timer); this.pending.delete(id); reject(nativeObservationError(error)); }
     });
   }
   send(value, callback) {
@@ -186,7 +229,7 @@ export class DroidRuntime {
       throw error;
     }
     try { stdin.write(`${JSON.stringify(value)}\n`, callback); }
-    catch (error) { this.rejectPending(error); throw error; }
+    catch (cause) { const error = nativeObservationError(cause); this.rejectPending(error); throw error; }
   }
   profile(settings) {
     const model = settings?.modelId ?? settings?.model ?? null;
@@ -244,7 +287,12 @@ export class DroidRuntime {
     }
   }
   async handleObservationError(error) {
-    if (["profile_integrity_violation", "session_identity_mismatch", "droid_child_identity_invalid", "droid_turn_identity_mismatch", "droid_hook_identity_invalid", "model_observation_storage_failed"].includes(error.code)) {
+    if (error.code === "model_observation_storage_failed") {
+      this.observationError = Object.assign(new Error("Droid model observation could not be published", { cause: error }), { code: "operation_observation_lost", details: { native_outcome: "unknown", observation_error: errorRecord(error) } });
+      this.rejectPending(this.observationError);
+      return;
+    }
+    if (["profile_integrity_violation", "session_identity_mismatch", "droid_child_identity_invalid", "droid_turn_identity_mismatch", "droid_hook_identity_invalid"].includes(error.code)) {
       if (!this.fatalError) {
         this.fatalError = error;
         try { await this.save({ fatal_error: errorRecord(error) }); await this.journal("integrity_failure", { error: errorRecord(error) }); }
@@ -276,7 +324,8 @@ export class DroidRuntime {
     const source = await readDroidSession(this.paths.factory, id); if (!source || path.resolve(source.header.cwd) !== this.config.cwd) throw new DroidError("session_identity_mismatch", "Resumed Session does not match its controlled workspace");
     this.loaded = true; this.observedProfile = await this.observeSettings(id, result.settings, "native.load_session"); this.workingState = result.workingState ?? (result.isAgentLoopInProgress ? "unknown" : "idle"); this.cancelled = false; await this.save(); return await this.inspect(id);
   }
-  async prompt(id, prompt, operationId) {
+  async prompt(id, prompt, operationId, livenessTimeoutMs = this.config.inactivityMs ?? 600_000) {
+    validateObservationDuration(livenessTimeoutMs);
     const assertDispatch = captureDispatchGuard(this);
     if (this.fatalError) throw this.fatalError;
     this.requireIdentity(id); if (!prompt) throw new DroidError("prompt_required", "prompt is required"); if (this.active) throw new DroidError("operation_busy", "Another Droid operation is active");
@@ -285,20 +334,31 @@ export class DroidRuntime {
     const before = await this.inspect(id); if (!before.settled) throw new DroidError("tree_not_settled", "Prior Droid tree has not settled");
     let resolve, reject; const completed = new Promise((a, b) => { resolve = a; reject = b; }); void completed.catch(() => {});
     const requestId = randomUUID(), turnId = randomUUID();
-    const current = { operationId, requestId, turnId, resolve, reject, text: "", saved: { operation: "session.prompt", provider_session_id: id, request_id: requestId, turn_id: turnId, accepted: false } };
+    const current = { operationId, requestId, turnId, resolve, reject, text: "", publish: operationProgressReporter(), saved: { operation: "session.prompt", provider_session_id: id, request_id: requestId, turn_id: turnId, accepted: false } };
     this.active = current; this.cancelled = false; await this.saveBinding(current); await this.save({ active_tree: true });
-    const clock = new ObservationClock({ timeoutMs: this.config.inactivityMs ?? 600_000, onGap: gap => { void this.journal("observation_gap", { gap }).catch(() => {}); } });
+    const clock = new ObservationClock({ timeoutMs: livenessTimeoutMs, onGap: gap => { void this.journal("observation_gap", { gap }).catch(() => {}); } });
     let checkingTerminal = false;
     const timer = setInterval(() => {
-      if (!clock.sample(this.activity) || checkingTerminal) return;
+      if (checkingTerminal || !clock.sample(this.progress)) return;
       checkingTerminal = true;
+      const cursor = this.progress?.cursor;
       void this.recoverOperation(operationId).then(() => {
-        if (!current.outcome) reject(new DroidError("subject_liveness_timeout", "Droid emitted no native progress within its inactivity window"));
-      }).catch(error => reject(new DroidError("operation_observation_lost", "Cannot reconcile native outcome before declaring inactivity", { error: errorRecord(error) })));
-    }, 1_000);
+        if (this.active === current && !current.outcome && this.progress?.cursor === cursor && clock.sample(this.progress)) reject(new DroidError("operation_observation_lost", "Droid native outcome remains unknown after its silence window", { operation_id: operationId, native_outcome: "unknown" }));
+      }).catch(error => reject(new DroidError("operation_observation_lost", "Cannot reconcile native outcome before declaring inactivity", { error: errorRecord(error) }))).finally(() => { checkingTerminal = false; });
+    }, Math.max(10, Math.min(1_000, livenessTimeoutMs / 4)));
+    let primary;
     try {
       assertDispatch();
+      current.dispatched = true;
       await this.request("droid.add_user_message", { text: prompt, messageId: turnId }, requestId);
+      try { await this.journal("native_dispatch", { operation_id: operationId, provider_session_id: id, native_request_id: requestId }); }
+      catch (cause) {
+        const error = nativeObservationError(cause);
+        if (!current.outcome || error.code !== "operation_observation_lost") throw error;
+        throw Object.assign(new Error("Droid completed natively but its dispatch journal could not be saved", { cause }), {
+          code: "native_outcome_observation_failed", details: { native_outcome: { provider_session_id: id, turn_id: turnId, result: current.outcome }, settled: false, observation_error: errorRecord(error) }
+        });
+      }
       const outcome = await completed; await this.draining;
       try {
         const receipt = await this.inspect(id, { ignoreActive: true });
@@ -310,8 +370,22 @@ export class DroidRuntime {
         return { provider_session_id: id, adapter_session_id: id, result: { ...outcome, status: status(outcome.reason) }, assistant_text: current.text, turn_id: turnId, settled: false, settlement_observation_error: errorRecord(error) };
       }
     } catch (error) {
-      await this.journal("prompt_error", { operation_id: operationId, error: errorRecord(error) }); throw error;
-    } finally { clearInterval(timer); if (this.active === current) this.active = null; await this.save({ active_tree: this.workingState !== "idle" }); }
+      if (current.outcome && isObservationLoss(error)) error = Object.assign(new Error("Droid completed natively but its dispatch acknowledgement was lost", { cause: error }), {
+        code: "native_outcome_observation_failed", details: { native_outcome: { provider_session_id: id, turn_id: turnId, result: current.outcome }, settled: false, observation_error: errorRecord(error) }
+      });
+      primary = error;
+      try { await this.journal("prompt_error", { operation_id: operationId, error: errorRecord(error) }); }
+      catch (publication) { error.cleanup_error ??= errorRecord(publication); }
+      throw error;
+    } finally {
+      clearInterval(timer); current.observerReturned = true;
+      if (this.active === current && (current.outcome || !current.dispatched)) this.active = null;
+      try { await this.save({ active_tree: Boolean(this.active) || this.workingState !== "idle" }); }
+      catch (publication) {
+        if (primary) primary.cleanup_error ??= errorRecord(publication);
+        else throw Object.assign(new Error("Droid outcome bookkeeping could not be published", { cause: publication }), { code: current.outcome ? "native_outcome_observation_failed" : "operation_observation_lost", details: { native_outcome: current.outcome ?? "unknown", observation_error: errorRecord(publication) } });
+      }
+    }
   }
   async recoverOperation(operationId) {
     const binding = await readJson(path.join(this.paths.bindings, `${createHash("sha256").update(operationId).digest("hex")}.json`));
@@ -332,6 +406,11 @@ export class DroidRuntime {
       current.outcome = outcome; this.lastResult = outcome;
       await this.saveBinding(current, { native_outcome: outcome });
       current.resolve(outcome);
+      if (current.observerReturned) {
+        if (this.active === current) this.active = null;
+        await this.save({ active_tree: this.workingState !== "idle" });
+        return { ...receipt, result: { ...outcome, status: status(outcome.reason) }, assistant_text: binding.assistant_text ?? "", turn_id: binding.turn_id, recovered_from: "native.agent_turn_outcome" };
+      }
       // Let the original dispatch persist its one terminal reply. Settlement
       // is reconciled separately; do not race a second writer or replay it.
       return null;
@@ -420,10 +499,17 @@ export class DroidRuntime {
     try {
       return await this.flow("event", "handle", { schema_id: "dd-flow/droid-tool-event@1", phase: event === "PreToolUse" ? "before" : "after", event_id: eventId, daemon_id: this.config.daemonId, session: { provider_session_id: id, parent_provider_session_id: parent, directory: this.config.cwd }, tool: payload.tool_name, input: payload.tool_input, profile, transcript_path: native.transcript_path, outcome: { status: payload.tool_response?.is_error ? "error" : "completed" } }, budget.remaining("admission", 15_000));
     } catch (error) {
+      const details = error.details;
+      if (event === "PreToolUse" && error.code === "lifecycle_shell_syntax_invalid" && details?.phase === "prepare" && details.effect === "no_effect" && details.recoverable === true && details.disposition === "pre_cli_shell_refusal" && (details.refusal_event_key || details.event_key)) {
+        const refusal = errorRecord(error);
+        await this.journal("hook_rejected", { error: refusal, event_id: eventId, session_id: id });
+        await this.save();
+        return { continue: false, stopReason: error.message };
+      }
       // Identity is proven above; only this owned admission can fail its turn.
       this.fatalError ??= Object.assign(error, { details: { ...error.details, provider_session_id: id, event_id: eventId, effect: "unknown" } });
       this.rejectPending(this.fatalError);
-      try { await this.save({ fatal_error: errorRecord(this.fatalError) }); await this.journal("hook_rejected", { error: errorRecord(this.fatalError) }); }
+      try { await budget.run(async () => { await this.save({ fatal_error: errorRecord(this.fatalError) }); await this.journal("hook_rejected", { error: errorRecord(this.fatalError) }); }, "failure_persistence"); }
       catch (storage) { this.fatalError.details.receipt_error = errorRecord(storage); }
       throw this.fatalError;
     }

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

@@ -1,6 +1,12 @@
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { canonicalNativeOperation } from './adapter-timeouts.mjs';
+import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
+import { errorRecord, isProvenShellCorrection } from "./operation-errors.mjs";
 import { ToolObservations, acpToolObservation } from "./tool-observations.mjs";
-import { observedTimeout } from "./observation-clock.mjs";
+import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
+import { parseLifecycleCommand, continuationCommand } from "./lifecycle-command.mjs";
+import { ObservationClock } from "./observation-clock.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
@@ -20,7 +26,7 @@ const RESPONSE_SCHEMA = "dd-grok/daemon-response@1";
 const STATE_SCHEMA = "dd-grok/daemon-state@1";
 // Normalize raw socket callers too, before the shared layer reserves capacity.
 export function durableDaemonDispatch(root, request, action, observe) {
-  return dispatchOperation(root, request.operation === "session.resume" ? { ...request, operation: "session.inspect" } : request, action, observe);
+  return dispatchOperation(root, { ...request, operation: canonicalNativeOperation("grok", request.operation) }, action, observe);
 }
 class DaemonError extends Error { constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; } }
 function absolute(value, label) { if (!value || !path.isAbsolute(value)) throw new DaemonError("invalid_path", `${label} must be an absolute path`); return path.resolve(value); }
@@ -28,11 +34,11 @@ function locations(stateDir) { const dir = absolute(stateDir, "--state-dir"); co
 async function readState(dir) { try { return JSON.parse(await readFile(locations(dir).state, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
 async function writeState(file, value) { const temporary = `${file}.${process.pid}.tmp`; await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 }); await rename(temporary, file); }
 async function removeSocket(socket, dir) { if (socket !== locations(dir).socket) throw new DaemonError("unsafe_socket", "daemon socket does not match its state directory"); try { const info = await lstat(socket); if (!info.isSocket()) throw new DaemonError("unsafe_socket", "refusing to remove a non-socket daemon path"); await unlink(socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
-function errorPayload(error) { return { code: error.code ?? "operation_failed", message: error.message ?? String(error), retryable: error.retryable === true, ...(error.details === undefined ? {} : { details: error.details }) }; }
+const errorPayload = errorRecord;
 function shellQuote(value) { return `'${String(value).replace(/'/g, "'\\''")}'`; }
 
 function executable(command, args = []) { const resolved = command ?? process.env.DD_GROK_BIN ?? "grok"; return /\.[cm]?js$/.test(resolved) ? { command: process.execPath, args: [resolved, ...args] } : { command: resolved, args }; }
-export function isolatedEnv(config) { const env = { ...process.env, HOME: config.grokHome, GROK_HOME: config.grokHome, ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome } : {}), ...(config.resourceHome ? { DD_FLOW_RESOURCE_HOME: config.resourceHome } : {}), ...(config.authPath ? { GROK_AUTH_PATH: config.authPath } : {}) }; delete env.DD_FLOW_DAEMON_ID; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
+export function isolatedEnv(config) { const env = { ...process.env, HOME: config.grokHome, GROK_HOME: config.grokHome, ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome } : {}), ...(config.resourceHome ? { DD_FLOW_RESOURCE_HOME: config.resourceHome } : {}), ...(config.authPath ? { GROK_AUTH_PATH: config.authPath } : {}) }; env.DD_FLOW_DAEMON_ID = undefined; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
 function within(candidate, root) { const resolved = path.resolve(candidate); const parent = path.resolve(root); return resolved === parent || resolved.startsWith(`${parent}${path.sep}`); }
 
 async function writeIsolatedConfig(paths) {
@@ -42,11 +48,7 @@ async function writeIsolatedConfig(paths) {
 
 async function inspectIsolatedConfig(config) {
   const target = executable(config.bin, ["inspect", "--json"]);
-  const raw = await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { cwd: config.cwd, env: isolatedEnv(config), stdio: ["ignore", "pipe", "pipe"] }); let stdout = ""; let stderr = "";
-    child.stdout.setEncoding("utf8").on("data", (chunk) => (stdout += chunk)); child.stderr.setEncoding("utf8").on("data", (chunk) => (stderr += chunk));
-    child.on("error", reject); child.on("close", (code) => code === 0 ? resolve(stdout) : reject(new DaemonError("grok_inspect_failed", stderr.trim() || `${target.command} exited ${code}`)));
-  });
+  const raw = await commandText(target.command, target.args, { cwd: config.cwd, env: isolatedEnv(config), phase: "native-inspect" });
   let report; try { report = JSON.parse(raw); } catch (error) { throw new DaemonError("grok_inspect_invalid", `grok inspect did not return JSON: ${error.message}`); }
   const foreign = [];
   const checkSource = (kind, value, roots) => { const candidate = value?.source?.path ?? value?.path ?? value?.filePath; if (candidate && !roots.some((root) => within(candidate, root))) foreign.push({ kind, path: candidate }); };
@@ -147,15 +149,9 @@ async function materializeSessionArchive(paths, archiveDir) {
 }
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
-  // Grok resume observes an already-owned Session; it never starts a turn.
-  if (operation === "session.resume") operation = "session.inspect";
-  const { socket } = locations(stateDir); const request = { schema_id: REQUEST_SCHEMA, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
-  return await new Promise((resolve, reject) => {
-    const client = net.createConnection(socket); let buffer = ""; let settled = false;
-    const timer = operation === "session.prompt" ? null : observedTimeout(() => finish(new DaemonError("daemon_timeout", `${operation} timed out`, true)), timeoutMs);
-    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); client.destroy(); error ? reject(error) : resolve(value); };
-    client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`)); client.on("data", (chunk) => { buffer += chunk; const newline = buffer.indexOf("\n"); if (newline < 0) return; try { const response = JSON.parse(buffer.slice(0, newline)); if (response.schema_id !== RESPONSE_SCHEMA || response.id !== request.id) return finish(new DaemonError("daemon_protocol_mismatch", "invalid daemon response")); if (!response.ok) return finish(new DaemonError(response.error?.code ?? "operation_failed", response.error?.message ?? "daemon operation failed", response.error?.retryable, response.error?.details)); finish(null, response.result); } catch (error) { finish(new DaemonError("daemon_protocol_mismatch", error.message)); } }); client.on("error", (error) => finish(new DaemonError("daemon_not_running", error.message, true))); client.on("end", () => finish(new DaemonError("daemon_connection_closed", `${operation} connection closed before a response`, true))); client.on("close", () => finish(new DaemonError("daemon_connection_closed", `${operation} connection closed before a response`, true)));
-  });
+  operation = canonicalNativeOperation('grok', operation);
+  const request = { schema_id: REQUEST_SCHEMA, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
+  return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: RESPONSE_SCHEMA, harness: 'grok', timeoutMs });
 }
 
 function sameConfig(state, config) { return ["cwd", "journal", "bin", "authSource", "model", "reasoning", "mode", "ddFlowBin", "ddFlowHome", "projectRoot", "sessionArchive", "resourceHome", "noFlow"].every((key) => (state.config?.[key] ?? null) === (config[key] ?? null)); }
@@ -178,7 +174,7 @@ export async function startDaemon(options) {
   const daemonId = randomUUID();
   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() + 120_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); const failure = grokStartupFailure(await readState(paths.dir)); if (failure) throw failure; 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); }
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: 120_000 }); while (!startupClock.sample()) { await new Promise((resolve) => setTimeout(resolve, 100)); const failure = grokStartupFailure(await readState(paths.dir)); if (failure) throw failure; 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 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, { readState: () => readState(options.stateDir) }); }
@@ -236,7 +232,7 @@ export class Runtime {
       cwd,
       native_root_receipt: prior?.native_root_receipt ?? null
     });
-    this.bridge.registerModelSession?.(id, id, this.state.config, parent);
+    this.bridge.registerModelSession?.(id, id, this.state.config, parent, true, newAttempt);
     this.descendants.set(id, {
       provider_session_id: id,
       parent_provider_session_id: parent,
@@ -340,10 +336,16 @@ export class Runtime {
     return running;
   }
   async requireSettled() { const running = await this.refreshTree(); if (running.length) throw new DaemonError("tree_not_settled", "daemon still owns a running Session tree", false, { sessions: running }); }
-  async productive(name, task, sessionId) {
+  async productive(name, task, sessionId, operationId = null) {
     assertDaemonDispatch(this.paths?.dir);
     if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true);
     this.active = name;
+    const current = this.nativeHookOperation = { operationId, sessionId, generation: (this.hookGeneration = (this.hookGeneration ?? 0) + 1), requests: new Map() };
+    let rejectHook;
+    const hookFailed = new Promise((_, reject) => { rejectHook = reject; });
+    void hookFailed.catch(() => {});
+    current.reject = error => { if (this.nativeHookOperation !== current || current.error) return; current.error = error; this.bridge.lifecycleFailure ??= error; this.bridge.notificationError = this.bridge.lifecycleFailure; this.bridge.rejectAll(this.bridge.lifecycleFailure); rejectHook(this.bridge.lifecycleFailure); };
+    const timer = setInterval(() => { void this.observeHookFailures(current).catch(error => current.reject(error)); }, 100);
     // Only a new native turn invalidates its own root proof. Creation, fork
     // and local archive export must not erase an unrelated Session's receipt.
     if (name === "session.prompt" && this.sessions.has(sessionId)) this.sessions.get(sessionId).native_root_receipt = null;
@@ -351,7 +353,7 @@ export class Runtime {
       await this.persist({ active_tree: true, active_operation: name });
       assertDaemonDispatch(this.paths?.dir);
       const before = new Map(this.descendants);
-      const result = await task();
+      const result = await Promise.race([task(), hookFailed]);
       this.track(result, before);
       const session = this.sessions.get(result.provider_session_id);
       if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id };
@@ -369,18 +371,41 @@ export class Runtime {
         const session = this.sessions.get(sessionId);
         if (session) session.native_root_receipt = { kind: "failed", daemon_id: this.state.daemon_id, request_id: response.request_id };
       }
-      await this.persist({ active_tree: true, active_operation: null }); throw error;
+      try { await hookBudget(1_000, null).run(() => this.persist({ active_tree: true, active_operation: null }), "failure_persistence"); }
+      catch (storage) { error.cleanup_error = errorRecord(storage); }
+      throw error;
     }
-    finally { this.active = null; }
+    finally { clearInterval(timer); current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; this.active = null; }
+  }
+  async observeHookFailures(current = this.nativeHookOperation) {
+    if (!current || this.nativeHookOperation !== current || current.reading) return;
+    current.reading = true;
+    try { await readNativeHookFailures(this.paths.dir, current.requests, current, error => {
+      if (!isProvenShellCorrection(error)) current.reject(error);
+    }); } finally { current.reading = false; }
+  }
+  async acceptHook(identity, sessionId, payload) {
+    const input = payload?.tool_input ?? payload?.toolInput;
+    const command = input?.command ?? input?.cmd;
+    if ((payload?.hook_event_name ?? payload?.hookEventName) !== "PreToolUse" || typeof command !== "string" || (!["lifecycle", "auxiliary"].includes(parseLifecycleCommand(command).participation) && !continuationCommand(command))) return identity;
+    const current = this.nativeHookOperation, tool = payload.tool_use_id ?? payload.toolUseId ?? payload.tool_call_id;
+    const root = current?.sessionId ?? this.loadedSessionId;
+    const pending = [...(this.bridge.pending?.values() ?? [])].some(request => request.method === "session/prompt" && request.sessionId === root);
+    if (!current || !pending || identity.rootProviderSessionId !== root || !tool) throw new DaemonError("native_hook_unproven", "Native hook has no exact active Session operation");
+    const binding = await hookBudget(1_000, null).run(() => acceptNativeHookRequest(this.paths.dir, { daemon_id: this.state.daemon_id, operation_id: current.operationId, turn_generation: current.generation, provider_session_id: sessionId, root_provider_session_id: root, tool_call_id: tool, event: "PreToolUse", command_sha256: createHash("sha256").update(command).digest("hex"), native_cwd: payload.cwd ?? null }, current), "hook_binding");
+    if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "Native hook operation changed during acceptance");
+    current.requests.set(binding.request_id, { current, binding });
+    return { ...identity, nativeHookBinding: binding };
   }
-  async dispatch(operation, params) {
+  async dispatch(operation, params, operationId = null) {
     const assertDispatch = captureDispatchGuard(this);
     if (["session.create", "session.prompt", "session.fork", "session.archive"].includes(operation)) assertDaemonDispatch(this.paths.dir);
     if (operation === "daemon.ready") return { ready: this.ready, daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, config_isolation: this.state.config_isolation, shutdown_state: this.state.shutdown_state, recovery_status: this.state.recovery_status, auth_status: this.state.auth_status, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config: this.state.config };
     if (operation === "daemon.status") { let observationError; if (!this.active && !this.state.shutdown?.phases?.tree) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { ...await this.dispatch("daemon.ready", {}), observation_error: observationError ?? this.state.observation_error ?? null }; }
-    if (operation === "hook.resolve") { const sessionId = String(params.sessionId ?? ""); if (!sessionId) throw new DaemonError("hook_identity_missing", "hook has no sessionId"); let session = this.sessions.get(sessionId); if (!session) { const roots = [...this.sessions.values()].filter((item) => !item.parent_provider_session_id); if (roots.length !== 1) throw new DaemonError("hook_identity_unknown", "unknown hook Session has no unique root"); const observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId, liveSession: true })); this.track(observed); session = this.sessions.get(sessionId); if (!session || session.root_provider_session_id !== roots[0].provider_session_id) throw new DaemonError("hook_identity_unknown", "hook Session is not a member of the retained native tree"); await this.persist(); } return { daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }; }
-    if (operation === "session.create") return await this.productive(operation, async () => { const result = await createSessionWithBridge(this.bridge, { ...this.options(params), onSessionCreated: async (session) => { this.track(session); this.loadedSessionId = session.provider_session_id; await this.persist(); } }, this.initialized); this.loadedSessionId = result.provider_session_id; return result; });
-    if (operation === "session.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch }); this.loadedSessionId = params.sessionId; return result; }, params.sessionId); }
+    if (operation === "hook.resolve") { const sessionId = String(params.sessionId ?? ""); if (!sessionId) throw new DaemonError("hook_identity_missing", "hook has no sessionId"); let session = this.sessions.get(sessionId); if (!session) { const roots = [...this.sessions.values()].filter((item) => !item.parent_provider_session_id); if (roots.length !== 1) throw new DaemonError("hook_identity_unknown", "unknown hook Session has no unique root"); const observed = await inspectSessionWithBridge(this.bridge, this.options({ sessionId, liveSession: true })); this.track(observed); session = this.sessions.get(sessionId); if (!session || session.root_provider_session_id !== roots[0].provider_session_id) throw new DaemonError("hook_identity_unknown", "hook Session is not a member of the retained native tree"); await this.persist(); } return await this.acceptHook({ daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} }, sessionId, params.payload); }
+    if (operation === "hook.failed") { await this.observeHookFailures(); return { observed: true }; }
+    if (operation === "session.create") return await this.productive(operation, async () => { const result = await createSessionWithBridge(this.bridge, { ...this.options(params), onSessionCreated: async (session) => { this.track(session); this.loadedSessionId = session.provider_session_id; await this.persist(); } }, this.initialized); this.loadedSessionId = result.provider_session_id; return result; }, null, operationId);
+    if (operation === "session.prompt") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await promptSessionWithBridge(this.bridge, { ...this.options(params), assertDispatch, operationId }); this.loadedSessionId = params.sessionId; return result; }, params.sessionId, operationId); }
     if (operation === "session.fork") { await this.requireSettled(); return await this.productive(operation, async () => { const result = await forkSessionWithBridge(this.bridge, this.options(params)); this.loadedSessionId = params.sessionId; return result; }); }
     if (operation === "session.inspect" || operation === "session.resume") { const before = new Map(this.descendants); const result = await inspectSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); this.track(result, before); await this.persist(); return { ...result, settled: !this.active && !this.treeRunning(result), descendants: this.topology(result.provider_session_id) }; }
     if (operation === "session.cancel") { if (!this.sessions.has(params.sessionId)) throw new DaemonError("session_identity_mismatch", "cancellation Session is not owned by this daemon"); cancelPendingDispatch(this); const result = await cancelSessionWithBridge(this.bridge, this.options({ ...params, liveSession: true })); await this.persist({ active_tree: Boolean(this.active) || !result.settled }); return result; }
@@ -441,13 +466,13 @@ export async function serveDaemon(stateDir) {
     connection.setEncoding("utf8"); let buffer = "", consumed = false;
     connection.on("data", chunk => {
       if (consumed) return;
-      buffer += chunk; const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
+      buffer += chunk; if (!admitNativeRequestBuffer(buffer, connection, RESPONSE_SCHEMA)) { consumed = true; return; } const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
       void (async () => {
         let request;
         try {
           request = JSON.parse(buffer.slice(0, at));
           if (request.schema_id !== REQUEST_SCHEMA || !request.id || !request.operation) throw new DaemonError("daemon_protocol_mismatch", "invalid daemon request");
-          const result = await durableDaemonDispatch(paths.dir, request, () => runtime.dispatch(request.operation, request.params ?? {}), () => runtime.dispatch("session.inspect", request.params ?? {}));
+          const result = await durableDaemonDispatch(paths.dir, request, () => runtime.dispatch(request.operation, request.params ?? {}, request.id), () => runtime.dispatch("session.inspect", request.params ?? {}));
           if (result._shutdown) retireDaemonEndpoint(server);
           connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: true, result: { ...result, _shutdown: undefined } })}\n`);
         } catch (error) {
@@ -461,3 +486,4 @@ export async function serveDaemon(stateDir) {
   await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await runtime.persist({ shutdown_state: "running", active_tree: false }); runtime.ready = true; return await new Promise(() => {});
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";
+import { commandText } from "./process-json.mjs";