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

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

@@ -1,6 +1,8 @@
 import { createHash } from "node:crypto";
 import { ToolObservations, openCodeToolObservation } from "./tool-observations.mjs";
-import { observedTimeout } from "./observation-clock.mjs";
+import { observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
+import { assertNativeLine } from "./native-streams.mjs";
+import { operationProgressReporter } from "./operation-progress.mjs";
 
 export class OpenCodeError extends Error {
   constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; }
@@ -10,18 +12,24 @@ export class OpenCodeClient {
   constructor({ baseUrl, password, directory, timeoutMs = 1_800_000 }) {
     this.baseUrl = new URL(baseUrl); this.password = password; this.directory = directory; this.timeoutMs = timeoutMs;
   }
-  async request(method, pathname, body, { directory = this.directory, timeoutMs = this.timeoutMs, progress } = {}) {
+  async request(method, pathname, body, { directory = this.directory, timeoutMs = this.timeoutMs, progress, onDispatched } = {}) {
     const url = new URL(pathname, this.baseUrl); if (directory) url.searchParams.set("directory", directory);
     const controller = new AbortController(); const timer = observedTimeout(() => controller.abort(), timeoutMs, { progress });
     try {
-      const response = await fetch(url, { method, headers: { authorization: `Basic ${Buffer.from(`opencode:${this.password}`).toString("base64")}`, ...(body === undefined ? {} : { "content-type": "application/json" }) }, body: body === undefined ? undefined : JSON.stringify(body), signal: controller.signal });
-      const text = await response.text(); let value = null; try { value = text ? JSON.parse(text) : null; } catch { value = text; }
+      const pending = fetch(url, { method, headers: { authorization: `Basic ${Buffer.from(`opencode:${this.password}`).toString("base64")}`, ...(body === undefined ? {} : { "content-type": "application/json" }) }, body: body === undefined ? undefined : JSON.stringify(body), signal: controller.signal });
+      void pending.catch(() => {}); await onDispatched?.(); const response = await pending;
+      let text = "";
+      const decoder = new TextDecoder();
+      if (response.body) for await (const chunk of response.body) { text += decoder.decode(chunk, { stream: true }); assertNativeLine(text); }
+      text += decoder.decode(); assertNativeLine(text);
+      let value = null; try { value = text ? JSON.parse(text) : null; } catch { value = text; }
       if (!response.ok) throw new OpenCodeError(response.status === 404 ? "session_not_found" : "opencode_http_error", `OpenCode ${method} ${pathname} returned ${response.status}`, response.status >= 500, value);
       return value;
     } catch (error) {
-      if (error instanceof OpenCodeError) throw error;
+      controller.abort();
+      if (error instanceof OpenCodeError || error.code === "operation_observation_lost") throw error;
       // Aborting HTTP only loses the observer; it does not cancel the provider.
-      throw new OpenCodeError(error.name === "AbortError" || method === "POST" ? "operation_observation_lost" : "opencode_unavailable", error.message, true, { method, pathname });
+      throw Object.assign(new OpenCodeError(error.name === "AbortError" || method === "POST" ? "operation_observation_lost" : "opencode_unavailable", error.message, true, { method, pathname }), { cause: error });
     } finally { clearTimeout(timer); }
   }
   health() { return this.request("GET", "/global/health", undefined, { directory: null, timeoutMs: 5_000 }); }
@@ -31,11 +39,15 @@ export class OpenCodeClient {
   statuses() { return this.request("GET", "/session/status"); }
   children(id) { return this.request("GET", `/session/${encodeURIComponent(id)}/children`); }
   messages(id) { return this.request("GET", `/session/${encodeURIComponent(id)}/message`); }
-  async prompt(id, { prompt, provider, model, variant, agent, onModelMessages, onObservationError, assertDispatch }) {
+  async prompt(id, { prompt, provider, model, variant, agent, onModelMessages, onObservationError, assertDispatch, onDispatched, livenessTimeoutMs = this.timeoutMs }) {
+    validateObservationDuration(livenessTimeoutMs);
     const previous = await this.messages(id);
     if (!Array.isArray(previous)) throw new OpenCodeError("operation_observation_lost", "OpenCode history cannot establish the prompt boundary", true);
     const previousIds = new Set(previous.map(message => message.info?.id).filter(Boolean));
-    let marker, observation = null;
+    const publish = operationProgressReporter();
+    let marker, observation = null, cursor = 0, signature = null, highWater = 0;
+    const seenSignatures = new Set();
+    const floors = new Map([[id, previousIds]]);
     // Native message content is progress; an HTTP poll or busy status is not.
     // Include descendants so a coordinating parent may legitimately be silent.
     const observe = async (session, seen = new Set(), parent = null) => {
@@ -46,21 +58,38 @@ export class OpenCodeClient {
         this.request("GET", `/session/${encodeURIComponent(session)}/message`, undefined, options),
         this.request("GET", `/session/${encodeURIComponent(session)}/children`, undefined, options)
       ]);
+      if (!Array.isArray(messages) || !Array.isArray(children)) throw new OpenCodeError("operation_observation_lost", "OpenCode observation shape is unproven", true);
       await onModelMessages?.(session, messages, parent);
-      return [session, messages, ...await Promise.all((children ?? []).map(child => observe(child.id, seen, session)))];
+      // A newly discovered child does not turn its old transcript into work.
+      if (!floors.has(session)) floors.set(session, new Set(messages.map(message => message.info?.id).filter(Boolean)));
+      const current = messages.filter(message => message.info?.role === "assistant" && message.info?.sessionID === session && !floors.get(session).has(message.info?.id));
+      const content = current.map(message => ({ id: message.info?.id, parts: (message.parts ?? []).filter(part => ["text", "reasoning", "tool", "subtask"].includes(part.type)).map(stablePart) })).sort((a, b) => String(a.id).localeCompare(String(b.id)));
+      const checked = children.filter(child => child.parentID === session && typeof child.id === "string").sort((a, b) => a.id.localeCompare(b.id));
+      const descendants = (await Promise.all(checked.map(child => observe(child.id, seen, session)))).filter(value => value.length > 0);
+      return content.some(message => message.parts.length) || descendants.length ? [session, content, ...descendants] : [];
     };
     const refreshObservation = () => observation ??= (async () => {
-      try { marker = createHash("sha256").update(JSON.stringify(await observe(id))).digest("hex"); }
+      try { const projection = JSON.stringify(await observe(id)), next = createHash("sha256").update(projection).digest("hex");
+        // Cumulative text can grow indefinitely without retaining every hash;
+        // non-growing snapshot states have bounded current-operation replay proof.
+        if (signature !== null && !seenSignatures.has(next) && (projection.length > highWater || seenSignatures.size < 1_024)) {
+          marker = { cursor: ++cursor, observed_at: Date.now() };
+          await publish("native_progress", { session_id: id, observed_at: new Date(marker.observed_at).toISOString() });
+        }
+        if (seenSignatures.size < 1_024) seenSignatures.add(next);
+        highWater = Math.max(highWater, projection.length);
+        signature = next;
+      }
       catch (error) { await onObservationError?.(error); /* Missing data is not progress. */ }
     })().finally(() => { observation = null; });
     // Begin observing before the long-running request.  Waiting for the first
     // interval can let a short liveness window expire before any native
     // content has had a chance to renew it.
     void refreshObservation();
-    const timer = setInterval(() => { void refreshObservation(); }, Math.max(10, Math.min(5_000, this.timeoutMs / 4)));
+    const timer = setInterval(() => { void refreshObservation(); }, Math.max(10, Math.min(5_000, livenessTimeoutMs / 4)));
     try {
       assertDispatch?.();
-      const reply = await this.request("POST", `/session/${encodeURIComponent(id)}/message`, { model: { providerID: provider, modelID: model }, variant, agent, parts: [{ type: "text", text: prompt }] }, { progress: () => marker });
+      const reply = await this.request("POST", `/session/${encodeURIComponent(id)}/message`, { model: { providerID: provider, modelID: model }, variant, agent, parts: [{ type: "text", text: prompt }] }, { timeoutMs: livenessTimeoutMs, progress: () => marker, onDispatched });
       if (!reply?.info?.id || reply.info.sessionID !== id || reply.info.role !== "assistant" || previousIds.has(reply.info.id) || !Array.isArray(reply.parts)) {
         throw new OpenCodeError("operation_observation_lost", "OpenCode did not return an identifiable current assistant response", true, { session_id: id, message_id: reply?.info?.id ?? null });
       }
@@ -69,7 +98,8 @@ export class OpenCodeClient {
         const message = native.data?.message ?? native.message ?? native.name ?? "OpenCode provider failed";
         const status = native.data?.statusCode;
         const code = status === 402 || /payment required|quota|usage balance exhausted|insufficient.?credit|billing/i.test(message) ? "provider_quota_exhausted" : /rate.?limit|too many requests/i.test(message) ? "provider_rate_limited" : status === 429 ? "provider_limit_unknown" : "opencode_provider_failed";
-        throw new OpenCodeError(code, message, code === "provider_rate_limited", { session_id: id, message_id: reply.info.id, provider_error: native });
+        throw new OpenCodeError(code, message, code === "provider_rate_limited", { session_id: id, provider_session_id: id, message_id: reply.info.id, provider_error: native,
+          observed_at: new Date().toISOString(), native_source: "opencode.reply.info.error", turn_id: reply.info.id });
       }
       return reply;
     }
@@ -81,7 +111,7 @@ export class OpenCodeClient {
 }
 
 function stablePart(part) {
-  if (part.type === "text") return { type: "text", text: part.text, synthetic: part.synthetic === true };
+  if (part.type === "text" || part.type === "reasoning") return { type: part.type, text: part.text, synthetic: part.synthetic === true };
   if (part.type === "tool") return { type: "tool", tool: part.tool, state: { status: part.state?.status, input: part.state?.input, output: part.state?.output, error: part.state?.error } };
   if (part.type === "subtask") return { type: "subtask", prompt: part.prompt, description: part.description, agent: part.agent };
   return { type: part.type };

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

@@ -1,11 +1,16 @@
-import { observedTimeout } from "./observation-clock.mjs";
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { admitNativeRequestBuffer } from "./native-streams.mjs";
+import { ObservationClock } from "./observation-clock.mjs";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import net from "node:net";
-import { durableDaemonDispatch } from "./daemon-operations.mjs";
+import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
 import path from "node:path";
-import { prepareRuntimeOwner, cleanupFailedDaemonStart, closeManagedBridge, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
+import { parseLifecycleCommand, continuationCommand } from "./lifecycle-command.mjs";
+import { errorRecord, isProvenShellCorrection } from "./operation-errors.mjs";
 
 import {
   AcpBridge,
@@ -80,48 +85,11 @@ async function removeSocket(socket, dir) {
   } 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;
 
 export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
-  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;
-    // A prompt has its own sliding ACP liveness deadline.  Do not add an
-    // independent wall-clock deadline here: it can cut off an actively
-    // producing Turn merely because it is long.
-    const timer = Number.isFinite(timeoutMs) && timeoutMs > 0
-      ? observedTimeout(() => { client.destroy(); reject(new DaemonError("daemon_timeout", `${operation} timed out`, true)); }, timeoutMs)
-      : null;
-    const finish = (error, value) => {
-      if (settled) return;
-      settled = true; if (timer) 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)));
-  });
+  return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: RESPONSE_SCHEMA, harness: 'zcode', timeoutMs });
 }
 
 const ZCODE_ROUTING_ENV = ["ZCODE_HOME", "ZCODE_STORAGE_DIR", "ZCODE_SESSION_DB_PATH"];
@@ -163,13 +131,14 @@ export async function startDaemon(options) {
   await prepareRuntimeOwner(config, paths.dir);
   await mkdir(paths.dir, { recursive: true, mode: 0o700 });
   await chmod(paths.dir, 0o700);
+  let previous = await readState(paths.dir); assertDaemonRestartable(previous);
   try {
     const status = await callDaemon(paths.dir, "daemon.status", {}, 1000);
     if (!sameConfig(status, config)) throw new DaemonError("daemon_config_mismatch", "a daemon is already running with different configuration");
     return { ...status, already_running: true };
   } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; }
 
-  const previous = await readState(paths.dir);
+  previous = await readState(paths.dir); assertDaemonRestartable(previous);
   if (previous?.shutdown_state === "clean") {
     if (!sameNativeRouting(previous.config, config)) throw new DaemonError("daemon_config_mismatch", "retained ZCode native storage routing changed");
     await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
@@ -211,8 +180,8 @@ export async function startDaemon(options) {
   await log.close();
   try {
     await confirmDaemonProcess(config, resourceProcess, child);
-    const deadline = Date.now() + 30_000;
-    while (Date.now() < deadline) {
+    const startupClock = new ObservationClock({ timeoutMs: 30_000 });
+    while (!startupClock.sample()) {
       await new Promise((resolve) => setTimeout(resolve, 100));
       try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); }
       catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; }
@@ -227,7 +196,7 @@ export async function startDaemon(options) {
 export async function stopDaemon(options) {
   const timeoutMs = options.timeoutMs ?? 30_000;
   const { socket } = locations(options.stateDir);
-  return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), socket, timeoutMs);
+  return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), socket, timeoutMs, { readState: () => readState(options.stateDir) });
 }
 
 export class DaemonRuntime {
@@ -241,7 +210,7 @@ export class DaemonRuntime {
   persist(patch = {}) {
     Object.assign(this.state, patch, { pid: process.pid, updated_at: new Date().toISOString(), sessions: [...this.sessions.values()] });
     const snapshot = structuredClone(this.state);
-    this.persisting = this.persisting.then(() => writeState(this.paths.state, snapshot));
+    this.persisting = this.persisting.catch(() => {}).then(() => writeState(this.paths.state, snapshot));
     return this.persisting;
   }
 
@@ -250,13 +219,18 @@ export class DaemonRuntime {
     const adapter = params.adapterSessionId ?? known?.adapter_session_id ?? params.sessionId;
     const generation = this.activeGeneration ?? this.controlGeneration ?? 0;
     return {
-      ...this.state.config, ...params, knownChildSessionIds: known?.known_child_session_ids ?? [], adapterSessionId: adapter,
+      ...this.state.config, ...params, operationId: this.state.active_request?.request_id, knownChildSessionIds: known?.known_child_session_ids ?? [], adapterSessionId: adapter,
       neverPromptedRootProof: this.neverPromptedRootProof(params.sessionId),
       daemonId: this.state.daemon_id, allowBackground: true, liveSession: this.liveAdapters.has(adapter),
       assertDispatch: () => { if (generation !== (this.controlGeneration ?? 0)) throw new DaemonError("operation_cancelled", "ZCode prompt was cancelled before native dispatch"); },
+      onActivity: async ({ sessionId, requestId, progress }) => {
+        const request = this.state.active_request;
+        if (!request || request.adapter_session_id !== sessionId || this.activeGeneration !== request.generation) return;
+        await this.persist({ active_request: { ...request, observation: { state: "productive", request_id: requestId, progress } } });
+      },
       // The bridge owns the quiet timer; the daemon owns the durable status.
       // Do not infer provider state or cancel here.
-      onInactivity: async ({ requestId, sessionId, lastActivityAt, idleTimeoutMs }) => {
+      onInactivity: async ({ requestId, sessionId, lastActivityAt, idleTimeoutMs, cursor }) => {
         const request = this.state.active_request;
         // `sessionId` is ACP identity; the durable request's `session_id` is
         // native/provider identity. These strings can coincide but are not
@@ -285,7 +259,8 @@ export class DaemonRuntime {
         // The probe is asynchronous. Do not recreate a completed or
         // reconnected request with a stale callback snapshot.
         const current = this.state.active_request;
-        if (!current || current.request_id !== request.request_id || current.adapter_session_id !== adapterSessionId || this.activeGeneration !== request.generation) return;
+        if (!current || current.request_id !== request.request_id || current.adapter_session_id !== adapterSessionId || this.activeGeneration !== request.generation
+            || cursor !== undefined && this.bridge.pending?.get(requestId)?.progress?.cursor !== cursor && cursor !== 0) return;
         await this.persist({ active_request: {
           ...current,
           observation: { state: "quiet", request_id: requestId, detected_at: new Date().toISOString(), last_activity_at: new Date(lastActivityAt).toISOString(), quiet_threshold_ms: idleTimeoutMs, diagnostics },
@@ -388,9 +363,15 @@ export class DaemonRuntime {
     if (this.activeProductive) throw new DaemonError("operation_busy", `${this.activeProductive} is already running`, true);
     this.activeProductive = name;
     this.activeGeneration = this.controlGeneration ?? 0;
+    const current = this.nativeHookOperation = { operationId: request?.operation_id, generation: this.activeGeneration, requests: new Map() };
+    let rejectHook;
+    const hookFailed = new Promise((_, reject) => { rejectHook = reject; });
+    void hookFailed.catch(() => {}); // A hook can fail while the dispatch receipt is still persisting.
+    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);
     try {
       await this.persist({ active_tree: true, active_operation: name, ...(request ? { active_request: request } : {}) });
-      const result = await task();
+      const result = await Promise.race([task(), hookFailed]);
       this.track(result);
       const running = this.treeRunning(result);
       await this.persist({ active_tree: running, active_operation: null, active_request: null });
@@ -402,12 +383,12 @@ export class DaemonRuntime {
       // daemon state no longer carried the only correlation to it.
       const active = this.state?.active_request;
       try {
-        await this.persist({
+        await hookBudget(1_000, null).run(() => this.persist({
           active_operation: null,
           active_request: active?.allocation
             ? { ...active, outcome: "unknown", error: errorPayload(error) }
             : null,
-        });
+        }), "failure_persistence");
       } catch (cleanupError) {
         // Preserve the operation's primary failure if durable cleanup itself
         // is unavailable. The caller will retain the outcome as unknown and
@@ -415,7 +396,15 @@ export class DaemonRuntime {
         if (error && typeof error === "object") error.cleanup_error = errorPayload(cleanupError);
       }
       throw error;
-    } finally { this.activeProductive = null; this.activeGeneration = null; }
+    } finally { clearInterval(timer); current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; this.activeProductive = null; this.activeGeneration = 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 requireSettled(params) {
@@ -447,7 +436,8 @@ export class DaemonRuntime {
     await this.persist();
   }
 
-  async dispatch(operation, params) {
+  async dispatch(operation, params, operationId = null) {
+    if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume"].includes(operation)) assertDaemonDispatch(this.paths.dir);
     if (operation === "daemon.status") return {
       daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket,
       cwd: this.state.cwd, journal: this.state.journal, versions: this.state.versions,
@@ -460,10 +450,24 @@ export class DaemonRuntime {
       const sessionId = String(params.sessionId ?? "");
       const session = this.sessions.get(sessionId);
       if (!session?.root_provider_session_id) throw new DaemonError("hook_identity_unknown", "ZCode hook Session is not a tracked controlled Session", false, { session_id: sessionId });
-      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) ?? {} };
+      const identity = { daemonId: this.state.daemon_id, rootProviderSessionId: session.root_provider_session_id, parentProviderSessionId: session.parent_provider_session_id ?? null, observedProfile: this.bridge.modelProfiles?.get(sessionId) ?? {} };
+      const payload = params.payload, command = payload?.tool_input?.command ?? payload?.tool_input?.cmd;
+      if (payload?.hook_event_name === "PreToolUse" && typeof command === "string" && (["lifecycle", "auxiliary"].includes(parseLifecycleCommand(command).participation) || continuationCommand(command))) {
+        const current = this.nativeHookOperation, active = this.state.active_request;
+        const tool = payload.tool_use_id ?? payload.tool_call_id;
+        const pending = [...(this.bridge.pending?.values() ?? [])].some(request => request.method === "session/prompt" && request.sessionId === active?.adapter_session_id);
+        const root = active?.session_id ?? active?.allocation?.provider_session_id;
+        if (!current || !active || !pending || current.generation !== (this.controlGeneration ?? 0) || session.root_provider_session_id !== 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: session.root_provider_session_id, 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 }); identity.nativeHookBinding = binding;
+      }
+      return identity;
     }
+    if (operation === "hook.failed") { await this.observeHookFailures(); return { observed: true }; }
     if (operation === "session.create") {
       const request = {
+        operation_id: operationId,
         request_id: randomUUID(),
         session_id: params.sessionId ?? null,
         adapter_session_id: params.adapterSessionId ?? params.sessionId ?? null,
@@ -477,6 +481,7 @@ export class DaemonRuntime {
       if (this.sessions.get(params.sessionId)?.close_receipt) throw new DaemonError("session_closed", "Closed Session requires explicit recovery before another prompt");
       const known = this.sessions.get(params.sessionId);
       const request = {
+        operation_id: operationId,
         request_id: randomUUID(),
         session_id: params.sessionId,
         adapter_session_id: params.adapterSessionId ?? known?.adapter_session_id ?? params.sessionId,
@@ -548,12 +553,17 @@ export class DaemonRuntime {
       await this.persist({ active_tree: this.treeRunning(result) || Boolean(this.activeProductive) });
       return result;
     }
-    if (operation === "daemon.stop") return await this.prepareStop(params.cancelTree === true);
+    if (operation === "daemon.stop") return await completeDaemonShutdown(this.paths.dir, this.state, patch => this.persist(patch), () => this.prepareStop(params.cancelTree === true), [
+      ["provider_resource", () => finishDaemonProcess(this.state.config, this.state.provider_process)],
+      ["daemon_resource", () => finishDaemonProcess(this.state.config, this.state.resource_process)]
+    ]);
     throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
   }
 
   async prepareStop(cancel) {
+    if (this.activeProductive && !cancel) throw new DaemonError("tree_not_settled", "productive operation is running");
     if (cancel) this.controlGeneration = (this.controlGeneration ?? 0) + 1;
+    if (!this.state.native_stop_proof || this.state.native_stop_proof.daemon_id !== this.state.daemon_id) {
     const unsettled = [];
     for (const session of this.sessions.values()) {
       if (session.close_receipt) {
@@ -603,6 +613,10 @@ export class DaemonRuntime {
       }
     }
     if (unsettled.length) throw new DaemonError("tree_not_settled", "daemon still owns running Sessions", false, { sessions: unsettled });
+    commitDaemonShutdown(this.paths.dir);
+    await this.persist({ native_stop_proof: { daemon_id: this.state.daemon_id, sessions: [...this.sessions.keys()], observed_at: new Date().toISOString() } });
+    }
+    commitDaemonShutdown(this.paths.dir);
     // A cooperative close can make the native Session non-resident while its
     // original ACP prompt is still pending.  For an explicitly whole-RUN
     // cancellation this daemon owns the bridge process group, so retire that
@@ -614,7 +628,7 @@ export class DaemonRuntime {
         if (typeof this.bridge.close === "function") await this.bridge.close();
         bridgeClosed = true;
       } catch (error) {
-        throw new DaemonError(error.code ?? "provider_process_stop_incomplete", error.message ?? String(error), false);
+        throw new DaemonError(error.code ?? "provider_process_stop_incomplete", error.message ?? String(error), false, error.details);
       }
     }
     const deadline = Date.now() + 5000;
@@ -625,24 +639,11 @@ export class DaemonRuntime {
     // A bridge without a close method occurs only in in-memory diagnostics: it
     // owns no OS process boundary. Production AcpBridge always has one.
     try { if (!bridgeClosed && typeof this.bridge.close === "function") await this.bridge.close(); }
-    catch (error) { throw new DaemonError(error.code ?? "provider_process_stop_incomplete", error.message ?? String(error), false); }
+    catch (error) { throw new DaemonError(error.code ?? "provider_process_stop_incomplete", error.message ?? String(error), false, error.details); }
     await this.persist({ active_tree: false, shutdown_state: "stopping", active_operation: null, active_request: null, physical_settlement: { confirmed_at: new Date().toISOString(), bridge_pid: this.bridge.child?.pid ?? null } });
     return { daemon_id: this.state.daemon_id, stopped: true, clean: true, physical_settlement: this.state.physical_settlement, _shutdown: true };
   }
 
-  async shutdown() {
-    // prepareStop has already closed the owned bridge. Signal shutdown may get
-    // here directly, so close remains idempotent.
-    await closeManagedBridge(this.state.config, this.state, this.bridge);
-    await this.persist({ active_tree: false, shutdown_state: "clean", stopped_at: new Date().toISOString() });
-    const resourceProcess = this.state.resource_process;
-    if (resourceProcess?.id && resourceProcess.lease_token) {
-      try { await finishDaemonProcess(this.state.config, resourceProcess, "stopped", "daemon_stopped"); }
-      catch { /* Keep the state; the next reconciler owns stale processes. */ }
-    }
-    await new Promise((resolve) => this.server.close(resolve));
-    await removeSocket(this.paths.socket, this.paths.dir);
-  }
 }
 
 export function zcodeBridgeEnv(config, daemonId) {
@@ -660,27 +661,31 @@ export async function serveDaemon(stateDir) {
   scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
   await removeSocket(paths.socket, paths.dir);
   const server = net.createServer((connection) => {
-    connection.setEncoding("utf8"); let buffer = "";
+    connection.setEncoding("utf8"); let buffer = "", consumed = false;
     connection.on("data", (chunk) => {
-      buffer += chunk;
+      if (consumed) return;
+      buffer += chunk; if (!admitNativeRequestBuffer(buffer, connection, RESPONSE_SCHEMA)) { consumed = true; return; }
       const newline = buffer.indexOf("\n");
       if (newline < 0) return;
+      consumed = true;
       const line = buffer.slice(0, newline); buffer = buffer.slice(newline + 1);
       void (async () => {
         let request;
         try {
           request = JSON.parse(line);
           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`);
-          if (result?._shutdown) setImmediate(() => void runtime.shutdown().then(() => process.exit(0)));
         } catch (error) {
+          await retireFailedDaemon(server, state, error, patch => runtime.persist(patch));
           connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request?.id ?? null, ok: false, error: errorPayload(error) })}\n`);
         }
       })();
     });
   });
   runtime.server = server;
+  trackDaemonConnections(server);
   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 });