@deksden-com/dd-flow-cli 0.9.0-beta.123 → 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 } 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,28 +15,22 @@ 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; }
-  const previous = await readJson(paths.state);
+  previous = await readJson(paths.state); assertDaemonRestartable(previous);
   if (previous) {
     const rows = await processSnapshot();
     if (rows.some(row => !row.zombie && ([previous.pid, previous.provider_pid].includes(row.pid) || previous.owned_processes?.some(old => old.pid === row.pid && old.started === row.started)))) throw new DroidError("invalid_harness_crash", "Previous daemon or provider ownership remains; refusing another owner");
@@ -48,16 +44,16 @@ 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; }
 }
-export async function stopDaemon(options) { return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, 30_000), droidPaths(options.stateDir).socket, 30_000); }
+export async function stopDaemon(options) { return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, 30_000), droidPaths(options.stateDir).socket, 30_000, { readState: () => readJson(droidPaths(options.stateDir).state) }); }
 export async function serveDaemon(stateDir) {
   const paths = droidPaths(stateDir), state = await readJson(paths.state); if (!state?.config) throw new DroidError("daemon_state_missing", "Missing Droid daemon state");
   let saving = Promise.resolve(), busy = null, stopping = false;
-  const save = patch => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString() }); const snapshot = structuredClone(state); saving = saving.then(() => writeJsonAtomic(paths.state, snapshot)); return saving; };
+  const save = patch => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString() }); const snapshot = structuredClone(state); saving = saving.catch(() => {}).then(() => writeJsonAtomic(paths.state, snapshot)); return saving; };
   const runtime = new DroidRuntime(state.config, state, save);
   const dispatch = async request => {
     const params = request.params ?? {}, operation = request.operation;
@@ -71,35 +67,40 @@ export async function serveDaemon(stateDir) {
       return { ...inspected, cancelled: true, settled: cleanup.settled, cleanup };
     }
     if (operation === "daemon.stop") {
-      if (stopping) throw new DroidError("operation_busy", "Droid shutdown is already in progress");
-      if (!params.cancelTree && (busy || (runtime.rootId && !(await runtime.inspect(runtime.rootId)).settled))) throw new DroidError("tree_not_settled", "Droid still owns unfinished work");
       stopping = true;
       try {
+        return await completeDaemonShutdown(paths.dir, state, save, async () => {
+        if (!params.cancelTree && (busy || (runtime.rootId && !(await runtime.inspect(runtime.rootId)).settled))) throw new DroidError("tree_not_settled", "Droid still owns unfinished work");
+        commitDaemonShutdown(paths.dir);
         const cleanup = await runtime.closeTree(params.cancelTree === true);
         if (runtime.rootId) try { await runtime.inspect(runtime.rootId, { ignoreActive: true }); } catch (error) { cleanup.inspection_error = errorRecord(error); }
         // Native evidence failures remain visible, but cannot strand copied
         // credentials or the daemon after the owned process tree is gone.
-        await removeDroidAuth(state.config); const clean = !cleanup.forced && !cleanup.topology_error && !cleanup.inspection_error;
-        await save({ shutdown_state: clean ? "clean" : "unclean", active_tree: false, cleanup }); await finishDaemonProcess(state.config, state.resource_process);
-        return { stopped: true, clean, settled: true, cleanup, _shutdown: true };
+        const clean = !cleanup.forced && !cleanup.topology_error && !cleanup.inspection_error;
+        return { clean, cleanup };
+        }, [
+          ["auth", () => removeDroidAuth(state.config)],
+          ["daemon_resource", () => finishDaemonProcess(state.config, state.resource_process)]
+        ]);
       }
-      catch (error) { stopping = false; await save({ shutdown_state: "cleanup_failed", cleanup_error: errorRecord(error) }); throw error; }
+      catch (error) { if (error.code === "tree_not_settled" && !runtime.closed) stopping = false; throw error; }
     }
     if (busy || stopping) throw new DroidError("operation_busy", "Another Droid operation is active");
     busy = operation;
     try {
       await save({ active_operation: busy });
+      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) {
@@ -114,10 +115,11 @@ export async function serveDaemon(stateDir) {
       // durable stop receipt while the Unix pathname is atomically retired.
       // Unlinking it from the request handler races that final response and
       // can leave a stop caller observing the socket for its whole timeout.
-      if (_shutdown) server.close();
+      if (_shutdown) retireDaemonEndpoint(server);
       socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request.id, ok: true, result: receipt })}\n`);
-      } catch (error) { socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request?.id, ok: false, error: errorRecord(error) })}\n`); } })();
+      } catch (error) { await retireFailedDaemon(server, state, error, save); socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request?.id, ok: false, error: errorRecord(error) })}\n`); } })();
   }); });
+  trackDaemonConnections(server);
   try { await runtime.start(); scheduleDaemonProcessHeartbeat(state.config, state.resource_process); await save({ shutdown_state: "running" }); await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); }
   catch (error) { let cleanup; try { cleanup = await runtime.closeTree(true); await removeDroidAuth(state.config); } catch (failure) { await save({ shutdown_state: "cleanup_failed", startup_error: errorRecord(error), cleanup_error: errorRecord(failure) }); throw error; } await save({ shutdown_state: "failed", startup_error: errorRecord(error), cleanup }); await finishDaemonProcess(state.config, state.resource_process, "failed", "startup_failed"); throw error; }
   await new Promise(resolve => server.once("close", resolve));

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;
     }