@deksden-com/dd-flow-cli 0.9.0-beta.16 → 0.9.0-beta.161

package/dist/harness-runtime/lib/tool-observations.d.mts

@@ -0,0 +1,21 @@
+export interface ToolEvent {
+  session?: { harness_id: string; session_id: string };
+  call_id?: string;
+  status?: string;
+  name?: string;
+  reason?: string;
+  [key: string]: unknown;
+}
+export function classifyCodexItem(type: unknown): "tool" | "non_tool" | "unknown";
+export class ToolObservations {
+  calls: Map<string, ToolEvent>;
+  turns: Map<string, { session: { harness_id: string; session_id: string }; turn_id: string; started: boolean; completed: boolean }>;
+  gaps: Set<string>;
+  sources: Map<string, ToolEvent>;
+  add(event: ToolEvent | null): void;
+  observeTurn(event: { session: { harness_id: string; session_id: string }; turn_id: string; started?: boolean; completed?: boolean }): void;
+  summary(sessionId?: string, cursor?: Set<string>): { total: number; failures: number; pending: number; by_tool: Record<string, number>; completeness: string; outcome_completeness: string; sessions: Array<{ session: { harness_id: string; session_id: string }; total: number; failures: number; pending: number; by_tool: Record<string, number> }>; reasons: string[] };
+  cursor(): Set<string>;
+}
+export function codexToolObservation(record: Record<string, unknown>, sessionId: string): ToolEvent | null;
+export function replayToolJournal(file: string, options: { harness: string; rootSessionId: string; adapterSessionId?: string; text?: string; expectedSessionIds?: string[] }, reducer?: ToolObservations): ToolObservations;

package/dist/harness-runtime/lib/tool-observations.mjs

@@ -0,0 +1,238 @@
+import fs from "node:fs";
+
+/** Canonical physical-session tool accounting. Native decoding lives below;
+ * consumers never have to inspect provider envelopes or aggregate tokens. */
+export class ToolObservations {
+  constructor() { this.calls = new Map(); this.turns = new Map(); this.gaps = new Set(); this.transcriptSessions = new Set(); this.sources = new Map(); }
+  observeTurn(event) {
+    if (!event?.session?.harness_id || !event.session.session_id || !event.turn_id) { this.gaps.add("turn_identity_missing"); return; }
+    const key = JSON.stringify([event.session, event.turn_id]);
+    const old = this.turns.get(key);
+    this.turns.set(key, { ...old, ...event, started: old?.started || event.started || false,
+      completed: old?.completed || event.completed || false });
+  }
+  add(event) {
+    if (!event) return;
+    if (event.reason) this.gaps.add(event.reason);
+    if (event.source_observed && event.session?.harness_id && event.session?.session_id) { this.sources.set(JSON.stringify(event.session), event); return; }
+    if (event.reason && !event.call_id) return;
+    const { harness_id, session_id } = event.session ?? {};
+    if (!harness_id || !session_id || !event.call_id) { this.gaps.add("tool_identity_missing"); return; }
+    const key = JSON.stringify([harness_id, session_id, event.epoch ?? "", event.call_id]);
+    const physical = JSON.stringify([harness_id, session_id]);
+    if (event.source?.channel === "agy.native_transcript") {
+      this.transcriptSessions.add(physical);
+      for (const [oldKey, call] of this.calls) if (JSON.stringify([call.session.harness_id, call.session.session_id]) === physical && call.source?.channel !== "agy.native_transcript") {
+        this.calls.delete(oldKey); this.gaps.add("agy_live_transcript_correlation_unproven");
+      }
+    } else if (this.transcriptSessions.has(physical)) { this.gaps.add("agy_live_transcript_correlation_unproven"); return; }
+    const old = this.calls.get(key);
+    // Replay and late starts cannot undo a terminal outcome. Conflicting
+    // terminal facts remain visible rather than silently choosing success.
+    const proven = value => ["completed", "failed"].includes(value);
+    if (old && proven(old.status) && proven(event.status) && old.status !== event.status) this.gaps.add("conflicting_tool_outcomes");
+    this.calls.set(key, { ...old, ...event, name: event.name ?? old?.name ?? "unknown",
+      status: old?.status === "failed" || event.status === "failed" ? "failed"
+        : old?.status === "completed" || event.status === "completed" ? "completed"
+        : old?.status === "unknown" || event.status === "unknown" ? "unknown" : "running" });
+  }
+  summary(sessionId, cursor) {
+    const by_tool = Object.create(null), sessions = new Map(), reasons = new Set(this.gaps); let total = 0, failures = 0, pending = 0;
+    for (const [key, value] of this.calls) {
+      if (sessionId !== undefined && value.session.session_id !== sessionId || cursor?.has(key)) continue;
+      const id = JSON.stringify(value.session);
+      if (value.name === "unknown") reasons.add("tool_start_missing");
+      const session = sessions.get(id) ?? { session: value.session, parent_session: value.parent_session ?? null, total: 0, failures: 0, pending: 0, by_tool: Object.create(null) };
+      total++; session.total++; by_tool[value.name] = (by_tool[value.name] ?? 0) + 1; session.by_tool[value.name] = (session.by_tool[value.name] ?? 0) + 1;
+      if (value.status === "failed") { failures++; session.failures++; }
+      if (!["completed", "failed"].includes(value.status)) { pending++; session.pending++; }
+      sessions.set(id, session);
+    }
+    if (!cursor) for (const turn of this.turns.values()) {
+      if (sessionId !== undefined && turn.session.session_id !== sessionId) continue;
+      const id = JSON.stringify(turn.session);
+      sessions.set(id, sessions.get(id) ?? { session: turn.session, parent_session: null, total: 0, failures: 0, pending: 0, by_tool: {} });
+      if (!turn.started || !turn.completed) reasons.add("turn_lifecycle_incomplete");
+    }
+    if (!cursor) for (const [id, event] of this.sources) {
+      if (sessionId !== undefined && event.session.session_id !== sessionId) continue;
+      sessions.set(id, sessions.get(id) ?? { session: event.session, parent_session: event.parent_session ?? null, total: 0, failures: 0, pending: 0, by_tool: {} });
+    }
+    return { schema_id: "dd-flow/tool-summary@1", scope: "physical_sessions", measurement: "observed_invocations", origin: "native_tool_events", aggregation: cursor ? "delta" : "cumulative", total, failures, pending, by_tool,
+      sessions: [...sessions.values()], completeness: reasons.size ? "partial" : "complete", outcome_completeness: pending ? "partial" : "complete", reasons: [...reasons] };
+  }
+  cursor() { return new Set(this.calls.keys()); }
+}
+
+/** For adapters whose raw transcript is not portable, retain only normalized
+ * tool facts in the existing owned journal. Repeated snapshots are idempotent. */
+export function journalToolObservations(file, events, previous) {
+  const batch = new ToolObservations();
+  for (const event of events) batch.add(event);
+  const records = [...batch.calls.values(), ...batch.sources.values(), ...[...batch.gaps].map(reason => ({ reason }))];
+  for (const event of records) {
+    const key = JSON.stringify([event.session, event.epoch, event.call_id, event.reason]);
+    const encoded = JSON.stringify(event);
+    if (previous.get(key) === encoded) continue;
+    fs.appendFileSync(file, `${JSON.stringify({ kind: "tool_observation", schema_id: "dd-flow/tool-observation@1", observed_at: new Date().toISOString(), event })}\n`, { mode: 0o600 });
+    previous.set(key, encoded);
+  }
+}
+
+const identity = (harness_id, session_id) => ({ harness_id, session_id });
+const status = value => ["error", "failed", "ERROR"].includes(value) ? "failed" : ["completed", "success", "DONE"].includes(value) ? "completed"
+  : value === undefined || value === null || ["running", "pending", "in_progress", "inProgress", "RUNNING", "PENDING", "IN_PROGRESS"].includes(value) ? "running" : "unknown";
+const nativeStatus = value => ({ status: status(value), ...(status(value) === "unknown" ? { reason: "tool_status_unsupported" } : {}) });
+export function zcodePhysicalSession(update, rootSessionId) {
+  const native = update?._meta?.zcodeRuntime ?? {};
+  if (native.source === "subagent" && !native.childSessionId) return null;
+  return native.childSessionId ?? rootSessionId;
+}
+
+export function acpToolObservation(message, { harness = "zcode-acp", rootSessionId, adapterSessionId } = {}) {
+  if (!["session/update", "_x.ai/session_notification"].includes(message?.method)) return null;
+  const update = message.params?.update;
+  if (!["tool_call", "tool_call_update"].includes(update?.sessionUpdate)) return null;
+  const transport = message.params?.sessionId;
+  if (adapterSessionId && transport !== adapterSessionId) return null;
+  const root = rootSessionId ?? transport;
+  const session = harness === "zcode-acp" ? zcodePhysicalSession(update, root) : harness === "grok-acp" ? transport : root;
+  if (!session || !update.toolCallId) return { reason: "tool_identity_missing" };
+  return { session: identity(harness, session), parent_session: session !== root ? identity(harness, root) : null,
+    transport_session_id: transport, call_id: update.toolCallId, name: update._meta?.["x.ai/tool"]?.name ?? update._meta?.claudeCode?.toolName ?? update.title?.split(":", 1)[0], ...nativeStatus(update.status) };
+}
+
+export function droidToolObservations(record, sessionId) {
+  return (Array.isArray(record.message?.content) ? record.message.content : []).flatMap(block => {
+    if (block.type === "tool_use") return [{ session: identity("droid-cli", sessionId), call_id: block.id, name: block.name, status: "running" }];
+    if (block.type === "tool_result") return [{ session: identity("droid-cli", sessionId), call_id: block.tool_use_id, status: block.is_error ? "failed" : "completed" }];
+    return [];
+  });
+}
+
+export function codexToolObservation(record, sessionId) {
+  if (record.type !== "response_item") return null;
+  const p = record.payload ?? {};
+  if (["function_call", "custom_tool_call"].includes(p.type)) return { session: identity("codex-desktop", sessionId), call_id: p.call_id, name: p.name, status: "running" };
+  if (["function_call_output", "custom_tool_call_output"].includes(p.type)) {
+    return { session: identity("codex-desktop", sessionId), call_id: p.call_id, status: structuredFailure(p.output) ? "failed" : "unknown" };
+  }
+  return null;
+}
+
+function structuredFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  return value.ok === false || value.is_error === true || value.isError === true || value.error === true
+    || typeof value.exit_code === "number" && value.exit_code !== 0;
+}
+
+const codexTools = new Set(["commandExecution", "fileChange", "mcpToolCall", "dynamicToolCall", "collabAgentToolCall", "webSearch", "imageView", "imageGeneration", "sleep"]);
+const codexNonTools = new Set(["userMessage", "hookPrompt", "agentMessage", "functionCallOutput", "plan", "reasoning", "subAgentActivity", "enteredReviewMode", "exitedReviewMode", "contextCompaction"]);
+export function classifyCodexItem(type) {
+  return codexTools.has(type) ? "tool" : codexNonTools.has(type) ? "non_tool" : "unknown";
+}
+export function codexAppServerObservation(message) {
+  if (!["item/started", "item/completed"].includes(message?.method)) return null;
+  const { threadId, turnId, item } = message.params ?? {};
+  if (!item || classifyCodexItem(item.type) === "non_tool") return null;
+  if (classifyCodexItem(item.type) === "unknown") return { reason: "codex_item_type_unsupported" };
+  if (!threadId || !item.id) return { reason: "tool_identity_missing" };
+  const native = item.status;
+  const failed = ["failed", "declined", "interrupted"].includes(native) || item.type === "commandExecution" && typeof item.exitCode === "number" && item.exitCode !== 0;
+  const completed = message.method === "item/completed" && (native === undefined || native === "completed");
+  const known = native === undefined || ["inProgress", "completed", "failed", "declined", "interrupted"].includes(native);
+  return { session: identity("codex-desktop", threadId), epoch: turnId ?? "", call_id: item.id, name: item.type,
+    status: !known ? "unknown" : failed ? "failed" : completed ? "completed" : "running", ...(!known ? { reason: "codex_item_status_unsupported" } : {}) };
+}
+
+export function openCodeToolObservation(part, sessionId, messageId) {
+  if (part.type !== "tool") return null;
+  return { session: identity("opencode-server", part.sessionID ?? sessionId), call_id: part.callID ?? part.id,
+    epoch: messageId, name: part.tool, ...nativeStatus(part.state?.status) };
+}
+
+export function agyToolObservation(step, rootSessionId) {
+  if (step.step_type !== "tool" && !(step.step_type === "subagent" && step.tool_name === "invoke_subagent")) return null;
+  const sessionId = step.conversation_id ?? rootSessionId;
+  return { session: identity("antigravity-cli", sessionId), parent_session: sessionId !== rootSessionId ? identity("antigravity-cli", rootSessionId) : null,
+    call_id: step.step_id ?? step.stepId ?? step.id ?? step.tool_call_id ?? step.toolCallId ?? (Number.isInteger(step.step_index) ? String(step.step_index) : null),
+    name: step.tool_name ?? step.tool_info?.name, ...(step.tool_info?.error ? { status: "failed" } : nativeStatus(step.state === "ACTIVE" ? "running" : step.state)) };
+}
+
+/** Native AGY JSONL records have planner tool invocations, not matching live
+ * step IDs. GENERIC result text is deliberately not guessed into success. */
+export function agyTranscriptObservations(text, sessionId, parentSessionId, source = {}) {
+  const reducer = createAgyTranscriptObserver(sessionId, parentSessionId, source), lines = text.split("\n");
+  for (const [line, bytes] of lines.entries()) {
+    if (!bytes.trim()) continue;
+    try { reducer.add(JSON.parse(bytes), line + 1); }
+    catch { reducer.gap(line === lines.length - 1 ? "agy_transcript_partial_tail" : "agy_transcript_invalid_record"); }
+  }
+  return reducer.finish();
+}
+
+export function createAgyTranscriptObserver(sessionId, parentSessionId, source = {}) {
+  const events = []; let recognized = false;
+  const session = identity("antigravity-cli", sessionId);
+  function add(record, line) {
+    if (!record || typeof record !== "object" || Array.isArray(record)) { events.push({ session, reason: "agy_transcript_shape_unsupported" }); return; }
+    if (record.conversation_id && record.conversation_id !== sessionId) { events.push({ session, reason: "agy_transcript_session_mismatch" }); return; }
+    if (!["SYSTEM_MESSAGE", "USER_INPUT", "PLANNER_RESPONSE", "GENERIC", "TOOL_RESPONSE", "CHECKPOINT"].includes(record.type)) { events.push({ session, reason: "agy_transcript_shape_unsupported" }); return; }
+    recognized = true;
+    if (record.tool_calls !== undefined && !Array.isArray(record.tool_calls)) events.push({ session, reason: "agy_transcript_shape_unsupported" });
+    if (record.truncated || record.truncation || typeof record.content === "string" && /\[.*truncat|<.*truncat/i.test(record.content)) events.push({ session, reason: "agy_transcript_truncated" });
+    for (const [index, call] of (Array.isArray(record.tool_calls) ? record.tool_calls : []).entries()) {
+      if (!Number.isInteger(record.step_index) || !call || typeof call.name !== "string" || !call.name) { events.push({ session, reason: "agy_transcript_tool_identity_missing" }); continue; }
+      const id = call.id ?? call.tool_call_id;
+      events.push({ session, parent_session: identity("antigravity-cli", parentSessionId), epoch: "native_transcript", call_id: id ?? `${record.step_index}:${index}`, name: call.name,
+        status: "unknown", reason: "agy_transcript_tool_outcome_unproven", source: { ...source, channel: "agy.native_transcript", line, step_index: record.step_index } });
+    }
+  }
+  return { add, gap: reason => events.push({ session, reason }), finish: () => {
+    if (!recognized) events.push({ session, reason: "agy_transcript_shape_unsupported" });
+    else events.push({ session, parent_session: identity("antigravity-cli", parentSessionId), source_observed: true, source: { ...source, channel: "agy.native_transcript" } });
+    return events;
+  } };
+}
+
+/** Read-only replay, shared by accounting and offline diagnosis. A journal
+ * carries physical identities; an ACP connection identity never crosses out. */
+export function replayToolJournal(file, options, reducer = new ToolObservations()) {
+  let bytes;
+  try { bytes = options.text ?? fs.readFileSync(file, "utf8"); } catch (error) { reducer.gaps.add(error.code === "ENOENT" ? "journal_missing" : "journal_unreadable"); return reducer; }
+  const lines = bytes.split("\n"); let session = options.rootSessionId, transport = options.adapterSessionId;
+  for (const [index, line] of lines.entries()) {
+    if (!line.trim()) continue;
+    let e; try { e = JSON.parse(line); } catch { reducer.gaps.add(index === lines.length - 1 ? "journal_partial_tail" : "journal_invalid_record"); continue; }
+    const add = event => { if (event) reducer.add({ ...event, source: { ...event.source, journal: file, journal_line: index + 1 }, observed_at: e.observed_at ?? e.timestamp ?? e.at ?? e.ts ?? null }); };
+    if (e.kind === "tool_observation" && e.schema_id === "dd-flow/tool-observation@1") { add(e.event); continue; }
+    if (e.kind === "notification_failure") reducer.gaps.add("notification_failure");
+    const m = e.payload ?? e;
+    if (options.harness === "zcode-acp" || options.harness === "grok-acp") {
+      if (m.method === "zcode/session/allocated" && m.params?.provider_session_id === session) transport = m.params.adapter_session_id;
+      if (e.kind === "inbound" || m.method) add(acpToolObservation(m, { ...options, rootSessionId: session, adapterSessionId: transport }));
+    } else if (options.harness === "codex-desktop") {
+      if (e.type === "session_meta" && e.payload?.id !== session) { reducer.gaps.add("session_identity_mismatch"); break; }
+      if (m.params?.threadId && options.expectedSessionIds && !options.expectedSessionIds.includes(m.params.threadId)) continue;
+      if (["turn/started", "turn/completed"].includes(m.method)) {
+        const params = m.params ?? {};
+        if (params.threadId && params.turn?.id) reducer.observeTurn({ session: identity("codex-desktop", params.threadId), turn_id: params.turn.id,
+          started: m.method === "turn/started", completed: m.method === "turn/completed" && params.turn.status === "completed" });
+        else reducer.gaps.add("turn_identity_missing");
+      }
+      add(codexAppServerObservation(m) ?? codexToolObservation(e, session));
+    } else if (options.harness === "droid-cli") {
+      if (e.type === "session_start" && e.id !== session) { reducer.gaps.add("session_identity_mismatch"); break; }
+      for (const event of droidToolObservations(e, session)) add(event);
+    } else if (options.harness === "antigravity-cli") {
+      const native = m.event ?? e;
+      if (native.event === "step_update") add(agyToolObservation(native.step_update ?? {}, session));
+    } else if (options.harness === "opencode-server") {
+      // Native SSE message.part.updated, retained in the adapter journal.
+      const event = m.event ?? m;
+      const part = event.properties?.part;
+      if (part) add(openCodeToolObservation(part, session, part.messageID));
+    } else reducer.gaps.add("tool_observation_unsupported");
+  }
+  return reducer;
+}

package/dist/harness-runtime/lib/zcode-native-hook-ownership.mjs

@@ -0,0 +1,109 @@
+// This map is optional evidence, not a replacement for the ordinary hook.
+// A turn becomes authoritative only after the bridge has matched the native
+// inputId it supplied on session/send and echoed by native turn.started.
+export class ZcodeNativeHookOwnership {
+  constructor() { this.turns = new Map(); this.invalidTurns = new Set(); this.requests = new Map(); this.observers = new Map(); this.managedSessions = new Set(); this.buffer = new Map(); this.hooks = new Map(); this.waiters = new Map(); }
+  key(...values) { return JSON.stringify(values); }
+  signature(message) { const update = message.params.update; return this.key(update.toolCallId, update.rawInput, update._meta?.zcodeRuntime); }
+  register(operationId, observer, sessionId) { if (operationId && observer) { this.observers.set(operationId, observer); if (typeof sessionId === 'string' && sessionId) this.managedSessions.add(sessionId); } }
+  isManaged(sessionId, pending) { return this.managedSessions.has(sessionId) || [...pending.values()].some(request => request.method === 'session/prompt' && request.sessionId === sessionId && request.nativeHookOwner); }
+  bind(params, pending) {
+    const { sessionId, requestId, nativeTurnId } = params ?? {};
+    const owner = pending?.nativeHookOwner;
+    if (!owner || pending.method !== 'session/prompt' || pending.id !== requestId || pending.sessionId !== sessionId
+      || typeof nativeTurnId !== 'string' || !nativeTurnId || !owner.operationId || !owner.rootProviderSessionId || !owner.valid()) return [];
+    const turnKey = this.key(sessionId, nativeTurnId), requestKey = this.key(sessionId, requestId);
+    if (this.invalidTurns.has(turnKey)) return [];
+    const priorTurn = this.turns.get(turnKey), priorRequest = this.requests.get(requestKey);
+    if (priorTurn && priorTurn.requestKey !== requestKey || priorRequest && priorRequest !== turnKey) {
+      this.invalidTurns.add(turnKey);
+      if (priorRequest && priorRequest !== 'conflict') this.invalidTurns.add(priorRequest);
+      if (priorTurn) priorTurn.invalid = true;
+      if (priorRequest && this.turns.has(priorRequest)) this.turns.get(priorRequest).invalid = true;
+      this.requests.set(requestKey, 'conflict'); this.buffer.delete(turnKey); return [];
+    }
+    if (!priorTurn) this.turns.set(turnKey, { requestKey, owner, tools: new Map(), waiting: [], seen: new Set(), invalid: false });
+    this.requests.set(requestKey, turnKey); this.managedSessions.add(sessionId); owner.retainNativeHooks = true;
+    const buffered = this.buffer.get(turnKey) ?? new Map(); this.buffer.delete(turnKey);
+    return [...buffered.values()].flatMap(message => this.observeBound(message, this.turns.get(turnKey)));
+  }
+  observe(message, mayBuffer, managed) {
+    const native = message?.params?.update?._meta?.zcodeRuntime;
+    if (message?.method !== 'session/update' || message.params.update?.sessionUpdate !== 'tool_call') return null;
+    if (!Object.hasOwn(native ?? {}, 'nativeTurnId')) return managed && (native?.source === 'subagent' || native?.childSessionId) ? [] : null;
+    const { sessionId } = message.params, { nativeTurnId } = native;
+    if (typeof sessionId !== 'string' || typeof nativeTurnId !== 'string' || !nativeTurnId) return managed ? [] : null;
+    const key = this.key(sessionId, nativeTurnId), turn = this.turns.get(key);
+    if (this.invalidTurns.has(key)) return [];
+    if (turn) return this.observeBound(message, turn);
+    if (!managed) return null;
+    if (mayBuffer) { const buffer = this.buffer.get(key) ?? new Map(); buffer.set(this.signature(message), message); this.buffer.set(key, buffer); }
+    return [];
+  }
+  discardUnbound(sessionId) {
+    for (const key of this.buffer.keys()) if (JSON.parse(key)[0] === sessionId) this.buffer.delete(key);
+  }
+  isCurrent(message, pending) {
+    const native = message?.params?.update?._meta?.zcodeRuntime;
+    if (!Object.hasOwn(native ?? {}, 'nativeTurnId')) return !(native?.source === 'subagent' || native?.childSessionId) || !this.isManaged(message.params.sessionId, pending);
+    const turn = this.turns.get(this.key(message.params.sessionId, native.nativeTurnId));
+    if (!turn) return !this.isManaged(message.params.sessionId, pending);
+    return Boolean(turn && !turn.invalid && turn.owner.valid() && [...pending.values()].some(request =>
+      request.method === 'session/prompt' && request.sessionId === message.params.sessionId && request.nativeHookOwner === turn.owner));
+  }
+  observeBound(message, turn) {
+    if (turn.invalid || !turn.owner.valid()) return [];
+    const signature = this.signature(message); if (turn.seen.has(signature)) return [];
+    turn.seen.add(signature);
+    // An unresolved native parent may arrive after the root turn returned;
+    // keep these exact, deduplicated facts only for this daemon lifetime.
+    turn.waiting.push(message);
+    const routed = [];
+    let progress = true;
+    while (progress) {
+      progress = false;
+      for (let i = 0; i < turn.waiting.length; i++) {
+        const event = turn.waiting[i], update = event.params.update, native = update._meta?.zcodeRuntime ?? {};
+        const tool = update.toolCallId, child = native.childSessionId;
+        if (typeof tool !== 'string' || !tool) { turn.waiting.splice(i--, 1); continue; }
+        if (native.source === 'subagent' && !child) { turn.waiting.splice(i--, 1); continue; }
+        const parent = child ? turn.tools.get(native.parentToolCallId) : null;
+        if (child && !parent) continue;
+        const session = child || turn.owner.rootProviderSessionId;
+        if (typeof session !== 'string' || !session || child && session === parent) { turn.waiting.splice(i--, 1); continue; }
+        const existing = turn.tools.get(tool);
+        if (existing && existing !== session) { turn.invalid = true; return []; }
+        turn.tools.set(tool, session); turn.waiting.splice(i--, 1); progress = true;
+        const command = update.rawInput?.command ?? update.rawInput?.cmd;
+        if (child && typeof native.childToolCallId === 'string' && native.childToolCallId && typeof command === 'string') {
+          const key = this.key(session, native.childToolCallId), fact = { owner: turn.owner, root: turn.owner.rootProviderSessionId, parent, session, tool: native.childToolCallId, command, message: event, turn };
+          const prior = this.hooks.get(key);
+          if (prior && (prior.owner !== fact.owner || prior.parent !== parent || prior.command !== command)) { this.hooks.set(key, null); turn.invalid = true; turn.waiting.length = 0; return []; }
+          else if (prior === undefined) this.hooks.set(key, fact);
+          for (const wake of this.waiters.get(key) ?? []) wake();
+        }
+        const observer = this.observers.get(turn.owner.operationId);
+        if (observer) routed.push({ message: event, observer, owner: turn.owner });
+      }
+    }
+    return routed;
+  }
+  fact(session, tool, command) {
+    const value = this.hooks.get(this.key(session, tool));
+    return value && !value.turn.invalid && value.owner.valid() && value.command === command ? value : null;
+  }
+  async wait(session, tool, command, deadlineAt) {
+    if (this.fact(session, tool, command)) return;
+    const remaining = deadlineAt - Date.now();
+    if (!Number.isSafeInteger(deadlineAt) || remaining <= 0 || remaining > 30_000) return;
+    const waitMs = Math.floor(remaining / 3); if (!waitMs) return;
+    const key = this.key(session, tool);
+    await new Promise(resolve => {
+      const waiters = this.waiters.get(key) ?? new Set();
+      const wake = () => { if (!this.fact(session, tool, command) && Date.now() < until) return; clearTimeout(timer); waiters.delete(wake); if (!waiters.size) this.waiters.delete(key); resolve(); };
+      const until = Date.now() + waitMs, timer = setTimeout(() => { waiters.delete(wake); if (!waiters.size) this.waiters.delete(key); resolve(); }, waitMs);
+      waiters.add(wake); this.waiters.set(key, waiters);
+      wake();
+    });
+  }
+}

package/dist/harness-runtime/lib/zcode-usage.mjs

@@ -0,0 +1,55 @@
+/** Accounting policy over native evidence; the bridge only exposes native RPCs. */
+export function normalizeZcodeUsage(usage, read) {
+  const result = { ...usage, requestUsageStatus: "unavailable" };
+  const totals = { requestTotalTokens: 0, requestInputTokens: 0, requestOutputTokens: 0,
+    requestReasoningTokens: 0, requestCacheCreationTokens: 0, requestCacheReadTokens: 0, requestCount: 0 };
+  const seen = new Map();
+  let incomplete = !Array.isArray(read?.messages);
+  for (const message of Array.isArray(read?.messages) ? read.messages : []) {
+    const info = message?.info;
+    if (info?.role !== "assistant") continue;
+    // Native history includes system timeline markers with role=assistant and
+    // zero token placeholders, but no model request (and no total counter).
+    if (info.semantics?.origin === "system" && info.semantics?.kind === "timeline_event") continue;
+    if (!info.tokens) { incomplete = true; continue; }
+    const tokens = info.tokens;
+    const id = info.messageId ?? info.id ?? message.id;
+    if (id) {
+      const signature = JSON.stringify(tokens);
+      if (seen.has(id)) { if (seen.get(id) !== signature) incomplete = true; continue; }
+      seen.set(id, signature);
+    }
+    const values = [tokens.total, tokens.input, tokens.output];
+    if (!values.every(valid)) { incomplete = true; continue; }
+    totals.requestTotalTokens += tokens.total;
+    totals.requestInputTokens += tokens.input;
+    totals.requestOutputTokens += tokens.output;
+    for (const [key, value] of [["requestReasoningTokens", tokens.reasoning],
+      ["requestCacheCreationTokens", tokens.cache?.write], ["requestCacheReadTokens", tokens.cache?.read]]) {
+      if (value == null) totals[key] = null;
+      else if (!valid(value)) incomplete = true;
+      else if (totals[key] !== null) totals[key] += value;
+    }
+    totals.requestCount++;
+  }
+  if (totals.requestCount && !incomplete) Object.assign(result, totals, { requestUsageStatus: "measured" });
+  if (incomplete) result.usageIsIncomplete = true;
+  return result;
+}
+
+function valid(value) { return typeof value === "number" && Number.isFinite(value) && value >= 0; }
+
+export async function readZcodeUsage(bridge, sessionId) {
+  const usage = await bridge.request("zcode/session/usage", { sessionId });
+  // Compatibility with immutable @1 bridges: they already expose this projection.
+  if (usage?.requestUsageStatus === "measured") return usage;
+  try {
+    // Unbounded native read is intentional: accounting needs the full history,
+    // unlike turn liveness reads which may use messageLimit: 1.
+    const read = await bridge.request("zcode/session/read", { sessionId });
+    return normalizeZcodeUsage(usage, read);
+  } catch (error) {
+    return { ...usage, requestUsageStatus: "unavailable", usageIsIncomplete: true,
+      requestUsageError: { code: error.code ?? "usage_evidence_failed", message: error.message, ...(error.details ? { details: error.details } : {}) } };
+  }
+}

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-1y4a697q.js

@@ -0,0 +1,81 @@
+import {
+  isRpcError2,
+  isRpcInternalError2
+} from "./service-probe-vt9jbch8.js";
+
+// src/promise/rpc.ts
+function makeRpc2(raw, events) {
+  return (definition) => {
+    const subscribe = (name, options) => {
+      if (!Object.hasOwn(definition.events, name))
+        throw new Error(`Unknown RPC event: ${definition.id}.${name}`);
+      const type = eventType(definition, name);
+      return {
+        [Symbol.asyncIterator]() {
+          const controller = new AbortController;
+          const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = async function* () {
+            try {
+              for await (const published of events.subscribe({ signal })) {
+                if (signal.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error) {
+              if (!signal.aborted)
+                throw error;
+            } finally {
+              controller.abort();
+            }
+          }();
+          return {
+            next: () => iterator.next(),
+            return: () => {
+              controller.abort();
+              return iterator.return();
+            }
+          };
+        }
+      };
+    };
+    return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
+      name,
+      async (input, options) => {
+        try {
+          const result = await raw.rpc.call({
+            rpcID: definition.id,
+            method: name,
+            input,
+            location: options?.location
+          }, { signal: options?.signal, headers: options?.headers });
+          return result.output;
+        } catch (error) {
+          if (!isRpcError2(error) && !isRpcInternalError2(error))
+            throw error;
+          throw error.data === undefined ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data };
+        }
+      }
+    ])), {
+      events: {
+        subscribe,
+        on: (name, handler, options) => {
+          const controller = new AbortController;
+          const signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal });
+          (async () => {
+            for await (const event of source)
+              await handler(event);
+          })().catch((error) => console.error(error));
+          return () => controller.abort();
+        }
+      }
+    });
+  };
+}
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+
+export { makeRpc2 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-2ny4vxct.js

@@ -0,0 +1,92 @@
+import {
+  defaultEnsureTiming2
+} from "./service-probe-xgnj2w4v.js";
+import {
+  matchesVersion2
+} from "./service-probe-sxt88q69.js";
+
+// src/service-probe.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+function decide2(service, options) {
+  if (!matchesVersion2(service.version, options))
+    return { _tag: "replace", pty: service.state === "ready" ? "handoff" : "clear" };
+  if (!service.compatible)
+    return fail("Background service uses an incompatible health protocol. Update this client or explicitly restart the service.");
+  if (service.state === "ready")
+    return { _tag: "reuse" };
+  if (service.state === "failed")
+    return fail("Background service failed to start");
+  return { _tag: "wait" };
+}
+function fail(message) {
+  return { _tag: "fail", error: new Error(message) };
+}
+function fallback2() {
+  return join(process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state"), "opencode", "service.json");
+}
+function same2(left, right) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+}
+async function probeResult2(info, timeout = defaultEnsureTiming2.requestTimeout) {
+  const endpoint = {
+    url: info.url,
+    auth: info.password === undefined ? undefined : { type: "basic", username: "opencode", password: info.password }
+  };
+  const signal = AbortSignal.timeout(timeout);
+  const result = await fetch(new URL("/api/info", info.url), { headers: headers2(endpoint), signal }).then(async (response) => ({
+    response,
+    body: response.status === 404 ? undefined : await response.json()
+  })).catch(() => {
+    return;
+  });
+  if (result === undefined)
+    return { service: undefined, timedOut: signal.aborted };
+  const response = result.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
+    };
+  const serverInfo = decodeInfo(result.body);
+  if (serverInfo === undefined)
+    return { service: undefined, timedOut: false };
+  if (serverInfo.pid !== info.pid)
+    return { service: undefined, timedOut: false };
+  if (info.version !== undefined && serverInfo.version !== info.version)
+    return { service: undefined, timedOut: false };
+  return {
+    service: {
+      info,
+      endpoint,
+      version: serverInfo.version,
+      state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+      compatible: true
+    },
+    timedOut: false
+  };
+}
+function headers2(endpoint) {
+  if (endpoint.auth === undefined)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
+}
+function decodeInfo(input) {
+  if (typeof input !== "object" || input === null)
+    return;
+  if (!("version" in input) || typeof input.version !== "string")
+    return;
+  if (!("pid" in input) || typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid < 0)
+    return;
+  return { version: input.version, pid: input.pid };
+}
+
+export { decide2, fallback2, same2, probeResult2, headers2 };