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

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

@@ -0,0 +1,228 @@
+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 events = [], lines = text.split("\n"); let recognized = false;
+  const session = identity("antigravity-cli", sessionId);
+  for (const [line, bytes] of lines.entries()) {
+    if (!bytes.trim()) continue;
+    let record; try { record = JSON.parse(bytes); } catch { events.push({ session, reason: line === lines.length - 1 ? "agy_transcript_partial_tail" : "agy_transcript_invalid_record" }); continue; }
+    if (!record || typeof record !== "object" || Array.isArray(record)) { events.push({ session, reason: "agy_transcript_shape_unsupported" }); continue; }
+    if (record.conversation_id && record.conversation_id !== sessionId) { events.push({ session, reason: "agy_transcript_session_mismatch" }); continue; }
+    if (!["SYSTEM_MESSAGE", "USER_INPUT", "PLANNER_RESPONSE", "GENERIC", "TOOL_RESPONSE", "CHECKPOINT"].includes(record.type)) { events.push({ session, reason: "agy_transcript_shape_unsupported" }); continue; }
+    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: line + 1, step_index: record.step_index } });
+    }
+  }
+  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-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 };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-7x67cf1q.js

@@ -0,0 +1,52 @@
+import {
+  make7
+} from "./service-probe-frbwqjmf.js";
+import {
+  ClientError2
+} from "./service-probe-y2etg5bs.js";
+import {
+  make3
+} from "./service-probe-q4g3afnw.js";
+import {
+  make4,
+  aborted2
+} from "./service-probe-z6qdwcsf.js";
+import {
+  __export
+} from "./service-probe-9rqn6x4v.js";
+
+// src/effect/client.ts
+var exports_client = {};
+__export(exports_client, {
+  OpenCode: () => exports_client,
+  make: () => make2
+});
+import { Cause, Context, Effect, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/http";
+var CurrentHeaders = Context.Reference("@opencode/client/effect/rpc/headers", {
+  defaultValue: () => {
+    return;
+  }
+});
+var make2 = Effect.fn("OpenCode.make")(function* (options) {
+  const httpClient = yield* HttpClient.HttpClient;
+  const raw = yield* make3(options).pipe(Effect.provideService(HttpClient.HttpClient, HttpClient.mapRequestEffect(httpClient, (request) => Effect.map(CurrentHeaders, (headers) => headers ? HttpClientRequest.setHeaders(request, new Headers(headers)) : request))));
+  const context = yield* Effect.context();
+  const native = raw.event.subscribe();
+
+  class EventFailure {
+    cause;
+    constructor(cause) {
+      this.cause = cause;
+    }
+  }
+  const shared = make7((signal) => Stream.toAsyncIterableWith(native.pipe(Stream.interruptWhen(aborted2(signal)), Stream.catchCause((cause) => Stream.fail(new EventFailure(cause)))), context));
+  const subscribe = () => Stream.fromAsyncIterable(shared.subscribe(), (error) => error).pipe(Stream.catch((error) => Stream.failCause(error instanceof EventFailure ? error.cause : Cause.fail(new ClientError2({ cause: error })))));
+  return {
+    ...raw,
+    event: { ...raw.event, subscribe },
+    rpc: Object.assign(make4((input, options) => raw.rpc.call(input).pipe(Effect.provideService(CurrentHeaders, options?.headers)), subscribe), raw.rpc)
+  };
+});
+
+export { make2, exports_client };

package/dist/harness-runtime/vendor/opencode-client/chunks/service-probe-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };