@deksden-com/dd-flow-cli 0.9.0-beta.64 → 0.9.0-beta.74

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

@@ -1,4 +1,5 @@
 import { processSnapshot } from "./process-snapshot.mjs";
+import { ToolObservations, droidToolObservations, journalToolObservations } from "./tool-observations.mjs";
 export { processSnapshot } from "./process-snapshot.mjs";
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
 import { createHash, randomUUID } from "node:crypto";
@@ -19,6 +20,7 @@ import { confirmDaemonProcess, finishDaemonProcess, heartbeatDaemonProcess, regi
 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;
 export class DroidError extends Error {
   constructor(code, message, details) { super(message); this.code = code; if (details) this.details = details; }
 }
@@ -26,6 +28,8 @@ export const absolute = (value, label) => { if (!value || !path.isAbsolute(value
 export const executable = (bin, args = []) => /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args };
 const shell = value => `'${String(value).replaceAll("'", `'"'"'`)}'`;
 const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+const responseSummary = event => ({ request_id: event?.id ?? null, has_result: event?.result !== undefined,
+  result_keys: event?.result && typeof event.result === "object" && !Array.isArray(event.result) ? Object.keys(event.result).slice(0, 32) : [], error: event?.error ?? null });
 export async function readJson(file) { try { return JSON.parse(await readFile(file, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
 export function droidPaths(stateDir) {
   const dir = absolute(stateDir, "state directory"), digest = createHash("sha256").update(dir).digest("hex").slice(0, 24);
@@ -71,13 +75,10 @@ export function parseDroidTranscript(text, settings, expectedId) {
   for (const line of text.split("\n")) { if (!line.trim()) continue; try { records.push(JSON.parse(line)); } catch { complete = false; } }
   const header = records.find(record => record.type === "session_start");
   if (!header || header.id !== expectedId) throw new DroidError("session_identity_mismatch", "Droid transcript has a different or missing native Session ID", { expected_session_id: expectedId, observed_session_id: header?.id ?? null });
-  const calls = new Map(), failures = new Set();
-  for (const record of records) for (const block of record.message?.content ?? []) {
-    if (block.type === "tool_use" && typeof block.id === "string") calls.set(block.id, block.name);
-    if (block.type === "tool_result" && block.is_error && typeof block.tool_use_id === "string") failures.add(block.tool_use_id);
-  }
-  const byTool = {}; for (const name of calls.values()) byTool[name] = (byTool[name] ?? 0) + 1;
-  return { header, records, outcomes: records.filter(record => record.type === "agent_turn_outcome"), usage: physicalUsage(settings?.tokenUsage), settings, complete, tool_calls: { total: calls.size, failures: [...failures].filter(id => calls.has(id)).length, by_tool: byTool } };
+  const tools = new ToolObservations();
+  for (const record of records) for (const event of droidToolObservations(record, expectedId)) tools.add(event);
+  if (!complete) tools.gaps.add("transcript_incomplete");
+  return { header, records, outcomes: records.filter(record => record.type === "agent_turn_outcome"), usage: physicalUsage(settings?.tokenUsage), settings, complete, tool_calls: tools.summary() };
 }
 export async function readDroidSession(factory, id) {
   const file = await metadataReader(factory).locate(id);
@@ -95,7 +96,7 @@ function descendants(rows, rootPid) { const ids = new Set([rootPid]); for (;;) {
 
 export class DroidRuntime {
   constructor(config, state, persist) {
-    this.config = config; this.state = state; this.paths = droidPaths(config.stateDir); this.persist = persist; this.pending = 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;
+    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 }); }
@@ -129,13 +130,14 @@ export class DroidRuntime {
     await this.journal("native", { event });
     if (event.type === "response") {
       this.protocol ??= event.factoryProtocolVersion;
-      const pending = this.pending.get(event.id); if (!pending) return;
+      const pending = this.pending.get(event.id); if (!pending) { this.lateResponses.set(event.id, event); while (this.lateResponses.size > 128) this.lateResponses.delete(this.lateResponses.keys().next().value); await this.journal("late_response", responseSummary(event)); return; }
       this.pending.delete(event.id); clearTimeout(pending.timer);
+      if (pending.timedOut) await this.journal("late_response", { ...responseSummary(event), method: pending.method, grace_ms: LATE_RESPONSE_GRACE_MS });
       event.error ? pending.reject(new DroidError("droid_rpc_error", event.error.message ?? "Droid rejected request", event.error)) : pending.resolve(event.result ?? {}); return;
     }
     if (event.method === "droid.request_permission" || event.method === "droid.ask_user") {
       const result = event.method === "droid.request_permission" ? { selectedOption: "cancel" } : { cancelled: true, answers: [] };
-      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", type: "response", factoryApiVersion: "1.0.0", factoryProtocolVersion: DROID_PROTOCOL, id: event.id, result })}\n`);
+      this.send({ jsonrpc: "2.0", type: "response", factoryApiVersion: "1.0.0", factoryProtocolVersion: DROID_PROTOCOL, id: event.id, result });
       await this.journal("unexpected_input_rejected", { method: event.method }); return;
     }
     if (event.method !== "droid.session_notification") return;
@@ -162,11 +164,28 @@ export class DroidRuntime {
   request(method, params, id = randomUUID(), timeoutMs = 30_000) {
     if (!this.child || this.closed) return Promise.reject(new DroidError("operation_observation_lost", "Droid runtime is not connected"));
     return new Promise((resolve, reject) => {
-      const timer = observedTimeout(() => { this.pending.delete(id); reject(new DroidError("rpc_timeout", `${method} has no observed reply`, { request_id: id })); }, timeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
-      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", type: "request", factoryApiVersion: "1.0.0", factoryProtocolVersion: DROID_PROTOCOL, id, method, params })}\n`, error => { if (error) { clearTimeout(timer); this.pending.delete(id); reject(error); } });
+      const timer = observedTimeout(() => {
+        const pending = this.pending.get(id); if (!pending || pending.timedOut) return;
+        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);
+      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); }
     });
   }
+  send(value, callback) {
+    const stdin = this.child?.stdin;
+    if (!stdin || stdin.destroyed) {
+      const error = new DroidError("bridge_pipe_broken", "Droid runtime stdin is closed");
+      this.rejectPending(error);
+      throw error;
+    }
+    try { stdin.write(`${JSON.stringify(value)}\n`, callback); }
+    catch (error) { this.rejectPending(error); throw error; }
+  }
   profile(settings) {
     const model = settings?.modelId ?? settings?.model ?? null;
     const nativeModel = this.models?.find(item => (item.id ?? item.modelId) === model);
@@ -279,8 +298,15 @@ export class DroidRuntime {
       assertDispatch();
       await this.request("droid.add_user_message", { text: prompt, messageId: turnId }, requestId);
       const outcome = await completed; await this.draining;
-      const receipt = await this.inspect(id, { ignoreActive: true });
-      return { ...receipt, result: { ...outcome, status: status(outcome.reason) }, assistant_text: current.text, turn_id: turnId };
+      try {
+        const receipt = await this.inspect(id, { ignoreActive: true });
+        return { ...receipt, result: { ...outcome, status: status(outcome.reason) }, assistant_text: current.text, turn_id: turnId };
+      } catch (error) {
+        // A terminal native outcome is durable independently of a later
+        // filesystem/topology observation.  Preserve it and let settlement
+        // reconcile; do not convert it into a failed prompt.
+        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" }); }
@@ -292,16 +318,23 @@ export class DroidRuntime {
     const native = await readDroidSession(this.paths.factory, binding.provider_session_id);
     const outcome = native?.outcomes.find(item => item.turnId === binding.turn_id);
     if (!outcome || !terminal(outcome.reason)) return null;
-    const receipt = await this.inspect(binding.provider_session_id, { ignoreActive: true });
-    if (!receipt.settled) return null;
+    let receipt;
+    try { receipt = await this.inspect(binding.provider_session_id, { ignoreActive: true }); }
+    catch (error) {
+      receipt = { provider_session_id: binding.provider_session_id, adapter_session_id: binding.provider_session_id, settled: false, settlement_observation_error: errorRecord(error) };
+    }
+    // A terminal root turn is not enough to recover the operation while a
+    // child Task or owned provider process is still active.  Leave the
+    // durable binding for the normal settlement observer instead of exposing
+    // a misleading successful receipt.
+    if (receipt.settled !== true) return null;
     const current = this.active;
     if (current?.operationId === operationId && current.turnId === binding.turn_id) {
       current.outcome = outcome; this.lastResult = outcome;
       await this.saveBinding(current, { native_outcome: outcome });
       current.resolve(outcome);
-      // Let the original dispatch persist its one terminal reply and release
-      // daemon busy. The next inspection reads that receipt; do not race it
-      // with a second writer or expose success while prompt still owns busy.
+      // Let the original dispatch persist its one terminal reply. Settlement
+      // is reconciled separately; do not race a second writer or replay it.
       return null;
     }
     return { ...receipt, result: { ...outcome, status: status(outcome.reason) }, assistant_text: binding.assistant_text ?? "", turn_id: binding.turn_id, recovered_from: "native.agent_turn_outcome" };
@@ -343,6 +376,8 @@ export class DroidRuntime {
   }
   async snapshotUsage(id) {
     const native = await readDroidSession(this.paths.factory, id); if (!native) return { status: "unavailable", provider_session_id: id };
+    this.journaledTools ??= new Map();
+    journalToolObservations(this.config.journal, [...native.records.flatMap(record => droidToolObservations(record, id)), ...native.tool_calls.reasons.map(reason => ({ reason }))], this.journaledTools);
     const measured = native.usage;
     const payload = { provider_session_id: id, daemon_id: this.config.daemonId, observed_at: new Date().toISOString(), usage_scope: "physical_session", completeness: native.complete && measured ? "complete" : "partial", usage: measured, tool_calls: native.tool_calls, source: { path: native.transcript_path, sha256: native.source_sha256 } };
     if (measured && this.config.ddFlowBin) await this.flow("usage", "ingest", payload);

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

@@ -1,4 +1,5 @@
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
+import { ToolObservations, acpToolObservation } from "./tool-observations.mjs";
 import { observedTimeout } from "./observation-clock.mjs";
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, copyFile, cp, lstat, mkdir, open, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
@@ -198,7 +199,7 @@ export class Runtime {
     }
   }
   topology(root) { return [...this.descendants.values()].filter((child) => child.parent_provider_session_id === root); }
-  observeToolCall(message) { const sessionId = message?.params?.sessionId; const update = message?.params?.update; const id = update?.toolCallId; if (!sessionId || !id) return; this.toolEvents ??= new Map(); const events = this.toolEvents.get(sessionId) ?? { calls: new Map(), failed: new Set() }; if (update.sessionUpdate === "tool_call") events.calls.set(id, update?._meta?.["x.ai/tool"]?.name ?? update?._meta?.claudeCode?.toolName ?? update.title?.split(":", 1)[0] ?? "unknown"); if (update.sessionUpdate === "tool_call_update" && ["failed", "error"].includes(update.status)) events.failed.add(id); this.toolEvents.set(sessionId, events); const by_tool = {}; for (const name of events.calls.values()) by_tool[name] = (by_tool[name] ?? 0) + 1; this.toolUsage.set(sessionId, { total: events.calls.size, failures: events.failed.size, by_tool }); }
+  observeToolCall(message) { this.toolObservations ??= new ToolObservations(); this.toolObservations.add(acpToolObservation(message, { harness: "grok-acp" })); const sessionId = message?.params?.sessionId; if (sessionId) this.toolUsage.set(sessionId, this.toolObservations.summary(sessionId)); }
   running(result) { return result?.evidence?.subagents?.subagents ?? result?.subagents?.subagents ?? []; }
   treeRunning(result) {
     const evidence = result?.evidence ?? result;
@@ -232,7 +233,7 @@ export class Runtime {
     return running;
   }
   async requireSettled() { const running = await this.refreshTree(); if (running.length) throw new DaemonError("tree_not_settled", "daemon still owns a running Session tree", false, { sessions: running }); }
-  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; for (const session of this.sessions.values()) session.native_root_receipt = null; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); this.track(result); const session = this.sessions.get(result.provider_session_id); if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id }; await this.persist({ active_tree: this.treeRunning(result), active_operation: null }); return { ...result, descendants: this.topology(result.provider_session_id) }; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); throw error; } finally { this.active = null; } }
+  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; for (const session of this.sessions.values()) session.native_root_receipt = null; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); this.track(result); const running = this.treeRunning(result); const session = this.sessions.get(result.provider_session_id); if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id }; await this.persist({ active_tree: running, active_operation: null }); return { ...result, descendants: this.topology(result.provider_session_id), settled: !running }; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); throw error; } finally { this.active = null; } }
   async dispatch(operation, params) {
     const assertDispatch = captureDispatchGuard(this);
     if (operation === "daemon.status") { let observationError; if (!this.active) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { observation_error: observationError ?? null, daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, config_isolation: this.state.config_isolation, shutdown_state: this.state.shutdown_state, recovery_status: this.state.recovery_status, auth_status: this.state.auth_status, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config: this.state.config }; }

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

@@ -29,13 +29,13 @@ function unwrap(value) { return value?.result ?? value ?? {}; }
 function extension(method) { return method.startsWith("_") ? method : `_${method}`; }
 function usageScope(options, providerSessionId) { return providerSessionId === options.rootProviderSessionId ? "execution_tree_inclusive" : "physical_session"; }
 function emptyToolCalls() { return { total: 0, failures: 0, by_tool: {} }; }
-function sessionToolCalls(options, bridge, sessionId) { return options.toolUsage ? (options.toolUsage.get(sessionId) ?? emptyToolCalls()) : bridge.toolSummary(); }
+function sessionToolCalls(options, bridge, sessionId) { return options.toolUsage ? (options.toolUsage.get(sessionId) ?? emptyToolCalls()) : bridge.toolSummary(sessionId); }
 function recordToolCalls(options, bridge, sessionId, cursor) {
   const result = options.toolUsage
     ? sessionToolCalls(options, bridge, sessionId)
     : typeof bridge.toolSummarySince === "function"
-      ? bridge.toolSummarySince(cursor)
-      : bridge.toolSummary();
+      ? bridge.toolSummarySince(cursor, sessionId)
+      : bridge.toolSummary(sessionId);
   options.toolUsage?.set(sessionId, result);
   return result;
 }
@@ -45,6 +45,7 @@ function bridgeOptions(options) {
   const grokHome = options.grokHome ? absolute(options.grokHome, "--grok-home") : null;
   return {
     ...options,
+    observationHarness: "grok-acp",
     // AcpBridge defaults to zcode-acp; Grok must always name its own executable.
     bin: options.bin ?? process.env.DD_GROK_BIN ?? "grok",
     commandArgs: ["agent", "--no-leader", "--always-approve", "--model", requested.model ?? "grok-4.6", "--reasoning-effort", requested.reasoning ?? "high", "stdio"],
@@ -91,6 +92,11 @@ async function forwardUsage(options, providerSessionId, usage, toolCalls) {
   });
 }
 
+async function forwardUsageBestEffort(options, providerSessionId, usage, toolCalls) {
+  try { await forwardUsage(options, providerSessionId, usage, toolCalls); return null; }
+  catch (error) { return { code: error.code ?? "usage_ingest_failed", message: error.message ?? String(error) }; }
+}
+
 async function identity(bridge, options) {
   const sessionId = text(options.sessionId, "--session-id");
   if (!options.liveSession) await bridge.request("session/load", { sessionId, cwd: absolute(options.cwd, "--cwd"), mcpServers: [] });
@@ -136,24 +142,24 @@ export async function createSessionWithBridge(bridge, options, initialized) {
   await observeModel({ journal: options.journal, harness: "grok-acp", sessionId: providerSessionId, requested, observed: observedProfile(initialized, requested), source: "acp.initialize.modelState" });
   const profileReceipt = assertProfile(requested, observedProfile(initialized, requested));
   await options.onSessionCreated?.({ provider_session_id: providerSessionId, adapter_session_id: providerSessionId, cwd });
-  const local = { ...options, initialized, rootProviderSessionId: providerSessionId }; await forwardUsage(local, providerSessionId, await sessionUsage(bridge, providerSessionId), sessionToolCalls(local, bridge, providerSessionId));
-  await bridge.flush(); const evidence = await inspect(bridge, providerSessionId, local); evidence.tool_calls = sessionToolCalls(local, bridge, providerSessionId); await forwardUsage(local, providerSessionId, evidence.usage, evidence.tool_calls);
+  const local = { ...options, initialized, rootProviderSessionId: providerSessionId }; const initial_usage_error = await forwardUsageBestEffort(local, providerSessionId, await sessionUsage(bridge, providerSessionId), sessionToolCalls(local, bridge, providerSessionId));
+  await bridge.flush(); const evidence = await inspect(bridge, providerSessionId, local); evidence.tool_calls = sessionToolCalls(local, bridge, providerSessionId); const usage_ingest_error = await forwardUsageBestEffort(local, providerSessionId, 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;
   return receipt(options, { harness: "grok-acp", runtime_family: "grok", provider_session_id: providerSessionId, adapter_session_id: providerSessionId, cwd, initialized, profile: profileReceipt, evidence });
 }
 
 export async function promptSession(options) { requireJournal(options); return await withBridge(options, async (bridge, initialized) => await promptSessionWithBridge(bridge, { ...options, initialized })); }
 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 }; await forwardUsage(local, sessionId, await sessionUsage(bridge, sessionId), sessionToolCalls(local, bridge, sessionId));
+  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();
-  const evidence = await inspect(bridge, sessionId, local); evidence.tool_calls = recordToolCalls(local, bridge, sessionId, cursor); await forwardUsage(local, sessionId, evidence.usage, evidence.tool_calls);
+  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 });
 }
 
 export async function inspectSession(options) { requireJournal(options); return await withBridge(options, async (bridge, initialized) => await inspectSessionWithBridge(bridge, { ...options, initialized })); }
-export async function inspectSessionWithBridge(bridge, options) { requireJournal(options); const sessionId = await identity(bridge, options); const evidence = await inspect(bridge, sessionId, options); evidence.tool_calls = sessionToolCalls(options, bridge, sessionId); await forwardUsage(options, sessionId, evidence.usage, evidence.tool_calls); return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, ...evidence }); }
+export async function inspectSessionWithBridge(bridge, options) { requireJournal(options); const sessionId = await identity(bridge, options); const evidence = await inspect(bridge, sessionId, options); evidence.tool_calls = sessionToolCalls(options, bridge, sessionId); const usage_ingest_error = await forwardUsageBestEffort(options, sessionId, evidence.usage, evidence.tool_calls); if (usage_ingest_error) evidence.usage_ingest_error = usage_ingest_error; return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, ...evidence }); }
 export async function cancelSession(options) { requireJournal(options); return await withBridge(options, async (bridge) => await cancelSessionWithBridge(bridge, options)); }
 export async function cancelSessionWithBridge(bridge, options) { requireJournal(options); const sessionId = await identity(bridge, options); return receipt(options, { harness: "grok-acp", provider_session_id: sessionId, adapter_session_id: sessionId, ...await cancelTree(bridge, sessionId) }); }
 export async function forkSession(options) { requireJournal(options); return await withBridge(options, async (bridge) => await forkSessionWithBridge(bridge, options)); }

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

@@ -1,4 +1,5 @@
 import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
+import { openCodeToolObservation, journalToolObservations } from "./tool-observations.mjs";
 import { observedTimeout } 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";
@@ -68,7 +69,7 @@ export class Runtime {
   persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.then(async () => { await writeJson(this.paths.state, snapshot); await heartbeatDaemonProcess(snapshot.config, snapshot.resource_process).catch(() => {}); await heartbeatDaemonProcess(snapshot.config, this.providerProcess).catch(() => {}); }); return this.persisting; }
   async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
   async childTree(id, seen = new Set()) { if (seen.has(id)) return []; seen.add(id); const direct = await this.client.children(id) ?? []; const nested = []; for (const child of direct) nested.push(child, ...await this.childTree(child.id, seen)); return nested; }
-  async describe(id) { const [info, messages, children, statuses] = await Promise.all([this.client.inspect(id), this.client.messages(id), this.childTree(id), this.client.statuses()]); if (path.resolve(info.directory) !== path.resolve(this.state.config.cwd)) throw new DaemonError("foreign_session", "OpenCode Session directory is outside the controlled workspace", false, { session_directory: info.directory, workspace: this.state.config.cwd }); const status = statuses?.[id]?.type ?? "idle", parent = info.parentID ?? null, existing = this.sessions.get(id); const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: parent ? (this.sessions.get(parent)?.root_provider_session_id ?? parent) : (existing?.root_provider_session_id ?? id), cwd: info.directory }; this.sessions.set(id, record); for (const child of children) if (!this.sessions.has(child.id)) this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: child.parentID ?? id, root_provider_session_id: record.root_provider_session_id, cwd: child.directory }); const unsettledChildren = children.filter(child => (statuses?.[child.id]?.type ?? "idle") !== "idle").map(child => child.id); const lastAssistant = messages.findLast(message => message.info?.role === "assistant"); const assistantText = (lastAssistant?.parts ?? []).filter(part => part.type === "text").map(part => part.text ?? "").join(""); await this.observeModels(id, messages, parent); return { ...record, observed_profile: { provider: lastAssistant?.info?.providerID ?? null, model: lastAssistant?.info?.modelID ?? null, reasoning: lastAssistant?.info?.variant ?? null, mode: info.agent ?? null }, assistant_text: assistantText, info, status, settled: status === "idle" && unsettledChildren.length === 0, unsettled_children: unsettledChildren, children, usage: usageSnapshot(messages), history_sha256: historyDigest(messages), message_count: messages.length }; }
+  async describe(id) { const [info, messages, children, statuses] = await Promise.all([this.client.inspect(id), this.client.messages(id), this.childTree(id), this.client.statuses()]); if (path.resolve(info.directory) !== path.resolve(this.state.config.cwd)) throw new DaemonError("foreign_session", "OpenCode Session directory is outside the controlled workspace", false, { session_directory: info.directory, workspace: this.state.config.cwd }); const status = statuses?.[id]?.type ?? "idle", parent = info.parentID ?? null, existing = this.sessions.get(id); const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: parent ? (this.sessions.get(parent)?.root_provider_session_id ?? parent) : (existing?.root_provider_session_id ?? id), cwd: info.directory }; this.sessions.set(id, record); for (const child of children) if (!this.sessions.has(child.id)) this.sessions.set(child.id, { provider_session_id: child.id, parent_provider_session_id: child.parentID ?? id, root_provider_session_id: record.root_provider_session_id, cwd: child.directory }); const unsettledChildren = children.filter(child => (statuses?.[child.id]?.type ?? "idle") !== "idle").map(child => child.id); const lastAssistant = messages.findLast(message => message.info?.role === "assistant"); const assistantText = (lastAssistant?.parts ?? []).filter(part => part.type === "text").map(part => part.text ?? "").join(""); await this.observeModels(id, messages, parent); this.journaledTools ??= new Map(); journalToolObservations(this.state.config.journal, messages.flatMap(message => (message.parts ?? []).map(part => openCodeToolObservation(part, id, message.info?.id))), this.journaledTools); return { ...record, observed_profile: { provider: lastAssistant?.info?.providerID ?? null, model: lastAssistant?.info?.modelID ?? null, reasoning: lastAssistant?.info?.variant ?? null, mode: info.agent ?? null }, assistant_text: assistantText, info, status, settled: status === "idle" && unsettledChildren.length === 0, unsettled_children: unsettledChildren, children, usage: usageSnapshot(messages, id), history_sha256: historyDigest(messages), message_count: messages.length }; }
   async observeModels(id, messages, parent = null) {
     this.modelMessages ??= new Set();
     for (const message of messages ?? []) {
@@ -82,7 +83,7 @@ export class Runtime {
     }
   }
   async requireSettled(id) { const value = await this.describe(id); if (!value.settled) throw new DaemonError("tree_not_settled", "OpenCode Session is not idle", false, { session_id: id, status: value.status }); return value; }
-  async reconcileUsage(observed) { await forwardUsage(this.state.config, observed.provider_session_id, observed.usage); for (const child of observed.children.filter(item => (item.parentID ?? observed.provider_session_id) === observed.provider_session_id)) await this.reconcileUsage(await this.describe(child.id)); }
+  async reconcileUsage(observed) { const errors = []; try { await forwardUsage(this.state.config, observed.provider_session_id, observed.usage); } catch (error) { errors.push({ session_id: observed.provider_session_id, phase: "usage", ...errorPayload(error) }); } for (const child of observed.children.filter(item => (item.parentID ?? observed.provider_session_id) === observed.provider_session_id)) { try { errors.push(...await this.reconcileUsage(await this.describe(child.id))); } catch (error) { errors.push({ session_id: child.id, phase: "usage_child", ...errorPayload(error) }); } } return errors; }
   async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); await this.persist({ active_tree: !result?.settled, active_operation: null }); await this.journal(name, result); return result; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); await this.journal(`${name}.failed`, null); throw error; } finally { this.active = null; } }
   async cancelTree(id, seen = new Set()) {
     if (seen.has(id)) return [];
@@ -102,18 +103,52 @@ export class Runtime {
     const assertDispatch = captureDispatchGuard(this);
     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 }; }
     if (operation === "daemon.doctor") { const doc = await this.client.request("GET", "/doc", undefined, { directory: null, timeoutMs: 5_000 }); const apiFingerprint = createHash("sha256").update(typeof doc === "string" ? doc : JSON.stringify(doc)).digest("hex"); if (apiFingerprint !== OPENCODE_BASELINE.api_fingerprint) throw new DaemonError("api_fingerprint_mismatch", "OpenCode API differs from the qualified baseline", false, { expected: OPENCODE_BASELINE.api_fingerprint, actual: apiFingerprint }); return { compatible: true, versions: this.state.versions, api_fingerprint: apiFingerprint, plugin_sha256: this.state.config.pluginSha256, auth_status: this.state.auth_status }; }
-    if (operation === "session.create") return this.productive(operation, async () => { const info = await this.client.create(params.title); this.sessions.set(info.id, { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.parentID ?? null, root_provider_session_id: info.id, cwd: info.directory }); const result = await this.describe(info.id); await this.reconcileUsage(result); return result; });
+    if (operation === "session.create") return this.productive(operation, async () => {
+      const info = await this.client.create(params.title);
+      const created = { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.parentID ?? null, root_provider_session_id: info.id, cwd: info.directory };
+      this.sessions.set(info.id, created);
+      try {
+        const result = await this.describe(info.id);
+        result.usage_ingest_errors = await this.reconcileUsage(result);
+        return result;
+      } catch (error) {
+        // The Session exists even if its optional post-create observation is
+        // temporarily unavailable.  Preserve the identity; a later inspect
+        // owns any profile/topology proof required before a prompt.
+        return { ...created, settled: false, settlement_observation_error: errorPayload(error) };
+      }
+    });
     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,
       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 result = await this.describe(params.sessionId);
-      result.assistant_text = reply.parts.filter(part => part.type === "text").map(part => part.text ?? "").join("");
+    }); const assistant_text = reply.parts.filter(part => part.type === "text").map(part => part.text ?? "").join("");
+      const reply_profile = { provider: reply.info.providerID ?? null, model: reply.info.modelID ?? null, reasoning: reply.info.variant ?? null, mode: this.state.config.agent ?? null };
+      checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: this.state.config.agent }, reply_profile);
+      let result;
+      try { result = await this.describe(params.sessionId); }
+      catch (error) { return { provider_session_id: params.sessionId, adapter_session_id: params.sessionId, assistant_text, response_message_id: reply.info.id, observed_profile: reply_profile, settled: false, settlement_observation_error: errorPayload(error) }; }
+      result.assistant_text = assistant_text;
       result.response_message_id = reply.info.id;
-      result.observed_profile = { provider: reply.info.providerID ?? null, model: reply.info.modelID ?? null, reasoning: reply.info.variant ?? null, mode: result.info.agent ?? null };
-      checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: this.state.config.agent }, result.observed_profile); await this.reconcileUsage(result); return result; }); }
-    if (operation === "session.fork") { const source = await this.requireSettled(params.sessionId); return this.productive(operation, async () => { const info = await this.client.fork(params.sessionId, params.messageId); const fork = await this.describe(info.id); const sourceMessages = await this.client.messages(params.sessionId), forkMessages = await this.client.messages(info.id); const prefix = JSON.stringify(canonicalHistory(forkMessages)) === JSON.stringify(canonicalHistory(sourceMessages).slice(0, forkMessages.length)); if (!prefix) throw new DaemonError("fork_continuity_failed", "fork history is not a source prefix"); return { ...fork, fork_receipt: { source_provider_session_id: params.sessionId, source_history_sha256: source.history_sha256, fork_history_sha256: fork.history_sha256, history_prefix_proven: true } }; }); }
+      result.observed_profile = { ...reply_profile, mode: result.info.agent ?? reply_profile.mode };
+      checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: this.state.config.agent }, result.observed_profile); result.usage_ingest_errors = await this.reconcileUsage(result); return result; }); }
+    if (operation === "session.fork") { const source = await this.requireSettled(params.sessionId); return this.productive(operation, async () => {
+      const info = await this.client.fork(params.sessionId, params.messageId);
+      const created = { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.parentID ?? params.sessionId, root_provider_session_id: this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId, cwd: info.directory };
+      this.sessions.set(info.id, created);
+      try {
+        const fork = await this.describe(info.id);
+        const sourceMessages = await this.client.messages(params.sessionId), forkMessages = await this.client.messages(info.id);
+        const prefix = JSON.stringify(canonicalHistory(forkMessages)) === JSON.stringify(canonicalHistory(sourceMessages).slice(0, forkMessages.length));
+        if (!prefix) throw new DaemonError("fork_continuity_failed", "fork history is not a source prefix");
+        return { ...fork, fork_receipt: { source_provider_session_id: params.sessionId, source_history_sha256: source.history_sha256, fork_history_sha256: fork.history_sha256, history_prefix_proven: true } };
+      } catch (error) {
+        // A native fork is materialized already.  Do not lose its identity or
+        // retry it, but never let an unproven history prefix become usable.
+        return { ...created, settled: false, fork_receipt: { source_provider_session_id: params.sessionId, source_history_sha256: source.history_sha256, history_prefix_proven: false }, fork_continuity_error: errorPayload(error) };
+      }
+    }); }
     if (operation === "session.cancel") {
       if (!this.sessions.has(params.sessionId)) throw new DaemonError("foreign_session", "cannot cancel a Session without daemon ownership");
       cancelPendingDispatch(this);

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

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { ToolObservations, openCodeToolObservation } from "./tool-observations.mjs";
 import { observedTimeout } from "./observation-clock.mjs";
 
 export class OpenCodeError extends Error {
@@ -89,9 +90,9 @@ export function canonicalHistory(messages) {
   return messages.map(({ info, parts }) => ({ role: info.role, ...(info.role === "assistant" ? { provider: info.providerID, model: info.modelID, mode: info.mode, finish: info.finish ?? null, error: info.error?.name ?? null } : {}), parts: parts.map(stablePart) }));
 }
 export function historyDigest(messages) { return createHash("sha256").update(JSON.stringify(canonicalHistory(messages))).digest("hex"); }
-export function usageSnapshot(messages) {
+export function usageSnapshot(messages, sessionId) {
   const assistants = messages.filter((item) => item.info?.role === "assistant"); const tokens = assistants.reduce((sum, item) => { const value = item.info.tokens ?? {}; const cache = value.cache ?? {}; sum.input += value.input ?? 0; sum.output += value.output ?? 0; sum.reasoning += value.reasoning ?? 0; sum.cache_read += cache.read ?? 0; sum.cache_write += cache.write ?? 0; return sum; }, { input: 0, output: 0, reasoning: 0, cache_read: 0, cache_write: 0 });
-  const calls = new Map(); let failures = 0; for (const item of messages) for (const part of item.parts ?? []) if (part.type === "tool") { calls.set(part.id ?? `${item.info.id}:${calls.size}`, part.tool ?? "unknown"); if (["error", "failed"].includes(part.state?.status)) failures += 1; }
-  const by_tool = {}; for (const tool of calls.values()) by_tool[tool] = (by_tool[tool] ?? 0) + 1;
-  return { input_tokens: tokens.input, output_tokens: tokens.output, reasoning_tokens: tokens.reasoning, cached_input_tokens: tokens.cache_read, cache_write_tokens: tokens.cache_write, total_tokens: tokens.input + tokens.output + tokens.reasoning + tokens.cache_read + tokens.cache_write, tool_calls: { total: calls.size, failures, by_tool }, cost_usd: assistants.reduce((sum, item) => sum + (item.info.cost ?? 0), 0) };
+  const tools = new ToolObservations();
+  for (const item of messages) for (const part of item.parts ?? []) tools.add(openCodeToolObservation(part, item.info?.sessionID ?? sessionId, item.info?.id));
+  return { input_tokens: tokens.input, output_tokens: tokens.output, reasoning_tokens: tokens.reasoning, cached_input_tokens: tokens.cache_read, cache_write_tokens: tokens.cache_write, total_tokens: tokens.input + tokens.output + tokens.reasoning + tokens.cache_read + tokens.cache_write, tool_calls: tools.summary(), cost_usd: assistants.reduce((sum, item) => sum + (item.info.cost ?? 0), 0) };
 }