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

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

@@ -1,9 +1,10 @@
-import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 
 import { AcpBridge } from "./dd-zcode.mjs";
 import { checkObservedProfile, observeModel } from "./model-observations.mjs";
+import { errorRecord } from "./operation-errors.mjs";
+import { nativeObservationError } from "./native-streams.mjs";
 
 const GROK_HARNESS_CONTRACT = "dd-grok-harness@1";
 
@@ -14,11 +15,7 @@ function executable(command, args = []) { const resolved = command ?? process.en
 
 async function commandOutput(command, args) {
   const target = executable(command, args);
-  return await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { 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.trim()) : reject(new Error(stderr.trim() || `${target.command} exited ${code}`)));
-  });
+  return await commandText(target.command, target.args, { phase: "native-version" });
 }
 
 function profile(options) { return { provider: "xai", model: options.model ?? null, reasoning: options.reasoning ?? null, mode: options.mode ?? "bypassPermissions" }; }
@@ -56,8 +53,10 @@ function bridgeOptions(options) {
 
 async function withBridge(options, operation) {
   const bridge = new AcpBridge(bridgeOptions(options));
-  try { const initialized = await bridge.start(); return await operation(bridge, initialized); }
-  finally { await bridge.close(); }
+  let primaryError, result;
+  try { const initialized = await bridge.start(); result = await operation(bridge, initialized); return result; }
+  catch (error) { primaryError = error; throw error; }
+  finally { try { await bridge.close(); } catch (error) { if (!primaryError) throw nativeObservationError(error, result === undefined ? {} : { result }); primaryError.cleanup_error = errorRecord(error); primaryError.details = { ...primaryError.details, cleanup_error: primaryError.cleanup_error }; } }
 }
 
 export function observedProfile(initialized, requested) {
@@ -88,10 +87,7 @@ async function forwardUsage(options, providerSessionId, usage, toolCalls) {
   const measured = usage.usage && typeof usage.usage === "object" ? usage.usage : usage;
   const input = JSON.stringify({ provider_session_id: providerSessionId, daemon_id: options.daemonId ?? null, observed_at: new Date().toISOString(), usage: measured, tool_calls: toolCalls, usage_scope: usageScope(options, providerSessionId), completeness: measured.usageIsIncomplete ? "partial" : "complete" });
   const target = executable(options.ddFlowBin, ["grok", "usage", "ingest", "--project-root", absolute(options.projectRoot, "--project-root"), "--json"]);
-  await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { env: { ...process.env, ...(options.ddFlowHome ? { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home") } : {}) }, stdio: ["pipe", "ignore", "pipe"] }); let stderr = "";
-    child.stderr.setEncoding("utf8").on("data", (chunk) => (stderr += chunk)); child.on("error", reject); child.on("close", (code) => code === 0 ? resolve() : reject(new Error(stderr || "dd-flow grok usage failed"))); child.stdin.end(`${input}\n`);
-  });
+  await commandText(target.command, target.args, { input: `${input}\n`, env: options.ddFlowHome ? { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home") } : {}, phase: "usage-ingest" });
 }
 
 async function forwardUsageBestEffort(options, providerSessionId, usage, toolCalls) {
@@ -153,10 +149,15 @@ export async function promptSessionWithBridge(bridge, options) {
   requireJournal(options); const sessionId = await identity(bridge, options); const prompt = text(options.prompt, "prompt"); const requested = requiredProfile(options); const profileReceipt = assertProfile(requested, observedProfile(options.initialized, requested));
   const local = { ...options, rootProviderSessionId: options.rootProviderSessionId ?? sessionId }; const initial_usage_error = await forwardUsageBestEffort(local, sessionId, await sessionUsage(bridge, sessionId), sessionToolCalls(local, bridge, sessionId));
   options.assertDispatch?.();
-  const cursor = bridge.toolCursor(); const textCursor = bridge.assistantTextCursor(sessionId); const turn = await bridge.request("session/prompt", { sessionId, prompt: [{ type: "text", text: prompt }] }, null, { idleSessionId: sessionId, idleTimeoutMs: options.timeoutMs ?? 600_000 }); await bridge.flush();
+  bridge.dispatchOperationId = options.operationId;
+  const cursor = bridge.toolCursor(); const textCursor = bridge.assistantTextCursor(sessionId); const turn = await bridge.request("session/prompt", { sessionId, prompt: [{ type: "text", text: prompt }] }, null, { idleSessionId: sessionId, idleTimeoutMs: options.livenessTimeoutMs ?? options.timeoutMs ?? 600_000 });
+  try {
+  await bridge.flush();
   const evidence = await inspect(bridge, sessionId, local); evidence.tool_calls = recordToolCalls(local, bridge, sessionId, cursor); const usage_ingest_error = await forwardUsageBestEffort(local, sessionId, evidence.usage, evidence.tool_calls); if (initial_usage_error) evidence.initial_usage_error = initial_usage_error; if (usage_ingest_error) evidence.usage_ingest_error = usage_ingest_error;
   if (!options.allowBackground && (evidence.subagents?.subagents ?? []).length) { await cancelTree(bridge, sessionId); fail("background Grok Build subagents cannot outlive the one-shot dd-grok connection"); }
   return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, assistant_text: bridge.assistantTextSince(sessionId, textCursor), turn, profile: profileReceipt, evidence });
+  } catch (error) { throw Object.assign(new Error("Grok native Turn completed but mandatory observation failed", { cause: error }), { code: "native_outcome_observation_failed", retryable: false,
+    details: { provider_session_id: sessionId, native_outcome: { status: "completed", turn }, observation_error: errorRecord(error), settled: false, journal_locator: options.journal } }); }
 }
 
 export async function inspectSession(options) { requireJournal(options); return await withBridge(options, async (bridge, initialized) => await inspectSessionWithBridge(bridge, { ...options, initialized })); }
@@ -173,3 +174,4 @@ export async function forkSessionWithBridge(bridge, options) {
   const child = text(result.newSessionId, "Grok Build fork newSessionId"); return receipt(options, { harness: "grok-acp", parent_provider_session_id: sessionId, provider_session_id: child, adapter_session_id: child, target, fork: result });
 }
 export async function promptFromFile(file) { return await readFile(absolute(file, "--prompt-file"), "utf8"); }
+import { commandText } from "./process-json.mjs";

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

@@ -1,6 +1,8 @@
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { admitNativeRequestBuffer } from "./native-streams.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
 import { openCodeToolObservation, journalToolObservations } from "./tool-observations.mjs";
-import { observedTimeout } from "./observation-clock.mjs";
+import { ObservationClock } from "./observation-clock.mjs";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { appendFile, chmod, copyFile, lstat, mkdir, open, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
@@ -24,24 +26,8 @@ async function readState(dir) { try { return JSON.parse(await readFile(locations
 async function removeSocket(paths) { try { if (!(await lstat(paths.socket)).isSocket()) throw new DaemonError("unsafe_socket", "refusing to replace non-socket daemon path"); await unlink(paths.socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
 function executable(bin, args = []) { return /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args }; }
 function isolatedEnv(config) { return { ...process.env, XDG_DATA_HOME: config.dataHome, XDG_CONFIG_HOME: config.configHome, XDG_CACHE_HOME: config.cacheHome, OPENCODE_CONFIG_DIR: config.adapterDir, OPENCODE_DISABLE_PROJECT_CONFIG: "1", OPENCODE_SERVER_PASSWORD: config.password, ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome } : {}), ...(config.resourceHome ? { DD_FLOW_RESOURCE_HOME: config.resourceHome } : {}), ...(config.ddFlowBin ? { DD_OPENCODE_DD_FLOW_BIN: config.ddFlowBin, DD_OPENCODE_NODE_BIN: process.execPath, DD_OPENCODE_PROJECT_ROOT: config.projectRoot } : {}), DD_OPENCODE_DAEMON_ID: config.daemonId, DD_OPENCODE_PROVIDER: config.provider, DD_OPENCODE_MODEL: config.model, DD_OPENCODE_VARIANT: config.variant, DD_OPENCODE_AGENT: config.agent, DD_OPENCODE_SERVER_VERSION: config.version ?? "unknown", DD_OPENCODE_PLUGIN_SHA256: config.pluginSha256 ?? "unknown" }; }
-async function run(bin, args, config, { stdin, timeoutMs = 30_000 } = {}) {
-  const target = executable(bin, args);
-  return await new Promise((resolve, reject) => {
-    const child = spawn(target.command, target.args, { cwd: config.cwd, env: isolatedEnv(config), detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = "", stderr = "", timeoutError, inputError, cleanup;
-    const timer = setTimeout(() => {
-      timeoutError = new DaemonError("opencode_timeout", `${args[0]} timed out`, true);
-      cleanup = stopProcessGroup(child, 1_000).catch(error => { timeoutError.details = { cleanup_error: errorRecord(error) }; reject(timeoutError); });
-    }, timeoutMs);
-    child.stdout.setEncoding("utf8").on("data", chunk => stdout += chunk); child.stderr.setEncoding("utf8").on("data", chunk => stderr += chunk);
-    child.on("error", error => { clearTimeout(timer); reject(error); });
-    child.on("close", async code => { clearTimeout(timer); await cleanup; if (timeoutError) reject(timeoutError); else if (inputError) reject(inputError); else if (code === 0) resolve(stdout); else reject(new DaemonError("opencode_cli_failed", stderr.trim() || `${target.command} exited ${code}`)); });
-    child.stdin.on("error", error => {
-      inputError ??= error;
-      cleanup ??= stopProcessGroup(child, 1_000).catch(cause => { clearTimeout(timer); inputError.details = { ...inputError.details, cleanup_error: errorRecord(cause) }; reject(timeoutError ?? inputError); });
-    });
-    child.stdin.end(stdin ?? "");
-  });
+export async function run(bin, args, config, { stdin, timeoutMs = 30_000 } = {}) {
+  return await commandText(bin, args, { cwd: config.cwd, env: isolatedEnv(config), input: stdin ?? null, timeoutMs, phase: "native-utility" });
 }
 async function forwardUsage(config, sessionId, snapshot) {
   if (!config.ddFlowBin) return;
@@ -49,7 +35,7 @@ async function forwardUsage(config, sessionId, snapshot) {
   await run(config.ddFlowBin, ["opencode", "usage", "ingest", "--project-root", config.projectRoot, "--json"], config, { stdin: `${JSON.stringify(payload)}\n` });
 }
 async function freePort() { return await new Promise((resolve, reject) => { const server = net.createServer(); server.once("error", reject); server.listen(0, "127.0.0.1", () => { const port = server.address().port; server.close(() => resolve(port)); }); }); }
-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;
 
 async function writePlugin(paths, config) {
   const directory = path.join(paths.config, "opencode", "plugins"); await mkdir(directory, { recursive: true, mode: 0o700 });
@@ -66,7 +52,10 @@ async function prepare(paths, config, authSource) {
 async function importArchive(paths, config, archiveFile) { if (!archiveFile) return null; const manifest = JSON.parse(await readFile(absolute(archiveFile, "--session-archive"), "utf8")); if (manifest.schema_id !== ARCHIVE_SCHEMA || !manifest.payload) throw new DaemonError("invalid_session_archive", "OpenCode archive is incompatible"); if (manifest.opencode_version !== config.version) throw new DaemonError("session_archive_version_mismatch", "OpenCode archive version differs from the daemon version", false, { archive_version: manifest.opencode_version, current_version: config.version }); const payload = Buffer.from(manifest.payload, "base64").toString("utf8"); await writeFile(paths.archive, payload, { mode: 0o600 }); const stdout = await run(config.bin, ["import", paths.archive], config); const match = stdout.match(/ses_[A-Za-z0-9]+/); return { provider_session_id: match?.[0] ?? manifest.provider_session_id, manifest };
 }
 
-export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) { const paths = locations(stateDir), 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(paths.socket); let buffer = "", settled = false; const timer = operation === "session.prompt" ? null : observedTimeout(() => finish(new DaemonError("daemon_timeout", `${operation} timed out`, true)), timeoutMs); const finish = (error, result) => { if (settled) return; settled = true; clearTimeout(timer); client.destroy(); error ? reject(error) : resolve(result); }; client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`)); client.on("data", chunk => { buffer += chunk; const i = buffer.indexOf("\n"); if (i < 0) return; try { const response = JSON.parse(buffer.slice(0, i)); if (!response.ok) return finish(new DaemonError(response.error.code, response.error.message, 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))); }); }
+export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
+  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: 'opencode', timeoutMs });
+}
 function sameConfig(state, config) { return ["cwd","journal","bin","provider","model","variant","agent","projectRoot","ddFlowBin","ddFlowHome","sessionArchive","resourceHome","noFlow"].every(key => (state.config?.[key] ?? null) === (config[key] ?? null)); }
 export async function startDaemon(options) {
   const paths = locations(options.stateDir); await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
@@ -81,7 +70,7 @@ export async function startDaemon(options) {
   const resourceProcess = await registerDaemonProcess(config, { kind: "opencode-daemon", owner: `opencode:${path.basename(paths.dir)}`, operation: `opencode-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
   const state = { schema_id: STATE_SCHEMA, daemon_id: daemonId, shutdown_state: "starting", active_tree: false, auth_status: config.authStatus, versions: { opencode: config.version }, config, sessions: imported ? [{ provider_session_id: imported.provider_session_id, parent_provider_session_id: null, root_provider_session_id: imported.provider_session_id, cwd: config.cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess }; await writeJson(paths.state, state);
   const log = await open(paths.log, "a", 0o600), entry = absolute(options.entryPath, "dd-opencode entry"); const child = spawn(process.execPath, [entry, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
-  try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 20_000; while (Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) 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: 20_000 }); while (!startupClock.sample()) { await new Promise(resolve => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
   catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
 }
 export const stopDaemon = async 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) }); };
@@ -139,7 +128,7 @@ export class Runtime {
     try { await this.client.abort(id); } catch (error) { errors.push({ session_id: id, phase: "abort", ...errorPayload(error) }); }
     return errors;
   }
-  async dispatch(operation, params) {
+  async dispatch(operation, params, operationId = null) {
     const assertDispatch = captureDispatchGuard(this);
     if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume", "session.archive"].includes(operation)) assertDaemonDispatch(this.paths.dir);
     if (operation === "daemon.status") { const { password, ...config } = this.state.config; return { daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, auth_status: this.state.auth_status, shutdown_state: this.state.shutdown_state, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config }; }
@@ -161,7 +150,8 @@ export class Runtime {
     });
     if (operation === "session.inspect" || operation === "session.resume") { const result = await this.describe(params.sessionId); await this.persist(); return result; }
     if (operation === "session.prompt") { await this.requireSettled(params.sessionId); return this.productive(operation, async () => { assertDispatch(); const reply = await this.client.prompt(params.sessionId, { prompt: params.prompt, provider: this.state.config.provider, model: this.state.config.model, variant: this.state.config.variant, agent: this.state.config.agent,
-      assertDispatch,
+      assertDispatch, livenessTimeoutMs: params.livenessTimeoutMs ?? this.client.timeoutMs,
+      onDispatched: () => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: params.sessionId }),
       onModelMessages: (id, messages, parent) => this.observeModels(id, messages, parent),
       onObservationError: error => observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: params.sessionId, requested: this.state.config, source: "native.message_observer", evidence: "unavailable", reason: error.code ?? "observation_unavailable" })
     }); const assistant_text = reply.parts.filter(part => part.type === "text").map(part => part.text ?? "").join("");
@@ -233,17 +223,17 @@ export async function serveDaemon(stateDir) {
     scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
     scheduleDaemonProcessHeartbeat(state.config, providerProcess);
     state.provider_process = providerProcess; state.provider_pid = child.pid; await writeJson(paths.state, state);
-    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd }); const deadline = Date.now() + 15_000; while (Date.now() < deadline) { try { await client.health(); break; } catch { await new Promise(resolve => setTimeout(resolve, 100)); } } await client.health(); const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths);
+    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd }); const startupClock = new ObservationClock({ timeoutMs: 15_000 }); while (!startupClock.sample()) { try { await client.health(); break; } catch { await new Promise(resolve => setTimeout(resolve, 100)); } } await client.health(); const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths);
     const server = net.createServer(connection => {
       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));
-            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) {
@@ -260,3 +250,4 @@ export async function serveDaemon(stateDir) {
   }
 }
 import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";
+import { commandText } from "./process-json.mjs";

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,4 +1,6 @@
-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";
@@ -6,6 +8,9 @@ import net from "node:net";
 import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
 import path from "node:path";
 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"];
@@ -212,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; }
@@ -251,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
@@ -286,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 },
@@ -389,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 });
@@ -403,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
@@ -416,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) {
@@ -448,7 +436,7 @@ 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,
@@ -462,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,
@@ -479,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,
@@ -661,7 +664,7 @@ export async function serveDaemon(stateDir) {
     connection.setEncoding("utf8"); let buffer = "", consumed = false;
     connection.on("data", (chunk) => {
       if (consumed) return;
-      buffer += chunk;
+      buffer += chunk; if (!admitNativeRequestBuffer(buffer, connection, RESPONSE_SCHEMA)) { consumed = true; return; }
       const newline = buffer.indexOf("\n");
       if (newline < 0) return;
       consumed = true;
@@ -671,7 +674,7 @@ export async function serveDaemon(stateDir) {
         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`);
         } catch (error) {