@kal-elsam/kairo-runtime 0.16.0 → 0.17.0

package/src/global/observability/opencode-usage.js

@@ -0,0 +1,162 @@
+import { spawn as defaultSpawn } from "node:child_process";
+import { join } from "node:path";
+import { resolveHomeDir } from "../paths.js";
+
+const GO_URL = "https://opencode.ai/zen/go/v1/usage";
+const DEFAULT_TIMEOUT_MS = 4000;
+// `opencode stats` scans local session history and can take several seconds on
+// larger databases. It runs at most once per five-minute cache window.
+const STATS_TIMEOUT_MS = 20_000;
+
+function unknown(error = null, source = "opencode usage") {
+  return { status: "unknown", source, windows: [], error: error ? String(error).replace(/(key|token|secret|authorization)[^\s]*/ig, "$1=[redacted]") : null };
+}
+
+function clamp(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.min(100, n)) : null;
+}
+
+export function normalizeOpenCodeGoUsage(payload) {
+  const usage = payload?.usage;
+  if (!usage || typeof usage !== "object") return null;
+  const windows = [];
+  for (const [name, value] of Object.entries(usage)) {
+    const percent = clamp(value?.percent);
+    if (percent == null) continue;
+    windows.push({
+      name,
+      usedPercent: percent,
+      remainingPercent: 100 - percent,
+      resetsAt: typeof value.resetsAt === "string" ? value.resetsAt : null,
+      status: value.status === "rate-limited" ? "rate-limited" : "ok"
+    });
+  }
+  if (!windows.length) return null;
+  return {
+    status: windows.some((window) => window.status === "rate-limited") ? "rate-limited" : "measured",
+    source: GO_URL,
+    windows,
+    primary: windows.find((window) => window.name === "rolling") ?? null,
+    secondary: windows.find((window) => window.name === "weekly") ?? null,
+    monthly: windows.find((window) => window.name === "monthly") ?? null
+  };
+}
+
+async function readGoUsage({ readFile, fetchImpl = globalThis.fetch, authPath, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  let auth;
+  try { auth = JSON.parse(await readFile(authPath, "utf8")); } catch (error) { return unknown(error?.code === "ENOENT" ? "OpenCode Go auth not found" : "invalid OpenCode auth", GO_URL); }
+  const credential = auth?.["opencode-go"] ?? (auth?.type === "api" ? auth : null);
+  const key = credential?.type === "api" && typeof credential.key === "string" ? credential.key : null;
+  if (!key) return unknown("OpenCode Go credential unavailable", GO_URL);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(GO_URL, { method: "GET", headers: { Authorization: `Bearer ${key}` }, signal: controller.signal });
+    if (!response?.ok) return unknown(`OpenCode Go usage HTTP ${response?.status ?? "error"}`, GO_URL);
+    const parsed = await response.json();
+    return normalizeOpenCodeGoUsage(parsed) ?? unknown("unusable OpenCode Go usage", GO_URL);
+  } catch (error) { return unknown(error?.name === "AbortError" ? "OpenCode Go usage timeout" : "OpenCode Go usage request failed", GO_URL); }
+  finally { clearTimeout(timer); }
+}
+
+/** Parse only rows explicitly belonging to OpenCode providers; this is local history, not billing. */
+export function parseOpenCodeStats(text) {
+  const stripAnsi = (value) => String(value).replace(/\x1b\[[0-?]*[ -\/]*[@-~]/g, "");
+  const parseAmount = (value) => {
+    const match = String(value).replace(/,/g, "").match(/([\d.]+)\s*([KMB])?/i);
+    if (!match) return null;
+    const multiplier = { K: 1e3, M: 1e6, B: 1e9 }[String(match[2] ?? "").toUpperCase()] ?? 1;
+    return Number(match[1]) * multiplier;
+  };
+  const records = [];
+  let current = null;
+  const push = () => {
+    if (!current) return;
+    current.tokens = (current.inputTokens ?? 0) + (current.outputTokens ?? 0)
+      + (current.cacheRead ?? 0) + (current.cacheWrite ?? 0) || null;
+    if (current.cost != null || current.tokens != null) records.push(current);
+    current = null;
+  };
+  for (const rawLine of String(text ?? "").split(/\r?\n/)) {
+    const line = stripAnsi(rawLine);
+    const model = line.match(/(?:│|\|)?\s*((?:opencode-go|opencode)\/[^\s│|]+)/i)?.[1];
+    if (model) {
+      push();
+      current = { model, provider: model.startsWith("opencode-go/") ? "opencode-go" : "opencode", cost: null, inputTokens: null, outputTokens: null, cacheRead: null, cacheWrite: null };
+      continue;
+    }
+    if (!current) continue;
+    const input = line.match(/Input Tokens\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    const output = line.match(/Output Tokens\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    const cost = line.match(/Cost\s+\$\s*([\d.,]+\s*[KMB]?)/i)?.[1];
+    if (input) current.inputTokens = parseAmount(input);
+    if (output) current.outputTokens = parseAmount(output);
+    const cacheRead = line.match(/Cache Read\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    const cacheWrite = line.match(/Cache Write\s+([\d.,]+\s*[KMB]?)/i)?.[1];
+    if (cacheRead) current.cacheRead = parseAmount(cacheRead);
+    if (cacheWrite) current.cacheWrite = parseAmount(cacheWrite);
+    if (cost) current.cost = parseAmount(cost);
+  }
+  push();
+  const zenRecords = records.filter((record) => record.provider === "opencode");
+  if (!zenRecords.length) return null;
+  return {
+    status: "local_recorded",
+    source: "opencode stats --days 7 --models",
+    billing: "PAYG",
+    balance: "unknown",
+    autoReload: "unknown",
+    kairoPolicy: "PAYG blocked",
+    days: 7,
+    records: zenRecords,
+    goRecords: records.filter((record) => record.provider === "opencode-go"),
+    totalCost: zenRecords.reduce((sum, record) => sum + (record.cost ?? 0), 0),
+    totalTokens: zenRecords.reduce((sum, record) => sum + (record.tokens ?? 0), 0)
+  };
+}
+
+function readStats({ spawn = defaultSpawn, timeoutMs = STATS_TIMEOUT_MS } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try { child = spawn("opencode", ["stats", "--days", "7", "--models"], { stdio: ["ignore", "pipe", "pipe"] }); }
+    catch { resolve(unknown("OpenCode stats unavailable", "opencode stats --days 7 --models")); return; }
+    let output = "";
+    let settled = false;
+    const timer = setTimeout(() => finish(unknown("OpenCode stats timeout", "opencode stats --days 7 --models")), timeoutMs);
+    const finish = (value) => { if (settled) return; settled = true; clearTimeout(timer); try { child.kill?.(); } catch {} resolve(value); };
+    child.stdout?.on("data", (chunk) => { output += String(chunk).slice(0, 100_000 - output.length); });
+    child.once?.("error", () => finish(unknown("OpenCode stats failed", "opencode stats --days 7 --models")));
+    child.once?.("close", () => finish(parseOpenCodeStats(output) ?? unknown("unparseable OpenCode stats", "opencode stats --days 7 --models")));
+  });
+}
+
+export async function readOpenCodeGoUsage({
+  readFile = (path, encoding) => import("node:fs/promises").then((fs) => fs.readFile(path, encoding)),
+  fetchImpl = globalThis.fetch,
+  homeDir = resolveHomeDir(),
+  authPath = join(homeDir, ".local/share/opencode/auth.json"),
+  timeoutMs = DEFAULT_TIMEOUT_MS
+} = {}) {
+  return readGoUsage({ readFile, fetchImpl, authPath, timeoutMs });
+}
+
+export async function readOpenCodeStats({ spawn = defaultSpawn, timeoutMs = STATS_TIMEOUT_MS } = {}) {
+  return readStats({ spawn, timeoutMs });
+}
+
+export async function readOpenCodeUsage({
+  readFile = (path, encoding) => import("node:fs/promises").then((fs) => fs.readFile(path, encoding)),
+  fetchImpl = globalThis.fetch,
+  spawn = defaultSpawn,
+  homeDir = resolveHomeDir(),
+  authPath = join(homeDir, ".local/share/opencode/auth.json"),
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  statsTimeoutMs = STATS_TIMEOUT_MS
+} = {}) {
+  const [go, zen] = await Promise.all([
+    readOpenCodeGoUsage({ readFile, fetchImpl, authPath, homeDir, timeoutMs }),
+    readOpenCodeStats({ spawn, timeoutMs: statsTimeoutMs })
+  ]);
+  return { go, zen };
+}

package/src/global/paths.js

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join, relative } from "node:path";
 
 export const HARNESS_DIR_NAME = ".harness";
 
@@ -24,7 +24,11 @@ export function harnessHomePaths(homeDir) {
     monitorStatePath: join(root, "monitor", "state.json"),
     coreDir: join(root, "core"),
     backupsDir: join(root, "backups"),
-    sessionsDir: join(root, "sessions")
+    sessionsDir: join(root, "sessions"),
+    worktreesDir: join(root, "worktrees"),
+    usageDir: join(root, "usage"),
+    modelIntelligencePath: join(root, "model-intelligence.json"),
+    huggingfaceLeaderboardPath: join(root, "huggingface-leaderboard.json")
   };
 }
 
@@ -39,3 +43,46 @@ export function runPaths(homeDir, runId) {
     transcriptPath: join(runDir, "transcript.jsonl")
   };
 }
+
+/**
+ * The exact shape createWorktreeId() (execution-worktree-types.js)
+ * produces — `wt_` plus two base36 segments. Enforced here, at the one
+ * real boundary every worktree path gets built from, rather than trusted
+ * by each caller separately: an unvalidated id (e.g. "../../escape")
+ * would otherwise let `join()` resolve outside worktreesDir entirely.
+ */
+export function assertWorktreeId(worktreeId) {
+  if (typeof worktreeId !== "string" || !/^wt_[a-z0-9]{1,20}_[a-z0-9]{1,20}$/.test(worktreeId)) {
+    throw new Error(`Invalid worktree id "${worktreeId ?? ""}".`);
+  }
+  return worktreeId;
+}
+
+/**
+ * Every real path an execution worktree needs — the real checked-out git
+ * worktree itself (`treePath`, never the project's own directory) plus its
+ * own metadata, all scoped under this one worktreeDir so a single
+ * `rm -rf` (see execution-worktree-manager.js's rollback) fully undoes an
+ * incomplete creation. `worktreeId` is validated here, the one real
+ * boundary every consumer of this function goes through — never trusted
+ * or re-validated ad hoc by callers.
+ */
+export function worktreePaths(homeDir, worktreeId) {
+  assertWorktreeId(worktreeId);
+  const { worktreesDir } = harnessHomePaths(homeDir);
+  const worktreeDir = join(worktreesDir, worktreeId);
+  // Defense in depth alongside the regex above — the same real containment
+  // check architect-store.js's taskPaths already applies to task ids.
+  const rel = relative(worktreesDir, worktreeDir);
+  const isInside = rel !== "" && !isAbsolute(rel) && rel !== ".." && !rel.startsWith("../");
+  if (!isInside) {
+    throw new Error(`Worktree path escapes worktreesDir for id "${worktreeId}".`);
+  }
+
+  return {
+    worktreeDir,
+    treePath: join(worktreeDir, "tree"),
+    statePath: join(worktreeDir, "state.json"),
+    checkpointsPath: join(worktreeDir, "checkpoints.jsonl")
+  };
+}

package/src/global/profile.js

@@ -5,6 +5,7 @@ import { harnessHomePaths } from "./paths.js";
 import { AGENT_CAPABILITY_IDS } from "./agent-capabilities/index.js";
 import { classifyCustomBaseUrl, isValidEnvironmentName } from "./intelligence/custom-url.js";
 import { validateRuntimeProfile, RUNTIME_PROFILE_KEYS } from "./runtime/run-profile.js";
+import { EXECUTION_ADAPTER_IDS } from "./runtime/execution-adapters/index.js";
 
 export const PROFILE_KEYS = new Set([
   "coordinator",
@@ -17,6 +18,7 @@ export const PROFILE_KEYS = new Set([
   "tokenBudget",
   "stableContextBudget",
   "requestContextBudget",
+  "providerTokenBudgets",
   "customProviders",
   ...RUNTIME_PROFILE_KEYS
 ]);
@@ -32,6 +34,7 @@ export const DEFAULT_PROFILE = {
   tokenBudget: null,
   stableContextBudget: null,
   requestContextBudget: null,
+  providerTokenBudgets: {},
   customProviders: [],
   agentAliases: {},
   modelAliases: {},
@@ -112,6 +115,7 @@ export function buildProfileJson(resolved) {
     tokenBudget: profile.tokenBudget,
     stableContextBudget: profile.stableContextBudget,
     requestContextBudget: profile.requestContextBudget,
+    providerTokenBudgets: profile.providerTokenBudgets ?? {},
     customProviders: sanitizeCustomProviders(profile.customProviders),
     agentAliases: profile.agentAliases ?? {},
     modelAliases: profile.modelAliases ?? {},
@@ -191,6 +195,8 @@ function validateProfile(profile) {
     }
   }
 
+  validateProviderTokenBudgets(profile.providerTokenBudgets);
+
   if (profile.preferredBackend != null && typeof profile.preferredBackend !== "string") {
     throw new Error("Profile preferredBackend must be a string or null.");
   }
@@ -213,7 +219,8 @@ const SECRET_KEY_ALLOWLIST = new Set([
   "api_key_env",
   "token_budget",
   "stable_context_budget",
-  "request_context_budget"
+  "request_context_budget",
+  "provider_token_budgets"
 ]);
 const SECRET_VALUE_PATTERN = /^(sk-[A-Za-z0-9]|sk-or-|gh[pousr]_|xox[baprs]-|AKIA[0-9A-Z]{16}\b|Bearer\s+\S+|eyJ[A-Za-z0-9_-]+\.)|-----BEGIN [A-Z ]*PRIVATE KEY-----/i;
 
@@ -265,6 +272,21 @@ function walkForSecrets(value) {
   }
 }
 
+function validateProviderTokenBudgets(budgets) {
+  if (budgets == null) return;
+  if (typeof budgets !== "object" || Array.isArray(budgets)) {
+    throw new Error("Profile providerTokenBudgets must be an object mapping provider id to a positive number.");
+  }
+  for (const [provider, budget] of Object.entries(budgets)) {
+    if (!EXECUTION_ADAPTER_IDS.includes(provider)) {
+      throw new Error(`Unknown provider "${provider}" in providerTokenBudgets. Use ${EXECUTION_ADAPTER_IDS.join(", ")}.`);
+    }
+    if (!Number.isFinite(budget) || budget < 1) {
+      throw new Error(`Profile providerTokenBudgets.${provider} must be a positive number.`);
+    }
+  }
+}
+
 function validateCustomProviders(providers) {
   if (providers == null) return;
   if (!Array.isArray(providers)) {

package/src/global/runtime/execution-adapters/claude.js

@@ -1,40 +1,77 @@
 import { createExecutionAdapter, parseNdjsonLine, buildPermissionsArgs } from "./create-execution-adapter.js";
+import {
+  ReviewExecError, assertBoundedProcessOk, runBoundedProcess
+} from "../review/review-exec.js";
 
 const EXECUTABLE = "claude";
+const AUTH_TIMEOUT_MS = 10_000;
+const AUTH_OUTPUT_LIMIT = 16_384;
+const SAFE_ENV_KEYS = Object.freeze([
+  "PATH", "HOME", "USER", "LOGNAME", "SHELL", "LANG", "LC_ALL", "LC_CTYPE",
+  "TMPDIR", "TERM", "CLAUDE_CONFIG_DIR", "HTTP_PROXY", "HTTPS_PROXY", "NO_PROXY",
+  "http_proxy", "https_proxy", "no_proxy", "NODE_EXTRA_CA_CERTS"
+]);
+const SUBSCRIPTION_TYPE = /^(?:pro|max|team|enterprise)(?:[-_ ].*)?$/i;
 
-function buildClaudeLaunch({ task, cwd, model, permissions = [] }) {
-  const args = [
-    "-p",
-    "--output-format",
-    "stream-json",
-    ...buildPermissionsArgs(permissions),
-    task
-  ];
+export const CLAUDE_AUTH_ERRORS = Object.freeze({
+  SUBSCRIPTION_REQUIRED: "claude_subscription_required",
+  INVALID_STATUS: "claude_auth_status_invalid"
+});
 
-  if (model) {
-    args.unshift("--model", model);
+export function buildClaudeExecutionEnv(sourceEnv = process.env) {
+  const env = Object.create(null);
+  for (const key of SAFE_ENV_KEYS) {
+    if (sourceEnv[key] != null && sourceEnv[key] !== "") env[key] = sourceEnv[key];
   }
+  return env;
+}
 
-  return {
+export async function verifyClaudeSubscriptionAuth({
+  env = process.env, runProcess = runBoundedProcess
+} = {}) {
+  const result = await runProcess({
     command: EXECUTABLE,
-    args,
-    cwd,
-    env: process.env
-  };
+    args: ["auth", "status"],
+    env: buildClaudeExecutionEnv(env),
+    stdin: null,
+    timeoutMs: AUTH_TIMEOUT_MS,
+    stdoutLimit: AUTH_OUTPUT_LIMIT,
+    stderrLimit: AUTH_OUTPUT_LIMIT
+  });
+  assertBoundedProcessOk(result);
+  let status;
+  try { status = JSON.parse(String(result.stdout ?? "").trim()); }
+  catch {
+    throw new ReviewExecError("Claude auth status did not return valid JSON.", {
+      code: CLAUDE_AUTH_ERRORS.INVALID_STATUS
+    });
+  }
+  if (status?.loggedIn !== true || status?.authMethod !== "claude.ai"
+    || status?.apiProvider !== "firstParty" || !SUBSCRIPTION_TYPE.test(status?.subscriptionType ?? "")) {
+    throw new ReviewExecError(
+      "Claude execution requires a first-party claude.ai Pro, Max, Team, or Enterprise subscription.",
+      { code: CLAUDE_AUTH_ERRORS.SUBSCRIPTION_REQUIRED }
+    );
+  }
+  return { mode: "subscription", subscriptionType: status.subscriptionType };
+}
+
+export function buildClaudeLaunch({ task, cwd, model, permissions = [], env = process.env }) {
+  const unsafeArgs = buildPermissionsArgs(permissions);
+  const permissionArgs = unsafeArgs.length > 0
+    ? unsafeArgs
+    : ["--permission-mode", "auto", "--permission-prompts", "none"];
+  const args = ["-p", "--output-format", "stream-json", ...permissionArgs, task];
+  if (model) args.unshift("--model", model);
+  return { command: EXECUTABLE, args, cwd, env: buildClaudeExecutionEnv(env) };
 }
 
 function parseClaudeEventLine(line) {
   const parsed = parseNdjsonLine(line);
   if (!parsed || typeof parsed !== "object") return null;
-
   if (parsed.type === "tool_use" || parsed.type === "tool_call") {
-    return {
-      type: "tool_call",
-      tool_name: parsed.name ?? parsed.tool ?? "unknown",
-      status: parsed.status ?? "started"
-    };
+    return { type: "tool_call", tool_name: parsed.name ?? parsed.tool ?? "unknown", status: parsed.status ?? "started" };
   }
-
   if (parsed.type === "usage" || parsed.usage) {
     const usage = parsed.usage ?? parsed;
     return {
@@ -45,7 +82,6 @@ function parseClaudeEventLine(line) {
       cost: usage.cost ?? null
     };
   }
-
   return parsed;
 }
 
@@ -54,13 +90,10 @@ export default createExecutionAdapter({
   label: "Claude Code",
   executable: EXECUTABLE,
   capabilities: {
-    structuredEvents: true,
-    tokens: true,
-    diff: false,
-    cancel: true,
-    transcript: true,
-    permissionModes: ["force", "yolo"]
+    structuredEvents: true, tokens: true, diff: false, cancel: true, transcript: true,
+    permissionModes: ["safe", "force", "yolo"]
   },
   buildLaunch: buildClaudeLaunch,
-  parseEventLine: parseClaudeEventLine
+  parseEventLine: parseClaudeEventLine,
+  preflight: verifyClaudeSubscriptionAuth
 });

package/src/global/runtime/execution-adapters/codex.js

@@ -1,4 +1,5 @@
 import { createExecutionAdapter, parseNdjsonLine } from "./create-execution-adapter.js";
+import { verifyCodexSubscriptionAuth } from "../../architect/architect-codex.js";
 
 const EXECUTABLE = "codex";
 
@@ -13,7 +14,12 @@ function buildCodexPermissionsArgs(permissions = []) {
     return ["--dangerously-bypass-approvals-and-sandbox"];
   }
 
-  return [];
+  // Safe headless default: sandboxed to the workspace, with approval
+  // requests auto-reviewed instead of blocking forever on a human who
+  // can't respond in a non-interactive run — mirrors claude.js's
+  // `--permission-mode auto --permission-prompts none`. Without this,
+  // `codex exec` hangs on its default on-request approval policy.
+  return ["--sandbox", "workspace-write", "--approve-for-me"];
 }
 
 function buildCodexLaunch({ task, cwd, model, permissions = [] }) {
@@ -76,5 +82,6 @@ export default createExecutionAdapter({
     permissionModes: ["yolo"]
   },
   buildLaunch: buildCodexLaunch,
-  parseEventLine: parseCodexEventLine
+  parseEventLine: parseCodexEventLine,
+  preflight: verifyCodexSubscriptionAuth
 });

package/src/global/runtime/execution-adapters/create-execution-adapter.js

@@ -11,7 +11,8 @@ export function createExecutionAdapter({
   buildLaunch,
   parseEventLine = null,
   checkAvailability = null,
-  launchable = null
+  launchable = null,
+  preflight = null
 }) {
   return {
     id,
@@ -63,6 +64,10 @@ export function createExecutionAdapter({
       return buildLaunch(options);
     },
 
+    async preflight(context = {}) {
+      return preflight ? preflight(context) : { ok: true };
+    },
+
     parseEventLine(line, context = {}) {
       if (!parseEventLine) return null;
       return parseEventLine(line, context);

package/src/global/runtime/execution-adapters/opencode.js

@@ -1,39 +1,104 @@
-import { createExecutionAdapter } from "./create-execution-adapter.js";
+import { createExecutionAdapter, parseNdjsonLine } from "./create-execution-adapter.js";
+import { isExecutableAvailable } from "../../cli-probe.js";
 
 const EXECUTABLE = "opencode";
 
+// Verified live (`opencode run --format json`) against a real account: the
+// CLI genuinely emits parseable NDJSON events — step_start/step_finish,
+// tool_use (with real tool name + status), text, and error — including
+// real per-step `tokens` {input, output, reasoning, cache} and `cost` on
+// step_finish. That earlier "does not emit auditable structured events"
+// claim was wrong; structuredEvents below is now an accurate capability.
+//
+// It stays `launchable: false` anyway, for a different, harder reason:
+// this adapter is shared by both OpenCode Go (subscription, $10/mo) and
+// OpenCode Zen (PAYG) — same `opencode` executable, same event shapes,
+// no field in any event that names which product tier actually served
+// the request. A live invocation with `-m opencode/<id>` for a model that
+// exists on BOTH tiers was confirmed to be ambiguous — no way to prove
+// after the fact whether it ran on Go or silently billed against Zen. A
+// second invocation with the Go-specific `opencode-go/<id>` prefix simply
+// hung. Per explicit decision: Kairo must not route real tasks through
+// this adapter until it can prove, from the run's own evidence, both (1)
+// the effective provider actually used was opencode-go, and (2) Zen was
+// not touched. Until that receipt-level proof exists, this stays blocked
+// — no more paid trial invocations to "just check" this again.
+function checkOpencodeAvailability(context = {}) {
+  const available = isExecutableAvailable(EXECUTABLE, { env: context.env ?? process.env });
+  if (!available) {
+    return {
+      available: false, compatible: false, launchable: false,
+      reason: `OpenCode CLI "${EXECUTABLE}" is not on PATH.`
+    };
+  }
+  return {
+    available: true, compatible: true, launchable: false,
+    reason: "OpenCode Go/Zen share one executable with no per-event way to prove which product tier actually served a run — blocked until that provider-isolation evidence exists."
+  };
+}
+
 function buildOpencodeLaunch({ task, cwd, model, permissions = [] }) {
-  const args = ["run", task];
+  // Not the adapter's call to make: which provider prefix ("opencode/" vs
+  // "opencode-go/") is safe for a given model id is exactly the unresolved
+  // question above. Whatever fully-qualified model ref the caller supplies
+  // is passed through unmodified, same as codex.js/claude.js do.
+  const args = ["run", "--format", "json"];
+  const normalized = permissions.map((entry) => String(entry).toLowerCase());
+  if (normalized.includes("yolo") || normalized.includes("force") || normalized.includes("all")) {
+    args.push("--auto");
+  }
+  if (model) args.push("--model", model);
+  args.push(task);
+  return { command: EXECUTABLE, args, cwd, env: process.env };
+}
+
+/**
+ * Verified against real captured output (`opencode run --format json`),
+ * not guessed: tool_use/tool -> tool_call, step_finish's real per-step
+ * tokens+cost -> usage, error -> passed through raw (no invented shape
+ * for a case never seen with a matching one here). Everything else
+ * (step_start, text) passes through raw, same fallback as the other
+ * adapters' parsers.
+ */
+export function parseOpencodeEventLine(line) {
+  const parsed = parseNdjsonLine(line);
+  if (!parsed || typeof parsed !== "object") return null;
 
-  if (model) {
-    args.unshift("--model", model);
+  if (parsed.type === "tool_use" && parsed.part?.type === "tool") {
+    return {
+      type: "tool_call",
+      tool_name: parsed.part.tool ?? "unknown",
+      status: parsed.part.state?.status ?? "started"
+    };
   }
 
-  if (permissions.includes("force") || permissions.includes("all")) {
-    args.unshift("--force");
+  if (parsed.type === "step_finish" && parsed.part?.tokens) {
+    const tokens = parsed.part.tokens;
+    return {
+      type: "usage",
+      inputTokens: tokens.input ?? null,
+      outputTokens: tokens.output ?? null,
+      totalTokens: tokens.total ?? null,
+      cost: parsed.part.cost ?? null
+    };
   }
 
-  return {
-    command: EXECUTABLE,
-    args,
-    cwd,
-    env: process.env
-  };
+  return parsed;
 }
 
 export default createExecutionAdapter({
   id: "opencode",
   label: "OpenCode",
   executable: EXECUTABLE,
-  launchable: false,
   capabilities: {
-    structuredEvents: false,
-    tokens: false,
+    structuredEvents: true,
+    tokens: true,
     diff: false,
     cancel: true,
-    transcript: false,
-    permissionModes: ["force"]
+    transcript: true,
+    permissionModes: ["force", "yolo"]
   },
+  checkAvailability: checkOpencodeAvailability,
   buildLaunch: buildOpencodeLaunch,
-  parseEventLine: null
+  parseEventLine: parseOpencodeEventLine
 });