@deksden-com/dd-flow-cli 0.9.0-beta.15 → 0.9.0-beta.150

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

@@ -0,0 +1,390 @@
+import { createHash, randomUUID } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { ToolObservations, openCodeToolObservation } from "./tool-observations.mjs";
+import { ObservationClock, observedTimeout, validateObservationDuration } from "./observation-clock.mjs";
+import { assertNativeLine } from "./native-streams.mjs";
+import { operationProgressReporter } from "./operation-progress.mjs";
+import { classifyProviderError, safeProviderError } from "./provider-overload-policy.mjs";
+
+export const OPENCODE_PROTOCOL = 2;
+export class OpenCodeError extends Error {
+  constructor(code, message, retryable = false, details) { super(message); Object.assign(this, { code, retryable, details }); }
+}
+const lost = (message, details) => new OpenCodeError("operation_observation_lost", message, false, { native_outcome: "unknown", ...details });
+export const requestDigest = value => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+export const nativeModel = ({ provider, model, variant }) => ({ providerID: provider, id: model, ...(variant && variant !== "default" ? { variant } : {}) });
+
+/** Native finite session.log includes a control watermark, not a domain event. */
+export function decodeFiniteLog(items, sessionId, after = 0) {
+  const fail = (reason, field, unproven = false) => { throw new OpenCodeError(unproven ? "opencode_observation_unproven" : "opencode_observation_corrupt", "OpenCode finite log has no trustworthy revision", false,
+    { native_outcome: "unknown", session_id: sessionId, cursor: after, reason, field }); };
+  if (!Number.isSafeInteger(after) || after < 0) fail("invalid_cursor", "after");
+  if (!Array.isArray(items)) fail("invalid_batch", "items");
+  const events = []; let watermark, cursor = after;
+  for (const item of items) {
+    if (watermark !== undefined) fail("frame_after_sync", "type");
+    const sync = item?.type === "log.synced", metadata = sync ? item : item?.durable;
+    if (!metadata) fail("missing_metadata", "durable");
+    if (metadata.aggregateID !== sessionId) fail("foreign_aggregate", sync ? "aggregateID" : "durable.aggregateID");
+    if (!Number.isSafeInteger(metadata.seq) || metadata.seq < 0) fail("invalid_sequence", sync ? "seq" : "durable.seq", sync && metadata.seq === undefined);
+    if (sync) {
+      if (metadata.seq < cursor) fail("watermark_behind_cursor", "seq");
+      watermark = metadata.seq;
+    } else {
+      if (typeof item.type !== "string" || !item.type.startsWith("session.") || !item.data || typeof item.data !== "object") fail("invalid_domain_event", "type/data");
+      if (item.data.sessionID !== undefined && item.data.sessionID !== sessionId) fail("foreign_session", "data.sessionID");
+      if (metadata.seq <= cursor) fail("non_increasing_sequence", "durable.seq");
+      cursor = metadata.seq; events.push(item);
+    }
+  }
+  if (watermark === undefined) fail("missing_sync", "log.synced", true);
+  return { events, watermark };
+}
+
+/** info/parts is our normalized projection, not a second v1 native protocol. */
+export function normalizeMessage(message, sessionID) {
+  if (!message?.id || !message.type) throw lost("OpenCode message has no native identity");
+  const { model, time = {} } = message;
+  const parts = (message.content ?? []).map(part => part.type === "tool"
+    ? { ...part, tool: part.name, callID: part.id, state: { ...part.state, output: part.state?.result ?? part.state?.output } }
+    : { ...part });
+  if (message.type !== "assistant" && typeof message.text === "string") parts.push({ type: "text", text: message.text });
+  return { info: { id: message.id, sessionID, role: message.type, providerID: model?.providerID, modelID: model?.id,
+    variant: model?.variant ?? "default", mode: message.agent, finish: message.finish, error: message.error,
+    cost: message.cost, tokens: message.tokens, created: time.created, completed: time.completed, metadata: message.metadata, outcome: message.outcome }, parts };
+}
+
+export function providerFailure(native, sessionId, turnId) {
+  const status = native?.status, type = String(native?.type ?? "unknown");
+  const category = classifyProviderError(native), code = category === "provider_failed" ? "opencode_provider_failed" : category;
+  // Never forward response.body or provider credentials into controller/Judge.
+  return new OpenCodeError(code, `OpenCode native execution failed (${type}${status ? `, HTTP ${status}` : ""})`,
+    ["provider_capacity_transient", "provider_rate_limited"].includes(code), {
+      provider_session_id: sessionId, session_id: sessionId, turn_id: turnId, native_error_type: type,
+      native_turn_id: turnId, terminal_status: "failed",
+      provider_error: safeProviderError(native),
+      will_retry: native?.willRetry === true, native_retry_active: native?.willRetry === true,
+      native_turn_items: { observed: true, possible_effects: true, pending: false },
+      ...(Number.isInteger(status) ? { http_status: status } : {}), observed_at: new Date().toISOString(), native_source: "opencode.v2.session.execution" });
+}
+
+export class OpenCodeClient {
+  constructor({ baseUrl, password, directory, timeoutMs = 1_800_000, api }) {
+    Object.assign(this, { baseUrl: new URL(baseUrl), password, directory, timeoutMs });
+    this.ready = api ? Promise.resolve(api) : import("../vendor/opencode-client/promise/index.js").then(({ OpenCode }) => OpenCode.make({
+      baseUrl: this.baseUrl.href, headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` }
+    }));
+  }
+  async call(method, input, { timeoutMs, progress, onDispatched, productive = false, signal } = {}) {
+    const observation = this.readObservation?.();
+    timeoutMs ??= observation?.timeoutMs ?? this.timeoutMs; progress ??= observation?.progress;
+    const controller = new AbortController();
+    let timer;
+    const abort = () => { controller.abort(); clearInterval(timer); };
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    timer = observedTimeout(() => controller.abort(), timeoutMs, { progress });
+    if (signal?.aborted) clearInterval(timer);
+    try {
+      // Cover initialization as well as RPC. Abort still reaches the owned
+      // request; an unresolved module import cannot start a late RPC.
+      let rejectAbort;
+      const aborted = new Promise((_, reject) => { rejectAbort = () => reject(Object.assign(new Error("OpenCode probe aborted"), { name: "AbortError" })); controller.signal.addEventListener("abort", rejectAbort, { once: true }); });
+      let api;
+      try { if (controller.signal.aborted) rejectAbort(); api = await Promise.race([this.ready, aborted]); }
+      finally { controller.signal.removeEventListener("abort", rejectAbort); }
+      const keys = method.split("."), name = keys.pop(), domain = keys.reduce((value, key) => value?.[key], api);
+      if (typeof domain?.[name] !== "function") throw new OpenCodeError("opencode_capability_missing", `OpenCode v2 does not expose ${method}`);
+      const options = { signal: controller.signal };
+      const pending = input === undefined ? domain[name](options) : domain[name](input, options);
+      void pending.catch(() => {}); await onDispatched?.(); const result = await pending;
+      assertNativeLine(JSON.stringify(result ?? null)); return result;
+    } catch (cause) {
+      if (cause instanceof OpenCodeError || cause.code === "operation_observation_lost") throw cause;
+      if (cause._tag === "SessionNotFoundError" || cause._tag === "NotFoundError") throw new OpenCodeError("session_not_found", "OpenCode native Session is unavailable");
+      if (productive && ["InvalidRequestError", "ConflictError", "UnauthorizedError", "ForbiddenError"].includes(cause._tag))
+        throw new OpenCodeError("opencode_admission_rejected", "OpenCode rejected native admission", false, { effect: "no_effect", native_type: cause._tag });
+      if (!productive && ["UnauthorizedError", "ForbiddenError"].includes(cause._tag)) throw new OpenCodeError("opencode_auth_rejected", "OpenCode rejected authentication", false, { method, native_type: cause._tag });
+      if (!productive && ["InvalidRequestError", "ConflictError"].includes(cause._tag)) throw new OpenCodeError("opencode_configuration_invalid", "OpenCode rejected the diagnostic request", false, { method, native_type: cause._tag });
+      if (productive || controller.signal.aborted) throw Object.assign(lost(`OpenCode observer lost during ${method}`, { method }), { cause });
+      throw Object.assign(new OpenCodeError("opencode_unavailable", `OpenCode ${method} observation failed`, true,
+        { method, native_type: cause._tag ?? cause.name ?? null, native_reason: cause.reason ?? null }), { cause });
+    } finally { clearInterval(timer); signal?.removeEventListener("abort", abort); }
+  }
+  async health(options = {}) {
+    const info = await this.call("server.info", undefined, { timeoutMs: 5_000, ...options });
+    if (!/^2\./.test(info?.version) || !Number.isInteger(info.pid)) throw new OpenCodeError("unsupported_version", "OpenCode v2 server identity is unavailable");
+    return info;
+  }
+  async pages(method, input) {
+    const items = new Map(), seen = new Set(); let cursor;
+    do {
+      const page = await this.call(method, { ...input, limit: 100, ...(cursor ? { cursor } : { order: "asc" }) });
+      if (!Array.isArray(page?.data)) throw lost(`OpenCode ${method} returned an invalid page`);
+      for (const item of page.data) { if (!item?.id) throw lost("OpenCode page item has no identity"); items.set(item.id, item); }
+      cursor = page.cursor?.next;
+      if (cursor && seen.has(cursor)) throw lost("OpenCode pagination cursor repeated");
+      if (cursor) seen.add(cursor);
+    } while (cursor);
+    return [...items.values()];
+  }
+  create(title, profile = {}, id) { return this.call("session.create", { ...(title ? { title } : {}), ...(id ? { id } : {}),
+    location: { directory: this.directory }, agent: profile.agent ?? "build", model: nativeModel(profile) }, { productive: true }); }
+  async inspect(id) { const info = await this.call("session.get", { sessionID: id }); return { ...info, directory: info.location?.directory }; }
+  list() { return this.pages("session.list", { directory: this.directory }); }
+  async statuses() { const active = await this.call("session.active"); return Object.fromEntries(Object.keys(active).map(id => [id, { type: "busy" }])); }
+  async children(id) { return (await this.pages("session.list", { parentID: id })).map(info => ({ ...info, directory: info.location?.directory })); }
+  async messages(id) { return (await this.pages("message.list", { sessionID: id })).map(message => normalizeMessage(message, id)); }
+  inbox(id) { return this.call("session.inbox.list", { sessionID: id }); }
+  async shellDirectory(id) { const api = await this.ready; return typeof api.session?.get === "function" ? (await this.inspect(id)).directory : this.directory; }
+  async shells(id) { const directory = await this.shellDirectory(id); const result = await this.call("shell.list", { location: { directory } }); return result.data.filter(item => item.metadata?.sessionID === id).map(item => ({ ...item, location: item.location ?? { directory } })); }
+  async pending(id) {
+    const [inbox, forms, permissions] = await Promise.all([this.inbox(id), this.call("session.form.list", { sessionID: id }), this.call("permission.list", { sessionID: id })]);
+    const value = { inbox, forms: forms.data ?? forms, permissions: permissions.data ?? permissions };
+    if (Object.values(value).some(items => !Array.isArray(items))) throw lost("OpenCode returned invalid pending-input evidence", { session_id: id });
+    return value;
+  }
+  async logs(id, after = 0) {
+    const api = await this.ready, controller = new AbortController(), events = [];
+    const observation = this.readObservation?.();
+    const timer = observedTimeout(() => controller.abort(), observation?.timeoutMs ?? this.timeoutMs, { progress: observation?.progress });
+    try { for await (const event of api.session.log({ sessionID: id, after, follow: false }, { signal: controller.signal })) events.push(event); }
+    catch (cause) { throw Object.assign(lost("OpenCode durable log observation failed", { session_id: id }), { cause }); }
+    finally { clearInterval(timer); }
+    return decodeFiniteLog(events, id, after);
+  }
+  async abort(id) {
+    // Queued input must not become fresh work during interruption cleanup.
+    for (const item of await this.inbox(id)) await this.call("session.inbox.cancel", { sessionID: id, inboxID: item.id }, { productive: true });
+    const result = await this.call("session.interrupt", { sessionID: id, resume: false }, { productive: true });
+    const api = await this.ready;
+    if (typeof api.shell?.list === "function") for (const shell of await this.shells(id)) {
+      if (shell.status === "running") await this.call("shell.remove", { id: shell.id, location: shell.location }, { productive: true });
+    }
+    return result;
+  }
+  fork(id, messageID) { return this.call("session.fork", { sessionID: id, ...(messageID ? { before: messageID } : {}) }, { productive: true }); }
+  delete(id) { return this.call("session.remove", { sessionID: id }, { productive: true }); }
+  export(id) { return this.call("session.export", { sessionID: id }); }
+  import(data) { return this.call("session.import", data, { productive: true }); }
+
+  async prompt(id, { prompt, messageId = `msg_${randomUUID().replaceAll("-", "")}`, retained,
+    save, onModelMessages, onObservationError, assertDispatch, onDispatched, checkHookFailures, livenessTimeoutMs = this.timeoutMs }) {
+    validateObservationDuration(livenessTimeoutMs);
+    const request = { sessionID: id, id: messageId, text: prompt, delivery: "queue", resume: true }, digest = requestDigest(request);
+    if (retained && (retained.request_sha256 !== digest || retained.message_id !== messageId)) throw new OpenCodeError("operation_request_mismatch", "OpenCode operation already binds another prompt", false, { effect: "no_effect" });
+    let state = retained ?? { message_id: messageId, request_sha256: digest, phase: "prepared", cursor: 0 };
+    const previous = await this.messages(id), baseline = new Map([[id, new Set(previous.map(item => item.info.id))]]), parents = new Map();
+    const capture = async session => { for (const child of await this.children(session)) { parents.set(child.id, child.parentID); baseline.set(child.id, new Set((await this.messages(child.id)).map(item => item.info.id))); await capture(child.id); } };
+    await capture(id);
+    if (retained) {
+      const index = previous.findIndex(item => item.info.id === messageId);
+      if (index >= 0) baseline.set(id, new Set(previous.slice(0, index + 1).map(item => item.info.id)));
+    }
+    assertDispatch?.(); // Cancellation/ownership wins before observer setup.
+    const api = await this.ready, streamAbort = new AbortController(), clock = new ObservationClock({ timeoutMs: livenessTimeoutMs });
+    const publish = operationProgressReporter(), known = new Set([id, ...baseline.keys()]), signatures = new Map(), shellCursors = new Map(), liveSeen = new Set();
+    let progress = 0, marker, stream;
+    const liveParts = new Map(), liveShells = new Map(), backgroundShells = new Set();
+    const completedTools = new Set(), outputReads = new Map(), shellLocations = new Map();
+    const observationErrors = { count: 0 };
+    const observeOutput = (shellID, location) => {
+      if (outputReads.has(shellID) || !location?.directory) return;
+      const cursor = shellCursors.get(shellID) ?? 0;
+      const pending = this.call("shell.output", { id: shellID, location, cursor, limit: 65536 }, { signal: streamAbort.signal })
+        .then(async output => { const data = output.data ?? output; if (!streamAbort.signal.aborted && data.cursor > cursor) { shellCursors.set(shellID, data.cursor); await advance(); } })
+        .catch(async error => {
+          if (streamAbort.signal.aborted) return;
+          const diagnostic = { method: "shell.output", shell_id: shellID, native_type: error.details?.native_type ?? error.cause?._tag ?? null, http_status: error.cause?.status ?? null };
+          observationErrors.count++; observationErrors.first ??= diagnostic; observationErrors.last = diagnostic;
+          if (observationErrors.count === 1) await onObservationError?.(error);
+        }).finally(() => outputReads.delete(shellID));
+      outputReads.set(shellID, pending); void pending.catch(() => {});
+    };
+    const advance = async (observedAt = Date.now()) => { marker = { cursor: ++progress, observed_at: observedAt }; await publish("native_progress", { session_id: id, observed_at: new Date(marker.observed_at).toISOString() }); };
+    let connected;
+    const connection = new Promise(resolve => { connected = resolve; });
+    const connectionTimer = api.event?.subscribe ? observedTimeout(() => { connected(false); streamAbort.abort(); }, livenessTimeoutMs) : null;
+    if (api.event?.subscribe) stream = (async () => {
+      try { for await (const event of api.event.subscribe({ signal: streamAbort.signal, onActivity: () => connected(true) })) {
+        connected(true); // Stream establishment is not model progress.
+        const data = event.data, floor = baseline.get(data?.sessionID);
+        if (known.has(data?.sessionID) && data?.assistantMessageID && !floor?.has(data.assistantMessageID)
+          && event.created >= clock.startedWall && event.created <= Date.now() && event.id && !liveSeen.has(event.id)
+          && ["session.text.delta", "session.reasoning.delta", "session.tool.input.delta", "session.tool.progress"].includes(event.type)) {
+          liveSeen.add(event.id); if (liveSeen.size > 1024) liveSeen.delete(liveSeen.values().next().value);
+          const key = `${data.sessionID}:${data.assistantMessageID}:${data.id ?? ""}`, signature = requestDigest(data.metadata ?? null);
+          if (event.type === "session.tool.progress" && completedTools.has(key)) continue;
+          if (event.type === "session.tool.progress" && typeof data.metadata?.shellID === "string" && !completedTools.has(key)) liveShells.set(key, data.metadata.shellID);
+          if (typeof data.delta === "string" && data.delta.length || event.type === "session.tool.progress" && liveParts.get(key) !== signature) {
+            liveParts.set(key, signature); await advance(event.created);
+          }
+        }
+      } } catch (error) { if (!streamAbort.signal.aborted) await onObservationError?.(error); }
+      finally { connected(false); }
+    })();
+    const priorObservation = this.readObservation;
+    this.readObservation = () => {
+      if (clock.sample(marker)) throw lost("OpenCode operation observation expired", { session_id: id, message_id: messageId, observation: clock.state() });
+      return { timeoutMs: Math.max(1, Math.ceil(livenessTimeoutMs - clock.elapsed)), progress: () => marker };
+    };
+    try {
+      if (api.event?.subscribe && !await connection) throw new OpenCodeError("opencode_unavailable", "Native observer stream could not be established before dispatch", true, { effect: "no_effect" });
+      clearInterval(connectionTimer);
+      if (!retained) {
+        await save?.(state); assertDispatch?.();
+        // Subscribe before dispatch; persisted intent precedes HTTP. Unknown
+        // ack permits reconciliation only, never another same-ID wake.
+        state = { ...state, phase: "dispatched" }; await save?.(state);
+        try {
+          const admission = await this.call("session.prompt", request, { productive: true, onDispatched });
+          if (admission?.id !== messageId || admission.sessionID !== id) throw lost("OpenCode prompt acknowledgement has another identity");
+          state = { ...state, phase: "admitted" }; await save?.(state);
+        } catch (error) {
+          if (error.details?.effect === "no_effect") throw error;
+          await onObservationError?.(error);
+        }
+      }
+      for (;;) {
+        try {
+          await checkHookFailures?.();
+          const { events, watermark } = await this.logs(id, state.cursor);
+          let delivered = state.delivered === true, terminal = state.terminal;
+          for (const event of events) {
+            if (event.type === "session.inbox.delivered" && event.data.inboxID === messageId) { delivered = true; terminal = null; }
+            if (delivered && event.type === "session.execution.started") terminal = null;
+            if (delivered && ["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted"].includes(event.type)) terminal = { type: event.type, error: event.data.error };
+            state = { ...state, cursor: event.durable.seq, delivered, terminal }; await save?.(state);
+          }
+          if (state.cursor !== watermark) { state = { ...state, cursor: watermark }; await save?.(state); }
+          let runningTools = false;
+          const observe = async (session, visited = new Set()) => {
+            if (visited.has(session)) throw lost("OpenCode topology contains a cycle"); visited.add(session); known.add(session);
+            const messages = await this.messages(session);
+            await onModelMessages?.(session, messages, parents.get(session) ?? null);
+            const floor = baseline.get(session) ?? new Set(), current = messages.filter(item => item.info.role === "assistant" && !floor.has(item.info.id));
+            for (const item of current) {
+              const key = `${session}:${item.info.id}`, encoded = JSON.stringify(item.parts.map(stablePart)), next = requestDigest(encoded), before = signatures.get(key);
+              if (before?.signature !== next && !before?.seen.has(next) && (!before || before.seen.size < 128 || encoded.length > before.highWater)) {
+                if (item.parts.length) await advance();
+                const seen = before?.seen ?? new Set(); if (seen.size < 128) seen.add(next);
+                signatures.set(key, { signature: next, seen, highWater: Math.max(before?.highWater ?? 0, encoded.length) });
+              }
+              for (const part of item.parts) {
+                const toolKey = `${session}:${item.info.id}:${part.id}`;
+                if (part.type === "tool" && ["running", "streaming", "pending"].includes(part.state?.status)) runningTools = true;
+                if (part.type === "tool" && !["running", "streaming", "pending"].includes(part.state?.status)) { completedTools.add(toolKey); liveShells.delete(toolKey); }
+                let shellID = part.type === "tool" ? part.state?.metadata?.shellID ?? liveShells.get(toolKey) : null;
+                if (!shellID && part.tool === "shell" && part.state?.status === "running") {
+                  // Tool progress metadata is volatile in the CLI. Reconcile
+                  // only an unambiguous native shell in this current message.
+                  const candidates = (await this.shells(session)).filter(shell => shell.time.started >= item.info.created);
+                  if (candidates.length === 1) { shellID = candidates[0].id; shellLocations.set(shellID, candidates[0].location); }
+                }
+                if (!shellID) continue;
+                const cursor = shellCursors.get(shellID) ?? 0;
+                shellCursors.set(shellID, cursor); // Zero-output shells still own their native notification.
+                if (part.tool === "shell" && part.state?.metadata?.status === "running") backgroundShells.add(shellID);
+                if (!completedTools.has(toolKey)) {
+                  if (!shellLocations.has(shellID)) shellLocations.set(shellID, (await this.shells(session)).find(shell => shell.id === shellID)?.location);
+                  observeOutput(shellID, shellLocations.get(shellID));
+                }
+              }
+            }
+            for (const child of await this.children(session)) {
+              if (child.parentID !== session) throw lost("OpenCode child has a foreign parent");
+              parents.set(child.id, session); await observe(child.id, visited);
+            }
+            return current;
+          };
+          const current = await observe(id), rootMessages = await this.messages(id);
+          // CLI v2 defaults to non-persistent event payloads. The native
+          // projected user + idle records remain durable and carry the
+          // exact terminal error; do not invent a 'latest assistant' outcome.
+          const deliveredIndex = rootMessages.findIndex(item => item.info.id === messageId && item.info.role === "user");
+          if (deliveredIndex >= 0) {
+            for (const item of rootMessages.slice(deliveredIndex + 1)) {
+              if (item.info.role === "synthetic" && item.info.metadata?.source === "subagent"
+                && typeof item.info.metadata.childID === "string" && parents.get(item.info.metadata.childID) !== id) {
+                // Native messages and topology are separate reads: a child can
+                // finish between them. Reconcile its ancestry before rejecting
+                // the notification, never trust the notification alone.
+                const child = (await this.children(id)).find(child => child.id === item.info.metadata.childID && child.parentID === id);
+                if (child) { parents.set(child.id, id); await observe(child.id); }
+              }
+              if (item.info.role === "user" || item.info.role === "synthetic" && !(
+                item.info.metadata?.source === "subagent" && parents.get(item.info.metadata.childID) === id
+                || item.info.metadata?.source === "shell" && shellCursors.has(item.info.metadata.shellID)))
+                throw new OpenCodeError("opencode_foreign_input", "OpenCode received input outside the owned operation", false, { session_id: id, message_id: item.info.id, role: item.info.role, source: item.info.metadata?.source });
+            }
+            const terminal = rootMessages.slice(deliveredIndex + 1).findLast(item => item.info.role === "idle");
+            if (terminal) {
+              if (!["succeeded", "failed", "interrupted"].includes(terminal.info.outcome)) throw lost("OpenCode idle record has no proven native outcome");
+              state = { ...state, delivered: true, terminal: { type: `session.execution.${terminal.info.outcome}`, error: terminal.info.error } }; await save?.(state);
+            }
+          }
+          const statuses = await this.statuses(); let unsettled = runningTools;
+          // A background child's native completion notification is delivered
+          // asynchronously. An idle parent before that delivery is not the
+          // completion of the coordinating operation.
+          const deliveredNotifications = new Set(rootMessages.filter(item => item.info.role === "synthetic" && item.info.metadata?.source === "subagent").map(item => item.info.metadata.childID));
+          const shellNotifications = new Set(rootMessages.filter(item => item.info.role === "synthetic" && item.info.metadata?.source === "shell").map(item => item.info.metadata.shellID));
+          unsettled ||= [...backgroundShells].some(shell => !shellNotifications.has(shell));
+          for (const item of current) for (const part of item.parts) {
+            if (part.tool === "subagent" && part.state?.input?.background === true) {
+              const child = part.state?.metadata?.sessionID;
+              if (!child || !deliveredNotifications.has(child)) unsettled = true;
+            }
+          }
+          for (const session of known) {
+            const pending = await this.pending(session);
+            if (pending.forms.length || pending.permissions.length) throw new OpenCodeError("opencode_native_hitl", "OpenCode requires native operator input", false, { provider_session_id: session, form_ids: pending.forms.map(item => item.id), permission_ids: pending.permissions.map(item => item.id) });
+            unsettled ||= Boolean(statuses[session]) || pending.inbox.length > 0;
+            if (typeof api.shell?.list === "function") unsettled ||= (await this.shells(session)).some(shell => shell.status === "running");
+          }
+          if (state.delivered && state.terminal && !unsettled) {
+            await checkHookFailures?.();
+            if (state.terminal.type === "session.execution.failed") throw providerFailure(state.terminal.error, id, messageId);
+            if (state.terminal.type === "session.execution.interrupted") throw new OpenCodeError("opencode_execution_interrupted", "OpenCode execution was interrupted", false, { provider_session_id: id, turn_id: messageId });
+            const final = current.findLast(item => item.info.completed !== undefined && item.info.finish && item.info.finish !== "tool-calls");
+            if (!final) throw lost("OpenCode terminal has no current assistant response", { session_id: id, message_id: messageId });
+            if (final.info.error) throw providerFailure(final.info.error, id, messageId);
+            return { ...final, admission_message_id: messageId, log_cursor: state.cursor, ...(observationErrors.count ? { observation_errors: observationErrors } : {}) };
+          }
+        } catch (error) {
+          await checkHookFailures?.();
+          if (error instanceof OpenCodeError && !["opencode_unavailable", "operation_observation_lost"].includes(error.code)) throw error;
+          await onObservationError?.(error);
+        }
+        if (clock.sample(marker)) throw lost("OpenCode native progress stopped or observation could not recover", { session_id: id, message_id: messageId, observation: clock.state(), ...(observationErrors.count ? { observation_errors: observationErrors } : {}) });
+        await delay(Math.max(5, Math.min(500, livenessTimeoutMs / 4)));
+      }
+    } finally { clearInterval(connectionTimer); this.readObservation = priorObservation; streamAbort.abort(); await stream; }
+  }
+}
+
+function stablePart(part) {
+  if (part.type === "text" || part.type === "reasoning") return { type: part.type, text: part.text };
+  if (part.type === "tool") return { type: "tool", tool: part.tool, state: part.state };
+  return { type: part.type };
+}
+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?.type ?? null } : {}), parts: parts.map(stablePart) }));
+}
+export function historyDigest(messages) { return requestDigest(canonicalHistory(messages)); }
+export function usageSnapshot(messages, sessionId) {
+  const assistants = messages.filter(item => item.info?.role === "assistant"), tokens = { input: 0, output: 0, reasoning: 0, cache_read: 0, cache_write: 0 };
+  let complete = true, cost = 0, costComplete = true;
+  for (const item of assistants) {
+    const value = item.info.tokens; complete &&= Boolean(value && [value.input, value.output, value.reasoning, value.cache?.read, value.cache?.write].every(Number.isFinite));
+    for (const name of ["input", "output", "reasoning"]) tokens[name] += value?.[name] ?? 0;
+    tokens.cache_read += value?.cache?.read ?? 0; tokens.cache_write += value?.cache?.write ?? 0;
+    costComplete &&= Number.isFinite(item.info.cost); cost += item.info.cost ?? 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: costComplete ? cost : null, completeness: complete ? "complete" : "partial" };
+}