@khalilgharbaoui/opencode-claude-code-plugin 0.18.2 → 0.19.0

package/dist/index.js

@@ -324,8 +324,8 @@ function mapTool(name, input, opts) {
   }
   if (name === "TaskUpdate") {
     if (opts?.sessionId) {
-      const list = applyTaskUpdate(opts.sessionId, input);
-      if (list !== null) return emitTodoWrite(list);
+      const list2 = applyTaskUpdate(opts.sessionId, input);
+      if (list2 !== null) return emitTodoWrite(list2);
     }
     return { name, input, executed: true, skip: true };
   }
@@ -1366,6 +1366,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     input: call.input,
     channel: call.channel,
     createdAt: Date.now(),
+    deadlineMs,
     timer,
     resolve: call.resolve,
     reject: call.reject
@@ -1397,6 +1398,21 @@ function getPendingProxyCalls(sessionKey2) {
   }
   return out;
 }
+function snapshotPendingProxyCalls(now = Date.now()) {
+  const out = [];
+  for (const pending of pendingByCallId.values()) {
+    out.push({
+      sessionKey: pending.sessionKey,
+      toolCallId: pending.toolCallId,
+      toolName: pending.toolName,
+      ageMs: Math.max(0, now - pending.createdAt),
+      deadlineMs: pending.deadlineMs,
+      emitted: pending.emitted === true,
+      channelClosed: pending.channel?.closed === true
+    });
+  }
+  return out;
+}
 function resolvePendingProxyCallById(toolCallId, result) {
   const pending = pendingByCallId.get(toolCallId);
   if (!pending) return false;
@@ -1832,6 +1848,18 @@ function takeUnattendedLines(ap) {
   ap.unattendedDropped = 0;
   return { lines, dropped };
 }
+var STDERR_RETAIN_BYTES = 2 * 1024;
+function retainStderr(ap, chunk) {
+  ap.lastStderr = ((ap.lastStderr ?? "") + chunk).slice(-STDERR_RETAIN_BYTES);
+}
+function describeChildCrash(exitCode, signal, lastStderr) {
+  const how = signal ? `was killed by ${signal}` : typeof exitCode === "number" ? `exited with code ${exitCode}` : "closed its output";
+  const tail = lastStderr?.trim();
+  return `The Claude Code CLI ${how} before finishing this turn (no result was emitted), so the answer above may be incomplete.` + (tail ? `
+
+Last stderr from the CLI:
+${tail}` : "");
+}
 var activeProcesses = /* @__PURE__ */ new Map();
 var claudeSessions = /* @__PURE__ */ new Map();
 var idleEvictionTimers = /* @__PURE__ */ new Map();
@@ -1877,10 +1905,22 @@ function touch(key) {
 }
 function evictIfNeeded() {
   while (activeProcesses.size >= MAX_ACTIVE_PROCESSES) {
-    const oldestKey = activeProcesses.keys().next().value;
-    if (!oldestKey) break;
-    log.info("evicting LRU claude process", { sessionKey: oldestKey });
-    deleteActiveProcess(oldestKey);
+    let victimKey;
+    for (const [key, ap] of activeProcesses) {
+      if (!isTurnInFlight(ap)) {
+        victimKey = key;
+        break;
+      }
+    }
+    if (!victimKey) {
+      log.warn("every claude process is mid-turn; skipping LRU eviction", {
+        active: activeProcesses.size,
+        cap: MAX_ACTIVE_PROCESSES
+      });
+      return;
+    }
+    log.info("evicting LRU claude process", { sessionKey: victimKey });
+    deleteActiveProcess(victimKey);
   }
 }
 var TURN_INTERRUPT_TIMEOUT_MS = 5e3;
@@ -2095,6 +2135,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     mcpHash,
     systemPromptFile,
     effort,
+    startedAt: Date.now(),
     cliArgs: [...cliArgs],
     unattendedLines: [],
     unattendedDropped: 0
@@ -2118,6 +2159,14 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   proc.on("error", (err) => {
     log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
   });
+  proc.stdin?.on("error", (err) => {
+    log.warn("claude process stdin error", {
+      sessionKey: sessionKey2,
+      code: err.code,
+      error: err.message
+    });
+    settleTurn(ap);
+  });
   proc.on("exit", (code, signal) => {
     log.info("claude process exited", { code, signal, sessionKey: sessionKey2 });
     void proxyServer?.close();
@@ -2141,6 +2190,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   proc.stderr?.on("data", (data) => {
     const stderr = data.toString();
     log.debug("stderr", { data: stderr.slice(0, 200) });
+    retainStderr(ap, stderr);
     if (stderr.includes("No conversation found") || stderr.includes("Session ID") && (stderr.includes("already in use") || stderr.includes("not found") || stderr.includes("invalid"))) {
       if (activeProcesses.get(sessionKey2) === ap) {
         log.warn("claude session ID error, clearing session", {
@@ -2263,6 +2313,36 @@ function buildCliArgs(opts) {
 function sessionKey(cwd, modelId) {
   return `${cwd}::${modelId}`;
 }
+function describeSessionKey(key) {
+  const parts = key.split("::");
+  return {
+    cwd: parts[0] ?? "unknown",
+    model: parts[1] ?? "unknown",
+    session: parts[3] ?? "unknown",
+    compaction: parts[2] === "compaction"
+  };
+}
+function snapshotActiveProcesses(now = Date.now()) {
+  const out = [];
+  for (const [key, ap] of activeProcesses) {
+    const described = describeSessionKey(key);
+    const lastStderr = ap.lastStderr;
+    out.push({
+      sessionKey: key,
+      session: ap.opencodeSessionID ?? described.session,
+      model: described.model,
+      compaction: described.compaction,
+      pid: ap.proc.pid,
+      inFlight: ap.turnInFlight === true,
+      ageMs: ap.startedAt === void 0 ? void 0 : Math.max(0, now - ap.startedAt),
+      effort: ap.effort,
+      attached: ap.lineEmitter.listenerCount("line") > 0,
+      proxyUrl: ap.proxyServer?.url,
+      lastStderr: typeof lastStderr === "string" ? lastStderr : void 0
+    });
+  }
+  return out;
+}
 
 // src/btw-command.ts
 var BtwHandledError = class extends Error {
@@ -2548,1359 +2628,2024 @@ async function handleBtwCommand(client, input, options = {}) {
   }
 }
 
-// src/message-builder.ts
-var ASIDE_MARKERS = [INLINE_ASIDE_MARKER, ...LEGACY_INLINE_ASIDE_MARKERS];
-function isInlineAside(part) {
-  if (!part || part.type !== "text" || typeof part.text !== "string") return false;
-  const text = part.text.trimStart();
-  return ASIDE_MARKERS.some((marker) => text.startsWith(marker));
+// src/cli-events.ts
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function stripInlineAsides(content) {
-  if (!Array.isArray(content)) return content;
-  const kept = content.filter((part) => !isInlineAside(part));
-  return kept.length === content.length ? content : kept;
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+var RATE_LIMIT_MARKER = "\u258C **rate limit:**";
+var RATE_LIMIT_ACTION = "Enable extra usage or add credits on the account, wait for the window to reset, switch account, org or plan, or authenticate with an API key.";
+var OVERAGE_DISABLED_REASONS = {
+  overage_not_provisioned: "extra usage is not set up on this account",
+  org_level_disabled: "extra usage is disabled for your organization",
+  org_level_disabled_until: "extra usage is disabled for your organization for now",
+  out_of_credits: "the account's usage credits are spent",
+  seat_tier_level_disabled: "your seat tier does not allow extra usage",
+  member_level_disabled: "extra usage is disabled for your member account",
+  seat_tier_zero_credit_limit: "your seat tier has a zero credit limit",
+  group_zero_credit_limit: "your group has a zero credit limit",
+  member_zero_credit_limit: "your member account has a zero credit limit",
+  org_service_level_disabled: "your organization's service level does not include extra usage",
+  no_limits_configured: "no usage limits are configured for this account",
+  fetch_error: "the CLI could not read the account's usage limits"
+};
+var RATE_LIMIT_WINDOWS = {
+  five_hour: "the 5-hour window",
+  seven_day: "the 7-day window",
+  seven_day_opus: "the 7-day Opus window",
+  seven_day_sonnet: "the 7-day Sonnet window",
+  seven_day_overage_included: "the 7-day extra-usage window",
+  overage: "extra usage"
+};
+function parseRateLimitEvent(msg) {
+  if (msg.type !== "rate_limit_event") return null;
+  const info = msg.rate_limit_info;
+  if (!isRecord2(info)) return null;
+  return {
+    status: str(info.status),
+    rateLimitType: str(info.rateLimitType),
+    resetsAt: num(info.resetsAt),
+    utilization: num(info.utilization),
+    isUsingOverage: info.isUsingOverage === true,
+    overageStatus: str(info.overageStatus),
+    overageResetsAt: num(info.overageResetsAt),
+    overageDisabledReason: str(info.overageDisabledReason)
+  };
 }
-function filterSideQuestionHistory(prompt) {
-  let aside = false;
-  const kept = prompt.filter((message) => {
-    if (message.role === "user") {
-      aside = parseSideQuestionContent(message.content) !== null;
-      return !aside;
-    }
-    return message.role !== "assistant" || !aside;
-  });
-  return kept.map(
-    (message) => message.role === "assistant" ? { ...message, content: stripInlineAsides(message.content) } : message
-  );
+function formatResetsAt(resetsAt) {
+  if (resetsAt === void 0) return void 0;
+  const ms = resetsAt < 1e12 ? resetsAt * 1e3 : resetsAt;
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
-var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp"
-]);
-function toImageBlock(part) {
-  const raw = part.image ?? part.data ?? part.url ?? part.source?.data;
-  if (!raw) {
-    log.warn("file part without data, skipping");
-    return null;
+function rateLimitKey(info) {
+  return [
+    info.status ?? "?",
+    info.rateLimitType ?? "?",
+    info.overageStatus ?? "?",
+    info.overageDisabledReason ?? "?"
+  ].join("|");
+}
+function isRateLimitRejected(info) {
+  return info.status === "rejected" || info.overageStatus === "rejected";
+}
+function describeRateLimit(info) {
+  if (!info.status && !info.overageStatus) return null;
+  const window = info.rateLimitType ? RATE_LIMIT_WINDOWS[info.rateLimitType] ?? info.rateLimitType : void 0;
+  const resets = formatResetsAt(info.resetsAt);
+  const overageResets = formatResetsAt(info.overageResetsAt);
+  const key = rateLimitKey(info);
+  if (isRateLimitRejected(info)) {
+    const parts = [];
+    parts.push(
+      info.status === "rejected" ? `Claude Code rejected this request: you are out of usage${window ? ` in ${window}` : ""}.` : "Claude Code rejected this request: paid extra usage is not available on this account."
+    );
+    const reason = info.overageDisabledReason ? OVERAGE_DISABLED_REASONS[info.overageDisabledReason] ?? info.overageDisabledReason : void 0;
+    if (reason) parts.push(`Extra usage is unavailable because ${reason}.`);
+    const resetAt = resets ?? overageResets;
+    if (resetAt) parts.push(`Resets at ${resetAt}.`);
+    parts.push(RATE_LIMIT_ACTION);
+    const message = parts.join(" ");
+    return { key, level: "warn", message, transcript: `
+${RATE_LIMIT_MARKER} ${message}
+` };
+  }
+  if (info.status === "allowed_warning" || info.overageStatus === "allowed_warning") {
+    const used = info.utilization === void 0 ? "" : ` (${Math.round(info.utilization * 100)}% used)`;
+    return {
+      key,
+      level: "notice",
+      message: `Approaching the usage limit${window ? ` for ${window}` : ""}${used}${resets ? `, resets at ${resets}` : ""}.`,
+      transcript: null
+    };
   }
-  let resolvedMediaType = part.mediaType || part.mimeType || part.mime || "";
-  let base64 = null;
-  if (typeof raw === "string") {
-    if (raw.startsWith("data:")) {
-      const match = /^data:([^;,]+)(?:;[^,]*)*(?:;base64)?,(.*)$/s.exec(raw);
-      if (!match) {
-        log.warn("malformed data URI, skipping file part");
-        return null;
-      }
-      resolvedMediaType = resolvedMediaType || match[1];
-      base64 = match[2];
-    } else if (/^https?:\/\//i.test(raw)) {
-      log.warn("remote URL images are not supported by Claude CLI, skipping");
-      return null;
-    } else {
-      base64 = raw;
-    }
-  } else if (raw instanceof URL) {
-    log.warn("remote URL images are not supported by Claude CLI, skipping");
-    return null;
-  } else if (raw instanceof Uint8Array || Buffer.isBuffer(raw)) {
-    base64 = Buffer.from(raw).toString("base64");
-  } else {
-    log.warn("unsupported file part data type", { dataType: typeof raw });
+  return {
+    key,
+    level: "info",
+    message: `usage limits updated${window ? ` for ${window}` : ""}`,
+    transcript: null
+  };
+}
+var reportedRateLimits = /* @__PURE__ */ new Set();
+function reportRateLimitEvent(msg) {
+  const info = parseRateLimitEvent(msg);
+  if (!info) return null;
+  const report = describeRateLimit(info);
+  if (!report) return null;
+  const data = { ...info };
+  if (reportedRateLimits.has(report.key)) {
+    log.debug(report.message, data);
     return null;
   }
-  if (!resolvedMediaType || !SUPPORTED_IMAGE_TYPES.has(resolvedMediaType)) {
-    log.warn("unsupported media type for Claude image block, skipping", {
-      mediaType: resolvedMediaType
-    });
-    return null;
+  reportedRateLimits.add(report.key);
+  log[report.level](report.message, data);
+  return report.transcript;
+}
+var API_KEY_SOURCES = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "apiKeyHelper",
+  "/login managed key",
+  "user",
+  "project",
+  "org",
+  "temporary"
+]);
+function parseSystemInit(msg) {
+  if (msg.type !== "system" || msg.subtype !== "init") return null;
+  const raw = msg;
+  const servers = [];
+  if (Array.isArray(raw.mcp_servers)) {
+    for (const entry of raw.mcp_servers) {
+      if (!isRecord2(entry)) continue;
+      servers.push({ name: str(entry.name) ?? "unknown", status: str(entry.status) ?? "unknown" });
+    }
   }
   return {
-    type: "image",
-    source: { type: "base64", media_type: resolvedMediaType, data: base64 }
+    apiKeySource: str(raw.apiKeySource),
+    permissionMode: str(raw.permissionMode),
+    model: str(raw.model),
+    cliVersion: str(raw.claude_code_version),
+    toolCount: Array.isArray(raw.tools) ? raw.tools.length : 0,
+    mcpServers: servers
   };
 }
-function getToolResultText(part) {
-  const value = part.output ?? part.result;
-  if (typeof value === "string") {
-    return value;
-  }
-  if (!value || typeof value !== "object") {
-    return JSON.stringify(value);
+function apiKeySourceWarning(apiKeySource, ignoreAnthropicApiKey) {
+  if (!apiKeySource || !API_KEY_SOURCES.has(apiKeySource)) return null;
+  const base = `Claude Code authenticated with an API key (apiKeySource: ${apiKeySource}), so these turns bill as pay-as-you-go API usage instead of your subscription's Agent SDK credit.`;
+  return ignoreAnthropicApiKey ? `${base} \`ignoreAnthropicApiKey\` is already on, so the key is not coming from the environment: check the CLI's own settings (\`claude config\`) or an \`apiKeyHelper\`.` : `${base} Set the provider option \`ignoreAnthropicApiKey: true\` to strip the key from spawns and fall back to the stored subscription auth.`;
+}
+var warnedApiKeySources = /* @__PURE__ */ new Set();
+var warnedMcpFailures = /* @__PURE__ */ new Set();
+function reportSystemInit(msg, options = {}) {
+  const info = parseSystemInit(msg);
+  if (!info) return;
+  log.info("claude session init", {
+    apiKeySource: info.apiKeySource ?? null,
+    permissionMode: info.permissionMode ?? null,
+    model: info.model ?? null,
+    cliVersion: info.cliVersion ?? null,
+    tools: info.toolCount,
+    mcpServers: info.mcpServers
+  });
+  for (const server2 of info.mcpServers) {
+    if (server2.status === "connected") continue;
+    const key2 = `${server2.name}:${server2.status}`;
+    const message = `MCP server "${server2.name}" is ${server2.status} in Claude Code; its tools are not available to the model this session.`;
+    if (warnedMcpFailures.has(key2)) {
+      log.debug(message, { server: server2.name, status: server2.status });
+      continue;
+    }
+    warnedMcpFailures.add(key2);
+    log.warn(message, { server: server2.name, status: server2.status });
   }
-  switch (value.type) {
-    case "text":
-    case "error-text":
-      return String(value.value);
-    case "json":
-    case "error-json":
-      return JSON.stringify(value.value);
-    case "execution-denied":
-      return value.reason ? `Execution denied: ${value.reason}` : "Execution denied";
-    case "content":
-      return Array.isArray(value.value) ? value.value.map((item) => {
-        if (item?.type === "text") return item.text;
-        return JSON.stringify(item);
-      }).join("\n") : JSON.stringify(value.value);
-    default:
-      return JSON.stringify(value);
+  const apiKeyMessage = apiKeySourceWarning(info.apiKeySource, options.ignoreAnthropicApiKey);
+  if (!apiKeyMessage) return;
+  const key = `${info.apiKeySource}:${options.ignoreAnthropicApiKey ? "ignored" : "passed"}`;
+  if (warnedApiKeySources.has(key)) {
+    log.debug(apiKeyMessage, { apiKeySource: info.apiKeySource });
+    return;
   }
+  warnedApiKeySources.add(key);
+  log.warn(apiKeyMessage, { apiKeySource: info.apiKeySource });
 }
-var MAX_HISTORY_CHARS = 18e4;
-var MAX_TOOL_RESULT_CHARS = 1e4;
-var MAX_TOOL_INPUT_CHARS = 2e3;
-function clipWithMarker(text, max) {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max)}
-\u2026[truncated ${text.length - max} chars]`;
+var COMPACT_BOUNDARY_MARKER = "\u258C **context compacted:**";
+function parseCompactBoundary(msg) {
+  if (msg.type !== "system" || msg.subtype !== "compact_boundary") return null;
+  const raw = msg;
+  const meta = isRecord2(raw.compact_metadata) ? raw.compact_metadata : isRecord2(raw.compactMetadata) ? raw.compactMetadata : void 0;
+  return {
+    trigger: str(meta?.trigger) ?? "unknown",
+    preTokens: num(meta?.pre_tokens) ?? num(meta?.preTokens),
+    postTokens: num(meta?.post_tokens) ?? num(meta?.postTokens)
+  };
 }
-function renderToolInput(input) {
-  let raw;
+function formatCompactBoundaryNote(boundary) {
+  const how = boundary.trigger === "auto" ? "on its own" : `on a ${boundary.trigger} request`;
+  const sizes = boundary.preTokens !== void 0 && boundary.postTokens !== void 0 ? ` (${boundary.preTokens.toLocaleString("en-US")} tokens to ${boundary.postTokens.toLocaleString("en-US")})` : "";
+  return `
+${COMPACT_BOUNDARY_MARKER} Claude Code compacted its own context ${how}${sizes}. Earlier detail in this conversation is now a summary.
+`;
+}
+function reportCompactBoundary(msg) {
+  const boundary = parseCompactBoundary(msg);
+  if (!boundary) return null;
+  log.notice("claude code compacted its own context", {
+    trigger: boundary.trigger,
+    preTokens: boundary.preTokens ?? null,
+    postTokens: boundary.postTokens ?? null
+  });
+  return formatCompactBoundaryNote(boundary);
+}
+var RESULT_ERROR_MARKER = "\u258C **claude code error:**";
+var RESULT_SUBTYPES = {
+  error_max_turns: "it hit its internal turn limit before finishing",
+  error_during_execution: "it failed while running the turn",
+  error_max_budget_usd: "it hit the configured spend limit for the turn",
+  error_max_structured_output_retries: "it could not produce valid structured output"
+};
+function describeResultFailure(msg) {
+  if (msg.type !== "result") return null;
+  const subtype = msg.subtype;
+  if (!subtype || subtype === "success") return null;
+  const explanation = RESULT_SUBTYPES[subtype];
+  return explanation ? `Claude Code ended the turn with \`${subtype}\`: ${explanation}.` : `Claude Code ended the turn with \`${subtype}\`.`;
+}
+function formatResultFailureNote(message) {
+  return `
+${RESULT_ERROR_MARKER} ${message}
+`;
+}
+
+// src/startup-diagnostics.ts
+import { execFile as execFile2 } from "child_process";
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { promisify as promisify2 } from "util";
+import { fileURLToPath } from "url";
+
+// src/mcp-bridge.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+import * as crypto2 from "crypto";
+import {
+  parse as parseJsonc,
+  printParseErrorCode
+} from "jsonc-parser";
+var FILE_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
+var PROJECT_FILE_NAMES = ["opencode.json", "opencode.jsonc"];
+function fileExists(p) {
   try {
-    raw = typeof input === "string" ? input : JSON.stringify(input);
+    return fs3.statSync(p).isFile();
   } catch {
-    raw = String(input);
+    return false;
   }
-  return clipWithMarker(raw, MAX_TOOL_INPUT_CHARS);
 }
-function renderMessageContentForCompaction(msg) {
-  const lines = [];
-  let toolResultCount = 0;
-  if (typeof msg.content === "string") {
-    return { text: msg.content, toolResultCount: 0 };
-  }
-  if (!Array.isArray(msg.content)) {
-    return { text: "", toolResultCount: 0 };
-  }
-  for (const part of msg.content) {
-    if (!part) continue;
-    switch (part.type) {
-      case "text":
-        if (part.text) lines.push(part.text);
-        break;
-      case "tool-call":
-        lines.push(
-          `[tool_use:${part.toolName ?? "unknown"}(${renderToolInput(part.input)})]`
-        );
-        break;
-      case "tool-result":
-        toolResultCount++;
-        lines.push(
-          `[tool_result:${part.toolName ?? part.toolCallId ?? "unknown"}]
-${clipWithMarker(
-            getToolResultText(part),
-            MAX_TOOL_RESULT_CHARS
-          )}`
-        );
-        break;
-      case "image":
-        lines.push(
-          `[image: ${part.mediaType ?? part.mimeType ?? "unknown"}]`
-        );
-        break;
-      case "file":
-        lines.push(
-          `[file: ${part.mediaType ?? part.mimeType ?? "unknown"}]`
-        );
-        break;
-      case "reasoning":
-        break;
-    }
+function dirExists(p) {
+  try {
+    return fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
   }
-  return { text: lines.join("\n"), toolResultCount };
 }
-function compactConversationHistory(prompt, opts = {}) {
-  const mode = opts.mode ?? "fresh-session";
-  prompt = filterSideQuestionHistory(prompt);
-  if (mode === "compaction") {
-    return buildCompactionHistory(prompt);
-  }
-  const conversationMessages = prompt.filter(
-    (m) => m.role === "user" || m.role === "assistant" || m.role === "tool"
-  );
-  if (conversationMessages.length <= 1) {
-    return null;
-  }
-  const historyParts = [];
-  for (let i = 0; i < conversationMessages.length - 1; i++) {
-    const msg = conversationMessages[i];
-    const role = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "Tool";
-    const { text } = renderMessageContentForCompaction(msg);
-    if (text.trim()) {
-      const truncated = text.length > 2e3 ? text.slice(0, 2e3) + "..." : text;
-      historyParts.push(`${role}: ${truncated}`);
+function readAndParse(file) {
+  try {
+    const raw = fs3.readFileSync(file, "utf8");
+    const errors = [];
+    const parsed = parseJsonc(raw, errors, { allowTrailingComma: true });
+    if (errors.length > 0) {
+      const first = errors[0];
+      throw new Error(
+        `${printParseErrorCode(first.error)} at offset ${first.offset}`
+      );
     }
-  }
-  if (historyParts.length === 0) {
+    return parsed;
+  } catch (e) {
+    log.warn("failed to parse opencode config", {
+      file,
+      error: e instanceof Error ? e.message : String(e)
+    });
     return null;
   }
-  return historyParts.join("\n\n");
 }
-function buildCompactionHistory(prompt) {
-  const entries = [];
-  let total = 0;
-  let totalToolResults = 0;
-  let droppedOldest = 0;
-  const end = prompt.length > 0 && prompt[prompt.length - 1].role === "user" ? prompt.length - 1 : prompt.length;
-  for (let i = end - 1; i >= 0; i--) {
-    const msg = prompt[i];
-    const roleLabel = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : msg.role === "tool" ? "Tool" : msg.role;
-    const { text, toolResultCount } = renderMessageContentForCompaction(msg);
-    if (!text.trim()) continue;
-    const entry = `${roleLabel}: ${text}`;
-    if (total + entry.length > MAX_HISTORY_CHARS) {
-      droppedOldest = i + 1;
-      break;
+function isPlainObject(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function deepMerge(target, source) {
+  const out = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    if (v === void 0) continue;
+    const existing = out[k];
+    if (isPlainObject(existing) && isPlainObject(v)) {
+      out[k] = deepMerge(existing, v);
+    } else {
+      out[k] = v;
     }
-    entries.push(entry);
-    total += entry.length + 2;
-    totalToolResults += toolResultCount;
   }
-  if (entries.length === 0) return null;
-  entries.reverse();
-  log.info("built compaction history", {
-    entries: entries.length,
-    chars: total,
-    toolResults: totalToolResults,
-    droppedOldestBefore: droppedOldest
-  });
-  return entries.join("\n\n");
+  return out;
 }
-function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {}) {
-  const compactionMode = opts.compactionMode === true;
-  const cliToolCallIds = opts.cliToolCallIds;
-  const content = [];
-  const pushToolResult = (part) => {
-    const id = part.toolCallId;
-    const text = getToolResultText(part);
-    if (!cliToolCallIds || cliToolCallIds.has(id)) {
-      content.push({ type: "tool_result", tool_use_id: id, content: text });
-      return;
-    }
-    log.info("rendering opencode-side tool result as text", {
-      toolCallId: id,
-      toolName: part.toolName,
-      chars: text.length
-    });
-    content.push({
-      type: "text",
-      text: `<opencode_tool_result tool="${part.toolName ?? "unknown"}">
-${text}
-</opencode_tool_result>`
-    });
-  };
-  if (compactionMode) {
-    const transcript = compactConversationHistory(prompt, {
-      mode: "compaction"
-    });
-    if (transcript) {
-      log.info("including compaction transcript", {
-        historyLength: transcript.length
-      });
-      content.push({
-        type: "text",
-        text: `<conversation_transcript>
-${transcript}
-</conversation_transcript>
-
-The complete prior conversation appears above. The synthesis instructions follow below.
-
-`
-      });
+function walkUp(opts) {
+  const out = [];
+  let current = path3.resolve(opts.start);
+  while (true) {
+    for (const target of opts.targets) {
+      const candidate = path3.join(current, target);
+      if (opts.predicate(candidate)) out.push(candidate);
     }
-  } else if (includeHistoryContext) {
-    const historyContext = compactConversationHistory(prompt);
-    if (historyContext) {
-      log.info("including conversation history context", {
-        historyLength: historyContext.length
-      });
-      content.push({
-        type: "text",
-        text: `<conversation_history>
-The following is a summary of our conversation so far (from a previous session that couldn't be resumed):
-
-${historyContext}
-
-</conversation_history>
-
-Now continuing with the current message:
-
-`
-      });
+    if (opts.stop && current === path3.resolve(opts.stop)) break;
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return out;
+}
+function detectWorktree(cwd) {
+  const override = process.env.OPENCODE_WORKTREE;
+  if (override) return path3.resolve(override);
+  let current = path3.resolve(cwd);
+  while (true) {
+    const gitPath = path3.join(current, ".git");
+    try {
+      if (fs3.existsSync(gitPath)) return current;
+    } catch {
     }
+    const parent = path3.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
   }
-  const messages = [];
-  for (let i = prompt.length - 1; i >= 0; i--) {
-    if (prompt[i].role === "assistant") break;
-    messages.unshift(prompt[i]);
+}
+function globalConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
+  return path3.join(xdg, "opencode");
+}
+function loadGlobalConfig() {
+  const dir = globalConfigDir();
+  let merged = {};
+  for (const name of FILE_NAMES.slice().reverse()) {
+    const file = path3.join(dir, name);
+    if (!fileExists(file)) continue;
+    const parsed = readAndParse(file);
+    if (parsed) merged = deepMerge(merged, parsed);
   }
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      if (parseSideQuestionContent(msg.content) !== null) continue;
-      if (typeof msg.content === "string") {
-        const str = msg.content;
-        if (str.trim()) {
-          content.push({ type: "text", text: str });
-        }
-      } else if (Array.isArray(msg.content)) {
-        for (const part of msg.content) {
-          if (part.type === "text") {
-            if (part.text && part.text.trim()) {
-              content.push({ type: "text", text: part.text });
-            }
-          } else if (part.type === "file" || part.type === "image") {
-            const block = toImageBlock(part);
-            if (block) {
-              content.push(block);
-            } else {
-              log.debug("skipped non-image file part", {
-                mediaType: part.mediaType
-              });
-            }
-          } else if (part.type === "tool-result") {
-            pushToolResult(part);
-          }
-        }
-      }
-    } else if (msg.role === "tool") {
-      if (Array.isArray(msg.content)) {
-        for (const part of msg.content) {
-          if (part?.type === "tool-result") {
-            pushToolResult(part);
-          }
-        }
-      }
+  return merged;
+}
+function loadProjectFilesInDir(dir) {
+  let merged = {};
+  for (const name of PROJECT_FILE_NAMES) {
+    const file = path3.join(dir, name);
+    if (!fileExists(file)) continue;
+    const parsed = readAndParse(file);
+    if (parsed) merged = deepMerge(merged, parsed);
+  }
+  return merged;
+}
+function dotOpencodeDirs(cwd, worktree) {
+  const dirs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    const abs = path3.resolve(p);
+    if (!seen.has(abs) && dirExists(abs)) {
+      seen.add(abs);
+      dirs.push(abs);
     }
+  };
+  for (const dir of walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: [".opencode"],
+    predicate: dirExists
+  })) {
+    push(dir);
   }
-  if (content.length === 0) {
-    log.warn("empty user content; sending sentinel to satisfy CLI");
-    return JSON.stringify({
-      type: "user",
-      message: {
-        role: "user",
-        content: [{ type: "text", text: "(empty)" }]
-      }
+  const home = os2.homedir();
+  if (home) {
+    const homeDot = path3.join(home, ".opencode");
+    if (dirExists(homeDot)) push(homeDot);
+  }
+  const envDir = process.env.OPENCODE_CONFIG_DIR;
+  if (envDir && dirExists(envDir)) push(envDir);
+  return dirs;
+}
+function substituteEnvPlaceholders(source) {
+  const out = {};
+  for (const [k, v] of Object.entries(source)) {
+    if (typeof v !== "string") continue;
+    out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+      const resolved = process.env[name];
+      return typeof resolved === "string" ? resolved : "";
     });
   }
-  return JSON.stringify({
-    type: "user",
-    message: {
-      role: "user",
-      content
+  return out;
+}
+function translateServer(name, spec) {
+  if (spec.enabled === false) return null;
+  const type = spec.type;
+  if (type === "local") {
+    const cmd = spec.command;
+    if (!Array.isArray(cmd) || cmd.length === 0) {
+      log.warn("skipping local MCP server with no command", { name });
+      return null;
+    }
+    const out = {
+      type: "stdio",
+      command: String(cmd[0])
+    };
+    if (cmd.length > 1) out.args = cmd.slice(1).map((s) => String(s));
+    if (spec.environment && typeof spec.environment === "object") {
+      out.env = substituteEnvPlaceholders(
+        spec.environment
+      );
+    }
+    return out;
+  }
+  if (type === "remote") {
+    if (typeof spec.url !== "string" || !spec.url) {
+      log.warn("skipping remote MCP server with no url", { name });
+      return null;
+    }
+    const out = {
+      type: "http",
+      url: spec.url
+    };
+    if (spec.headers && typeof spec.headers === "object") {
+      out.headers = substituteEnvPlaceholders(
+        spec.headers
+      );
     }
+    return out;
+  }
+  log.warn("skipping MCP server with unknown type", {
+    name,
+    type: type ?? null
   });
+  return null;
 }
-
-// src/agent-models.ts
-import { readFile, readdir } from "fs/promises";
-import path3 from "path";
-
-// src/models.ts
-var PROVIDER_ID = "claude-code";
-var NPM = "@khalilgharbaoui/opencode-claude-code-plugin";
-var reasoningVariants = {
-  low: { reasoningEffort: "low" },
-  medium: { reasoningEffort: "medium" },
-  high: { reasoningEffort: "high" },
-  xhigh: { reasoningEffort: "xhigh" },
-  max: { reasoningEffort: "max" }
-};
-var baseCapabilities = {
-  temperature: false,
-  attachment: true,
-  toolcall: true,
-  input: { text: true, audio: false, image: true, video: false, pdf: false },
-  output: { text: true, audio: false, image: false, video: false, pdf: false },
-  interleaved: false
-};
-function defineModel(opts) {
-  return {
-    id: opts.id,
-    providerID: PROVIDER_ID,
-    api: { id: opts.id, url: "", npm: NPM },
-    name: `${opts.name} (${opts.multiplier}\xD7)`,
-    family: opts.family,
-    capabilities: { ...baseCapabilities, reasoning: opts.reasoning },
-    cost: {
-      input: opts.cost.input,
-      output: opts.cost.output,
-      cache: { read: opts.cost.cacheRead, write: opts.cost.cacheWrite }
-    },
-    limit: { context: opts.context, output: opts.output },
-    status: opts.status ?? "active",
-    options: {},
-    headers: {},
-    release_date: opts.releaseDate,
-    variants: opts.reasoning ? reasoningVariants : void 0
-  };
+function extractMcpBlock(config) {
+  const mcp = config.mcp;
+  if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) return {};
+  return mcp;
 }
-var haikuCost = { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 };
-var sonnetCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
-var opusCost = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
-var fableCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
-var fable51Cost = { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 };
-var opusFastCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
-function toConfigModel(model) {
-  const inputMods = [];
-  const outputMods = [];
-  for (const [k, v] of Object.entries(model.capabilities.input)) {
-    if (v) inputMods.push(k);
+function mergeMcp(target, source) {
+  const out = { ...target };
+  for (const [name, spec] of Object.entries(source)) {
+    if (!spec || typeof spec !== "object") continue;
+    const existing = out[name];
+    if (existing && typeof existing === "object") {
+      out[name] = deepMerge(
+        existing,
+        spec
+      );
+    } else {
+      out[name] = spec;
+    }
   }
-  for (const [k, v] of Object.entries(model.capabilities.output)) {
-    if (v) outputMods.push(k);
+  return out;
+}
+function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
+  const {
+    servers: merged,
+    enabledServerNames: allEnabledServerNames,
+    hash
+  } = mergeOpencodeMcp(cwd, runtimeStatus);
+  const servers = {};
+  const bridgedServerNames = [];
+  for (const [name, spec] of Object.entries(merged)) {
+    if (!spec || typeof spec !== "object") continue;
+    if (excludeServers?.has(name)) continue;
+    const translated = translateServer(name, spec);
+    if (translated) {
+      servers[name] = translated;
+      bridgedServerNames.push(name);
+    }
+  }
+  return finishBridge({
+    servers,
+    bridgedServerNames,
+    allEnabledServerNames,
+    hash,
+    excludeServers
+  });
+}
+function mergeOpencodeMcp(cwd, runtimeStatus) {
+  const worktree = detectWorktree(cwd);
+  let merged = {};
+  merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
+  const explicitConfig = process.env.OPENCODE_CONFIG;
+  if (explicitConfig && fileExists(explicitConfig)) {
+    const parsed = readAndParse(explicitConfig);
+    if (parsed) merged = mergeMcp(merged, extractMcpBlock(parsed));
+  }
+  const projectFiles = walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: PROJECT_FILE_NAMES,
+    predicate: fileExists
+  });
+  const projectDirs = [];
+  const seenProjectDirs = /* @__PURE__ */ new Set();
+  for (const f of projectFiles) {
+    const d = path3.dirname(f);
+    if (!seenProjectDirs.has(d)) {
+      seenProjectDirs.add(d);
+      projectDirs.push(d);
+    }
+  }
+  for (const dir of projectDirs.slice().reverse()) {
+    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
+  }
+  for (const dir of dotOpencodeDirs(cwd, worktree)) {
+    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
+  }
+  if (runtimeStatus) {
+    for (const name of Object.keys(merged)) {
+      const status = runtimeStatus[name];
+      if (status === void 0) continue;
+      const existing = merged[name];
+      const base = existing && typeof existing === "object" ? existing : {};
+      merged[name] = { ...base, enabled: status === "connected" };
+    }
   }
+  const enabledServerNames = [];
+  for (const [name, spec] of Object.entries(merged)) {
+    if (!spec || typeof spec !== "object") continue;
+    const enabled = spec.enabled;
+    if (enabled === false) continue;
+    enabledServerNames.push(name);
+  }
+  const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
+  const hash = crypto2.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
+  return { servers: merged, enabledServerNames, hash };
+}
+function finishBridge(input) {
+  const { servers, bridgedServerNames, allEnabledServerNames, hash, excludeServers } = input;
+  if (Object.keys(servers).length === 0) {
+    const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
+    if (!allEnabledServersExcluded) return null;
+    return {
+      path: "",
+      hash,
+      serverNames: [],
+      allEnabledServerNames
+    };
+  }
+  const body = JSON.stringify({ mcpServers: servers }, null, 2);
+  const outPath = path3.join(
+    pluginTmpDir(),
+    `mcp-${hash}.json`
+  );
+  try {
+    if (!fileExists(outPath)) {
+      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+    }
+  } catch (e) {
+    log.warn("failed to write bridged MCP config", {
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return null;
+  }
+  log.info("bridged opencode MCP config", {
+    target: outPath,
+    hash,
+    servers: bridgedServerNames,
+    excluded: excludeServers ? Array.from(excludeServers) : []
+  });
   return {
-    id: model.api.id,
-    name: model.name,
-    status: model.status,
-    family: model.family ?? "",
-    release_date: model.release_date,
-    temperature: model.capabilities.temperature,
-    reasoning: model.capabilities.reasoning,
-    attachment: model.capabilities.attachment,
-    tool_call: model.capabilities.toolcall,
-    modalities: { input: inputMods, output: outputMods },
-    cost: {
-      input: model.cost.input,
-      output: model.cost.output,
-      cache_read: model.cost.cache.read,
-      cache_write: model.cost.cache.write
-    },
-    limit: model.limit,
-    options: model.options,
-    headers: model.headers,
-    variants: model.variants
+    path: outPath,
+    hash,
+    serverNames: bridgedServerNames,
+    allEnabledServerNames
   };
 }
-var defaultModels = {
-  "claude-haiku-4-5": defineModel({
-    id: "claude-haiku-4-5",
-    name: "Claude Haiku 4.5",
-    family: "haiku",
-    reasoning: false,
-    context: 2e5,
-    output: 64e3,
-    cost: haikuCost,
-    multiplier: 1,
-    releaseDate: "2025-10-01"
-  }),
-  "claude-sonnet-4-5": defineModel({
-    id: "claude-sonnet-4-5",
-    name: "Claude Sonnet 4.5",
-    family: "sonnet",
-    reasoning: true,
-    context: 2e5,
-    output: 64e3,
-    cost: sonnetCost,
-    multiplier: 3,
-    releaseDate: "2025-09-29"
-  }),
-  "claude-sonnet-4-6": defineModel({
-    id: "claude-sonnet-4-6",
-    name: "Claude Sonnet 4.6",
-    family: "sonnet",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: sonnetCost,
-    multiplier: 3,
-    releaseDate: "2025-06-19"
-  }),
-  "claude-sonnet-5": defineModel({
-    id: "claude-sonnet-5",
-    name: "Claude Sonnet 5",
-    family: "sonnet",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: sonnetCost,
-    multiplier: 3,
-    releaseDate: "2026-06-30"
-  }),
-  "claude-opus-4-5": defineModel({
-    id: "claude-opus-4-5",
-    name: "Claude Opus 4.5",
-    family: "opus",
-    reasoning: true,
-    context: 2e5,
-    output: 64e3,
-    cost: opusCost,
-    multiplier: 5,
-    releaseDate: "2025-11-01"
-  }),
-  "claude-opus-4-6": defineModel({
-    id: "claude-opus-4-6",
-    name: "Claude Opus 4.6",
-    family: "opus",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: opusCost,
-    multiplier: 5,
-    releaseDate: "2025-06-19"
-  }),
-  "claude-opus-4-7": defineModel({
-    id: "claude-opus-4-7",
-    name: "Claude Opus 4.7",
-    family: "opus",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: opusCost,
-    multiplier: 5,
-    releaseDate: "2025-07-16"
-  }),
-  "claude-opus-4-8": defineModel({
-    id: "claude-opus-4-8",
-    name: "Claude Opus 4.8",
-    family: "opus",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: opusCost,
-    multiplier: 5,
-    releaseDate: "2026-05-28"
-  }),
-  // Fast mode. The `-fast` suffix is OUR marker, not a model name Anthropic
-  // serves: `parseModelId` strips it before `--model` and turns it into
-  // `--settings {"fastMode":true}` on the spawn. Retired `-fast` model strings
-  // (`claude-opus-4-6-fast`) are a different thing and are not registered here.
-  //
-  // Only Opus 4.8 and Opus 5 qualify: the CLI gates fast mode on the resolved
-  // model name containing `opus-4-8` or `opus-5`, so registering a fast entry
-  // for any other model would produce a picker option that silently runs at
-  // standard speed while displaying the 10x price.
-  "claude-opus-4-8-fast": defineModel({
-    id: "claude-opus-4-8-fast",
-    name: "Claude Opus 4.8 Fast",
-    family: "opus",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: opusFastCost,
-    multiplier: 10,
-    releaseDate: "2026-05-28"
-  }),
-  "claude-opus-5": defineModel({
-    id: "claude-opus-5",
-    name: "Claude Opus 5",
-    family: "opus",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: opusCost,
-    multiplier: 5,
-    releaseDate: "2026-07-24"
-  }),
-  "claude-opus-5-fast": defineModel({
-    id: "claude-opus-5-fast",
-    name: "Claude Opus 5 Fast",
-    family: "opus",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: opusFastCost,
-    multiplier: 10,
-    releaseDate: "2026-07-24"
-  }),
-  "claude-fable-5": defineModel({
-    id: "claude-fable-5",
-    name: "Claude Fable 5",
-    family: "fable",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: fableCost,
-    multiplier: 10,
-    releaseDate: "2026-06-09"
-  }),
-  "claude-fable-5-1": defineModel({
-    id: "claude-fable-5-1",
-    name: "Claude Fable 5.1",
-    family: "fable",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: fable51Cost,
-    multiplier: 10,
-    releaseDate: "2026-09-01"
-  }),
-  // Mythos 5 and 5.1 share the corresponding Fable models' capabilities and
-  // pricing without the safety classifiers; limited availability via Project
-  // Glasswing. `claude --model` simply errors for accounts without access, so
-  // they are safe to register unconditionally.
-  "claude-mythos-5": defineModel({
-    id: "claude-mythos-5",
-    name: "Claude Mythos 5",
-    family: "mythos",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: fableCost,
-    multiplier: 10,
-    releaseDate: "2026-06-09"
-  }),
-  "claude-mythos-5-1": defineModel({
-    id: "claude-mythos-5-1",
-    name: "Claude Mythos 5.1",
-    family: "mythos",
-    reasoning: true,
-    context: 1e6,
-    output: 128e3,
-    cost: fable51Cost,
-    multiplier: 10,
-    releaseDate: "2026-09-01"
-  })
-};
-var FAST_SUFFIX = "-fast";
-function parseModelId(modelId) {
-  const at = modelId.indexOf("@");
-  const base = at === -1 ? modelId : modelId.slice(0, at);
-  const account = at === -1 ? "" : modelId.slice(at);
-  if (!base.endsWith(FAST_SUFFIX)) return { model: modelId, fast: false };
-  if (!Object.hasOwn(defaultModels, base)) return { model: modelId, fast: false };
-  return { model: base.slice(0, -FAST_SUFFIX.length) + account, fast: true };
-}
 
-// src/agent-models.ts
-var AGENT_DIR_NAMES = ["agents", "agent"];
-var REASONING_EFFORTS = [
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-var registry = {};
-var defaultSubagentModel;
-function setAgentRegistry(records) {
-  registry = records;
+// src/runtime-status.ts
+var opencodeClient = null;
+function setOpencodeClient(client) {
+  if (client && typeof client === "object") {
+    opencodeClient = client;
+  }
 }
-function getAgentRegistry() {
-  return registry;
+function getOpencodeClient() {
+  return opencodeClient;
 }
-function setDefaultSubagentModel(model) {
-  defaultSubagentModel = model?.trim() || void 0;
+var opencodeProjectDirectory;
+function setOpencodeProjectDirectory(dir) {
+  opencodeProjectDirectory = dir;
 }
-function getDefaultSubagentModel() {
-  return defaultSubagentModel;
+function getOpencodeProjectDirectory() {
+  return opencodeProjectDirectory;
 }
-function accountMarker(modelId) {
-  const at = modelId.indexOf("@");
-  return at === -1 ? "" : modelId.slice(at);
+function isUsableDirectory(d) {
+  return typeof d === "string" && d.length > 1 && d !== "/";
 }
-function withoutAccountMarker(modelId) {
-  const at = modelId.indexOf("@");
-  return at === -1 ? modelId : modelId.slice(0, at);
+function resolveSpawnCwdFrom(configured, live, captured, sessionDir) {
+  if (configured) return configured;
+  if (isUsableDirectory(sessionDir)) return sessionDir;
+  if (isUsableDirectory(live)) return live;
+  return captured ?? live;
 }
-function resolveAgentModel(agent, modelId, overrides) {
-  if (!agent) return modelId;
-  const record = (overrides?.records ?? registry)[agent];
-  if (!record) return modelId;
-  if (record.model?.includes("/")) return modelId;
-  const fallback = overrides ? overrides.defaultSubagentModel : defaultSubagentModel;
-  const declared = record.forceModel?.trim();
-  const wanted = declared || (record.mode === "subagent" ? fallback : void 0);
-  if (!wanted) return modelId;
-  const base = withoutAccountMarker(wanted);
-  if (!Object.hasOwn(defaultModels, base)) {
-    log.warn("agent model override refused: unknown model", {
-      agent,
-      wanted: base,
-      keeping: modelId
-    });
-    return modelId;
-  }
-  const resolved = `${base}${accountMarker(modelId)}`;
-  if (resolved !== modelId) {
-    log.debug("agent model override", { agent, from: modelId, to: resolved });
-  }
-  return resolved;
+async function resolveSpawnCwdForSession(configured, sessionID) {
+  if (configured) return configured;
+  const sessionDir = sessionID ? await fetchSessionDirectory(sessionID) : void 0;
+  return resolveSpawnCwdFrom(
+    configured,
+    process.cwd(),
+    opencodeProjectDirectory,
+    sessionDir
+  );
 }
-function resolveAgentEffort(agent, inherited, overrides) {
-  if (!agent) return inherited;
-  const record = (overrides?.records ?? registry)[agent];
-  const declared = record?.reasoningEffort?.trim();
-  if (!declared) return inherited;
-  if (!REASONING_EFFORTS.includes(declared)) {
-    log.warn("agent effort override refused: unknown level", {
-      agent,
-      wanted: declared,
-      keeping: inherited
+async function fetchSessionDirectory(sessionID) {
+  if (!sessionID || sessionID === "default") return void 0;
+  const client = opencodeClient;
+  if (!client?.session?.get) return void 0;
+  try {
+    const res = await client.session.get({ path: { id: sessionID } });
+    const data = res.data;
+    if (!data || typeof data !== "object") return void 0;
+    const dir = data.directory;
+    return isUsableDirectory(dir) ? dir : void 0;
+  } catch (err) {
+    log.warn("failed to fetch opencode session directory", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
     });
-    return inherited;
+    return void 0;
   }
-  if (declared !== inherited) {
-    log.debug("agent effort override", {
-      agent,
-      from: inherited,
-      to: declared
+}
+async function getRuntimeMcpStatus() {
+  const client = opencodeClient;
+  if (!client?.mcp?.status) return void 0;
+  try {
+    const res = await client.mcp.status();
+    const data = res.data;
+    if (!data || typeof data !== "object") return void 0;
+    const out = {};
+    for (const [name, entry] of Object.entries(data)) {
+      if (entry && typeof entry === "object") {
+        const status = entry.status;
+        if (typeof status === "string") out[name] = status;
+      }
+    }
+    return out;
+  } catch (err) {
+    log.warn("failed to fetch opencode MCP runtime status", {
+      error: err instanceof Error ? err.message : String(err)
     });
+    return void 0;
   }
-  return declared;
 }
-function parseAgentFrontmatter(text) {
-  const record = {};
-  if (!text.startsWith("---")) return record;
-  const lines = text.split(/\r?\n/);
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim() === "---") break;
-    const match = /^([A-Za-z_][A-Za-z0-9_-]*):[ \t]*(.*)$/.exec(line);
-    if (!match) continue;
-    const key = match[1];
-    if (key !== "mode" && key !== "model" && key !== "forceModel" && key !== "reasoningEffort")
-      continue;
-    const value = match[2].trim().replace(/^["']|["']$/g, "");
-    if (value) record[key] = value;
+async function fetchOpencodeToolList(provider, model, directory) {
+  const client = opencodeClient;
+  if (!client?.tool?.list) return void 0;
+  try {
+    const res = await client.tool.list({
+      query: { provider, model, ...directory ? { directory } : {} }
+    });
+    const data = res.data;
+    if (!Array.isArray(data)) return void 0;
+    const out = [];
+    for (const entry of data) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const id = typeof e.id === "string" ? e.id : null;
+      const description = typeof e.description === "string" ? e.description : "";
+      const parameters = e.parameters && typeof e.parameters === "object" ? e.parameters : {};
+      if (!id) continue;
+      out.push({ id, description, parameters });
+    }
+    return out;
+  } catch (err) {
+    log.warn("failed to fetch opencode tool list", {
+      provider,
+      model,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
   }
-  return record;
 }
-async function readAgentMarkdownRecords(directories) {
-  const records = {};
-  for (const directory of directories) {
-    let entries;
-    try {
-      entries = await readdir(directory);
-    } catch {
-      continue;
+
+// src/startup-diagnostics.ts
+var cachedPluginVersion;
+function pluginVersion() {
+  if (cachedPluginVersion) return cachedPluginVersion;
+  try {
+    const here = path4.dirname(fileURLToPath(import.meta.url));
+    const raw = fs4.readFileSync(path4.join(here, "..", "package.json"), "utf8");
+    const version = JSON.parse(raw).version;
+    cachedPluginVersion = typeof version === "string" ? version : "unknown";
+  } catch {
+    cachedPluginVersion = "unknown";
+  }
+  return cachedPluginVersion;
+}
+function pickOpencodeVersion(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const app = input.app;
+  if (app && typeof app === "object") {
+    const version = app.version;
+    if (typeof version === "string" && version.length > 0) return version;
+  }
+  const direct = input.version;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  return void 0;
+}
+var execFileAsync2 = promisify2(execFile2);
+var opencodeVersionProbe;
+function detectOpencodeVersion(execPath = process.execPath) {
+  if (opencodeVersionProbe) return opencodeVersionProbe;
+  opencodeVersionProbe = (async () => {
+    if (!path4.basename(execPath).toLowerCase().includes("opencode")) {
+      log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
+      return void 0;
     }
-    for (const entry of entries) {
-      if (!entry.endsWith(".md")) continue;
-      const name = entry.slice(0, -3);
-      if (records[name]) continue;
-      try {
-        const text = await readFile(path3.join(directory, entry), "utf8");
-        records[name] = parseAgentFrontmatter(text);
-      } catch (err) {
-        log.debug("failed to read agent markdown", {
-          file: path3.join(directory, entry),
-          error: String(err)
-        });
-      }
+    try {
+      const { stdout } = await execFileAsync2(execPath, ["--version"], { timeout: 5e3 });
+      const match = /\d+\.\d+\.\d+\S*/.exec(stdout.trim());
+      return match ? match[0] : void 0;
+    } catch (err) {
+      log.debug("opencode version probe failed", {
+        execPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return void 0;
     }
+  })();
+  return opencodeVersionProbe;
+}
+function describeSpawnCwd(configured, live = process.cwd(), captured = getOpencodeProjectDirectory()) {
+  if (typeof configured === "string" && configured.length > 0) {
+    return { resolved: configured, source: "configured" };
   }
-  return records;
+  if (isUsableDirectory(live)) return { resolved: live, source: "process" };
+  if (isUsableDirectory(captured)) return { resolved: captured, source: "captured" };
+  return { resolved: live, source: "unresolved" };
 }
-function agentDirectories(home, projectDirectory) {
-  const directories = [];
-  if (projectDirectory) {
-    for (const name of AGENT_DIR_NAMES) {
-      directories.push(path3.join(projectDirectory, ".opencode", name));
-    }
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function firstOption(providers, key) {
+  for (const entry of Object.values(providers)) {
+    const value = entry?.options?.[key];
+    if (value !== void 0) return value;
   }
-  if (home) {
-    for (const name of AGENT_DIR_NAMES) {
-      directories.push(path3.join(home, ".config", "opencode", name));
-    }
+  return void 0;
+}
+function collectStartupDiagnostics(providers, opencodeVersion) {
+  const accounts = [];
+  for (const entry of Object.values(providers)) {
+    const account = entry?.options?.account;
+    if (typeof account === "string" && account.length > 0) accounts.push(account);
   }
-  return directories;
+  const cwd = describeSpawnCwd(firstOption(providers, "cwd"));
+  let mcpServers = [];
+  try {
+    mcpServers = mergeOpencodeMcp(cwd.resolved).enabledServerNames;
+  } catch (err) {
+    log.debug("startup diagnostics could not read MCP config", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+  return {
+    plugin: pluginVersion(),
+    opencode: opencodeVersion ?? process.env.OPENCODE_VERSION ?? "unknown",
+    claudeCliPath: String(firstOption(providers, "cliPath") ?? "claude"),
+    cwd,
+    providers: Object.keys(providers),
+    accounts,
+    proxyTools: stringList(firstOption(providers, "proxyTools")),
+    mcpServers,
+    interactiveTransport: firstOption(providers, "interactive") === true || process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT === "1",
+    planModeQuestion: firstOption(providers, "planModeQuestion") === true,
+    anthropicApiKeyInEnv: Boolean(
+      process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
+    )
+  };
+}
+var logged = false;
+var lastProviders = {};
+var lastOpencodeVersion;
+function lastDiagnosticsProviders() {
+  return lastProviders;
+}
+function lastKnownOpencodeVersion() {
+  return lastOpencodeVersion;
+}
+function logStartupDiagnostics(providers, opencodeVersion) {
+  lastProviders = providers;
+  if (opencodeVersion) lastOpencodeVersion = opencodeVersion;
+  if (logged) return;
+  logged = true;
+  void (async () => {
+    try {
+      const version = opencodeVersion ?? process.env.OPENCODE_VERSION ?? await detectOpencodeVersion();
+      const { claudeCliPath, ...rest } = collectStartupDiagnostics(providers, version);
+      const cli = await detectCliVersion(claudeCliPath);
+      const diagnostics = {
+        ...rest,
+        claudeCli: { path: claudeCliPath, version: cli?.raw ?? "not detected" }
+      };
+      log.notice("claude-code plugin ready", { ...diagnostics });
+    } catch (err) {
+      log.debug("startup diagnostics failed", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  })();
 }
 
-// src/skill-bridge.ts
-import * as crypto2 from "crypto";
-import * as fs3 from "fs";
-import * as os2 from "os";
-import * as path4 from "path";
-import { fileURLToPath } from "url";
-var SKILL_PLUGIN_NAME = "opencode-skills";
-function bundledSkillsDir() {
-  try {
-    const here = fileURLToPath(import.meta.url);
-    const dir = path4.resolve(path4.dirname(here), "..", "skills");
-    return dirExists(dir) ? dir : null;
-  } catch {
+// src/doctor.ts
+var DOCTOR_COMMAND = "claude-code-doctor";
+var DOCTOR_MARKER = "\u258C **claude-code doctor**";
+function isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+var SYSTEM_REMINDER_BLOCK2 = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+function parseDoctorCommandContent(content) {
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (!isRecord3(part) || part.type !== "text" || typeof part.text !== "string") return null;
+      parts.push(part.text);
+    }
+    text = parts.join("\n");
+  } else {
     return null;
   }
+  const match = new RegExp(`^/${DOCTOR_COMMAND}(?:\\s+([\\s\\S]*))?$`).exec(
+    text.replace(SYSTEM_REMINDER_BLOCK2, "").trim()
+  );
+  return match ? { rest: (match[1] ?? "").trim() } : null;
 }
-function dirExists(p) {
-  try {
-    return fs3.statSync(p).isDirectory();
-  } catch {
-    return false;
+function parseDoctorCommand(prompt) {
+  const latest = prompt.at(-1);
+  return latest?.role === "user" ? parseDoctorCommandContent(latest.content) : null;
+}
+function formatAge(ms) {
+  if (ms === void 0) return "unknown";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 60) return `${minutes}m`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function list(values) {
+  return values.length ? values.join(", ") : "none";
+}
+function describeAuth(auth) {
+  switch (auth.status) {
+    case "ok":
+      return `${auth.code}, good`;
+    case "unsafe":
+      return `${auth.code}, UNSAFE: an unauthenticated caller was accepted. Restart every opencode window; a window opened before 0.13.2 keeps serving an open port.`;
+    case "unreachable":
+      return `could not be checked (${auth.error})`;
+    case "skipped":
+      return "not checked";
+  }
+}
+function formatDoctorReport(report) {
+  const lines = [];
+  lines.push(DOCTOR_MARKER);
+  lines.push("");
+  lines.push("| Field | Value |");
+  lines.push("|---|---|");
+  lines.push(`| plugin | ${report.plugin} |`);
+  lines.push(`| opencode | ${report.opencode} |`);
+  lines.push(`| claude CLI | \`${report.claudeCli.path}\` (${report.claudeCli.version}) |`);
+  lines.push(`| cwd | \`${report.cwd.resolved}\` (${report.cwd.source}) |`);
+  lines.push(`| providers | ${list(report.providers)} |`);
+  lines.push(`| accounts | ${list(report.accounts)} |`);
+  lines.push(`| proxyTools | ${list(report.proxyTools)} |`);
+  lines.push(`| MCP servers (on disk) | ${list(report.mcpServers)} |`);
+  lines.push(`| transport | ${report.transport} |`);
+  lines.push(`| planModeQuestion | ${report.planModeQuestion} |`);
+  lines.push(`| turnStats | ${report.turnStats} |`);
+  lines.push(`| ANTHROPIC_API_KEY in env | ${report.anthropicApiKeyInEnv ? "yes" : "no"} |`);
+  lines.push("");
+  lines.push("**Live `claude` processes**");
+  lines.push("");
+  if (report.processes.length === 0) {
+    lines.push("None. The next message in a Claude Code session spawns one.");
+  } else {
+    lines.push("| session | model | pid | in flight | age | effort |");
+    lines.push("|---|---|---|---|---|---|");
+    for (const proc of report.processes) {
+      lines.push(
+        `| ${proc.session}${proc.compaction ? " (compaction)" : ""} | ${proc.model} | ${proc.pid ?? "unknown"} | ${proc.inFlight ? "yes" : "no"} | ${formatAge(proc.ageMs)} | ${proc.effort ?? "inherited"} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("**Pending proxy calls**");
+  lines.push("");
+  if (report.pendingCalls.length === 0) {
+    lines.push("None.");
+  } else {
+    lines.push("| tool | call id | age | deadline |");
+    lines.push("|---|---|---|---|");
+    for (const call of report.pendingCalls) {
+      lines.push(
+        `| ${call.toolName} | \`${call.toolCallId}\` | ${formatAge(call.ageMs)} | ${formatAge(
+          call.deadlineMs
+        )} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("**Proxy servers**");
+  lines.push("");
+  if (report.proxyServers.length === 0) {
+    lines.push("None running.");
+  } else {
+    lines.push("| url | unauthenticated `initialize` |");
+    lines.push("|---|---|");
+    for (const server2 of report.proxyServers) {
+      lines.push(`| ${server2.url} | ${describeAuth(server2.auth)} |`);
+    }
+  }
+  const stderr = report.processes.filter((proc) => proc.lastStderr);
+  if (stderr.length > 0) {
+    lines.push("");
+    lines.push("**Last stderr**");
+    lines.push("");
+    for (const proc of stderr) {
+      lines.push(`\`${proc.session}\`:`);
+      lines.push("");
+      lines.push("```text");
+      lines.push(proc.lastStderr.trimEnd());
+      lines.push("```");
+    }
   }
+  return lines.join("\n");
 }
-function fileExists(p) {
+async function checkProxyAuth(url, fetchImpl = fetch, timeoutMs = 3e3) {
+  let authority;
   try {
-    return fs3.statSync(p).isFile();
+    authority = new URL(url).host;
   } catch {
-    return false;
+    return { status: "skipped" };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", host: authority },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 0, method: "initialize", params: {} }),
+      signal: controller.signal
+    });
+    await response.text().catch(() => "");
+    return response.status === 401 ? { status: "ok", code: response.status } : { status: "unsafe", code: response.status };
+  } catch (error) {
+    return {
+      status: "unreachable",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    clearTimeout(timer);
   }
 }
-function skillRoots(cwd) {
-  const roots = [];
+async function gatherDoctorReport(options) {
+  const providers = lastDiagnosticsProviders();
+  const opencodeVersion = lastKnownOpencodeVersion() ?? process.env.OPENCODE_VERSION ?? await detectOpencodeVersion().catch(() => void 0);
+  const { claudeCliPath, ...base } = collectStartupDiagnostics(providers, opencodeVersion);
+  const cliPath = options.cliPath || claudeCliPath;
+  const cli = await detectCliVersion(cliPath).catch(() => null);
+  const processes = snapshotActiveProcesses();
   const seen = /* @__PURE__ */ new Set();
-  const push = (p) => {
-    const abs = path4.resolve(p);
-    if (seen.has(abs)) return;
-    seen.add(abs);
-    if (dirExists(abs)) roots.push(abs);
-  };
-  let current = path4.resolve(cwd);
-  while (true) {
-    push(path4.join(current, ".opencode", "skills"));
-    const parent = path4.dirname(current);
-    if (parent === current) break;
-    current = parent;
+  const proxyServers = [];
+  for (const proc of processes) {
+    if (!proc.proxyUrl || seen.has(proc.proxyUrl)) continue;
+    seen.add(proc.proxyUrl);
+    proxyServers.push({
+      url: proc.proxyUrl,
+      auth: await checkProxyAuth(proc.proxyUrl, options.fetchImpl ?? fetch)
+    });
   }
-  const home = os2.homedir();
-  if (home) push(path4.join(home, ".opencode", "skills"));
-  const envDir = process.env.OPENCODE_CONFIG_DIR;
-  if (envDir) push(path4.join(envDir, "skills"));
-  const xdg = process.env.XDG_CONFIG_HOME ?? (home ? path4.join(home, ".config") : null);
-  if (xdg) push(path4.join(xdg, "opencode", "skills"));
-  return roots;
+  return {
+    plugin: base.plugin,
+    opencode: base.opencode,
+    claudeCli: { path: cliPath, version: cli?.raw ?? "not detected" },
+    cwd: base.cwd,
+    providers: base.providers,
+    accounts: base.accounts,
+    proxyTools: base.proxyTools,
+    mcpServers: base.mcpServers,
+    transport: options.interactive || base.interactiveTransport ? "interactive" : "headless",
+    planModeQuestion: base.planModeQuestion,
+    turnStats: options.turnStats,
+    anthropicApiKeyInEnv: base.anthropicApiKeyInEnv,
+    processes,
+    pendingCalls: snapshotPendingProxyCalls(),
+    proxyServers
+  };
 }
-function collectSkills(root, claimed, found) {
-  let entries;
+async function buildDoctorReport(options) {
   try {
-    entries = fs3.readdirSync(root, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const name = entry.name;
-    if (name.startsWith(".")) continue;
-    if (claimed.has(name)) continue;
-    const dir = path4.join(root, name);
-    if (!fileExists(path4.join(dir, "SKILL.md"))) continue;
-    claimed.add(name);
-    found.push({ name, dir });
+    const report = await gatherDoctorReport(options);
+    log.info("claude-code doctor report", {
+      plugin: report.plugin,
+      opencode: report.opencode,
+      cwd: report.cwd,
+      processes: report.processes.length,
+      pendingCalls: report.pendingCalls.length,
+      proxyServers: report.proxyServers.map((server2) => server2.auth.status)
+    });
+    return formatDoctorReport(report);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.warn("claude-code doctor failed to build its report", { error: message });
+    return `${DOCTOR_MARKER}
+
+Could not build the report: ${message}`;
   }
 }
-var byName = (a, b) => a.name.localeCompare(b.name);
-function discoverOpencodeSkills(cwd) {
-  const found = [];
-  const claimed = /* @__PURE__ */ new Set();
-  for (const root of skillRoots(cwd)) collectSkills(root, claimed, found);
-  return found.sort(byName);
+
+// src/turn-stats.ts
+var TURN_STATS_MARKER = "\u258C **stats:**";
+function extractTurnStats(msg) {
+  const usage = msg.usage;
+  const stats = {};
+  if (typeof msg.total_cost_usd === "number") stats.costUsd = msg.total_cost_usd;
+  if (typeof msg.duration_ms === "number") stats.durationMs = msg.duration_ms;
+  if (typeof msg.duration_api_ms === "number") stats.durationApiMs = msg.duration_api_ms;
+  if (typeof msg.num_turns === "number") stats.numTurns = msg.num_turns;
+  if (typeof usage?.input_tokens === "number") stats.inputTokens = usage.input_tokens;
+  if (typeof usage?.output_tokens === "number") stats.outputTokens = usage.output_tokens;
+  if (typeof usage?.cache_read_input_tokens === "number") {
+    stats.cacheReadTokens = usage.cache_read_input_tokens;
+  }
+  if (typeof usage?.cache_creation_input_tokens === "number") {
+    stats.cacheWriteTokens = usage.cache_creation_input_tokens;
+  }
+  if (msg.modelUsage && typeof msg.modelUsage === "object") stats.modelUsage = msg.modelUsage;
+  if (Array.isArray(msg.permission_denials)) stats.permissionDenials = msg.permission_denials;
+  return stats;
+}
+function formatCost(costUsd) {
+  if (!Number.isFinite(costUsd) || costUsd < 0) return "$0.00";
+  return costUsd >= 1 ? `$${costUsd.toFixed(2)}` : `$${costUsd.toFixed(4)}`;
+}
+function formatDuration(durationMs) {
+  if (!Number.isFinite(durationMs) || durationMs < 0) return "0.0 s";
+  if (durationMs < 6e4) return `${(durationMs / 1e3).toFixed(1)} s`;
+  const totalSeconds = Math.round(durationMs / 1e3);
+  return `${Math.floor(totalSeconds / 60)}m ${totalSeconds % 60}s`;
+}
+function formatTokens(tokens) {
+  if (!Number.isFinite(tokens) || tokens < 0) return "0";
+  if (tokens < 1e3) return String(Math.round(tokens));
+  if (tokens < 1e6) return `${(tokens / 1e3).toFixed(1)}k`;
+  return `${(tokens / 1e6).toFixed(1)}M`;
+}
+function formatTurnStatsLine(stats) {
+  const parts = [];
+  if (stats.costUsd !== void 0) parts.push(formatCost(stats.costUsd));
+  if (stats.durationMs !== void 0) parts.push(formatDuration(stats.durationMs));
+  if (stats.numTurns !== void 0) {
+    parts.push(`${stats.numTurns} CLI ${stats.numTurns === 1 ? "turn" : "turns"}`);
+  }
+  if (stats.inputTokens !== void 0) parts.push(`in ${formatTokens(stats.inputTokens)}`);
+  if (stats.outputTokens !== void 0) parts.push(`out ${formatTokens(stats.outputTokens)}`);
+  if (stats.cacheReadTokens) parts.push(`cache read ${formatTokens(stats.cacheReadTokens)}`);
+  if (stats.cacheWriteTokens) parts.push(`cache write ${formatTokens(stats.cacheWriteTokens)}`);
+  if (stats.permissionDenials?.length) {
+    const count = stats.permissionDenials.length;
+    parts.push(`${count} permission ${count === 1 ? "denial" : "denials"}`);
+  }
+  if (parts.length === 0) return null;
+  return `${TURN_STATS_MARKER} ${parts.join(" \xB7 ")}`;
+}
+function formatTurnStatsBlock(stats) {
+  const line = formatTurnStatsLine(stats);
+  return line === null ? null : `
+${line}
+`;
 }
-function discoverBundledSkills() {
-  const root = bundledSkillsDir();
-  if (!root) return [];
-  const found = [];
-  collectSkills(root, /* @__PURE__ */ new Set(), found);
-  return found.sort(byName);
+function turnStatsLogPayload(stats) {
+  return {
+    costUsd: stats.costUsd ?? null,
+    durationMs: stats.durationMs ?? null,
+    durationApiMs: stats.durationApiMs ?? null,
+    numTurns: stats.numTurns ?? null,
+    inputTokens: stats.inputTokens ?? null,
+    outputTokens: stats.outputTokens ?? null,
+    cacheReadTokens: stats.cacheReadTokens ?? null,
+    cacheWriteTokens: stats.cacheWriteTokens ?? null,
+    modelUsage: stats.modelUsage ?? null,
+    permissionDenials: stats.permissionDenials?.length ?? 0
+  };
 }
-function registerBundledSkillPath(config) {
-  const dir = bundledSkillsDir();
-  if (!dir) return false;
-  config.skills ??= {};
-  const paths = config.skills.paths ??= [];
-  if (paths.some((p) => path4.resolve(p) === dir)) return false;
-  paths.push(dir);
-  return true;
+
+// src/message-builder.ts
+var PLUGIN_NOTE_MARKERS = [
+  INLINE_ASIDE_MARKER,
+  ...LEGACY_INLINE_ASIDE_MARKERS,
+  TURN_STATS_MARKER,
+  COMPACT_BOUNDARY_MARKER,
+  RATE_LIMIT_MARKER,
+  RESULT_ERROR_MARKER,
+  DOCTOR_MARKER
+];
+function isPluginNote(part) {
+  if (!part || part.type !== "text" || typeof part.text !== "string") return false;
+  const text = part.text.trimStart();
+  return PLUGIN_NOTE_MARKERS.some((marker) => text.startsWith(marker));
 }
-function linkSkill(source, target) {
-  try {
-    fs3.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
-    return;
-  } catch {
-    fs3.cpSync(source, target, { recursive: true, dereference: true });
-  }
+function stripPluginNotes(content) {
+  if (!Array.isArray(content)) return content;
+  const kept = content.filter((part) => !isPluginNote(part));
+  return kept.length === content.length ? content : kept;
 }
-function buildSkillPluginDir(skills) {
-  if (skills.length === 0) return null;
-  const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
-  const hash = crypto2.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
-  const root = path4.join(pluginTmpDir(), `skills-${hash}`);
-  const manifest = path4.join(root, ".claude-plugin", "plugin.json");
-  if (fileExists(manifest)) return root;
-  try {
-    fs3.rmSync(root, { recursive: true, force: true });
-    fs3.mkdirSync(path4.join(root, ".claude-plugin"), { recursive: true });
-    fs3.mkdirSync(path4.join(root, "skills"), { recursive: true });
-    fs3.writeFileSync(
-      manifest,
-      JSON.stringify(
-        {
-          name: SKILL_PLUGIN_NAME,
-          description: "Skills discovered from this opencode installation, bridged into Claude Code."
-        },
-        null,
-        2
-      ),
-      { encoding: "utf8", mode: 384 }
-    );
-    for (const skill of skills) {
-      linkSkill(skill.dir, path4.join(root, "skills", skill.name));
+function filterSideQuestionHistory(prompt) {
+  let pluginCommand = false;
+  const kept = prompt.filter((message) => {
+    if (message.role === "user") {
+      pluginCommand = parseSideQuestionContent(message.content) !== null || parseDoctorCommandContent(message.content) !== null;
+      return !pluginCommand;
     }
-  } catch (err) {
-    log.warn("failed to stage opencode skill plugin dir", {
-      root,
-      error: err instanceof Error ? err.message : String(err)
+    return message.role !== "assistant" || !pluginCommand;
+  });
+  return kept.map(
+    (message) => message.role === "assistant" ? { ...message, content: stripPluginNotes(message.content) } : message
+  );
+}
+var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+function toImageBlock(part) {
+  const raw = part.image ?? part.data ?? part.url ?? part.source?.data;
+  if (!raw) {
+    log.warn("file part without data, skipping");
+    return null;
+  }
+  let resolvedMediaType = part.mediaType || part.mimeType || part.mime || "";
+  let base64 = null;
+  if (typeof raw === "string") {
+    if (raw.startsWith("data:")) {
+      const match = /^data:([^;,]+)(?:;[^,]*)*(?:;base64)?,(.*)$/s.exec(raw);
+      if (!match) {
+        log.warn("malformed data URI, skipping file part");
+        return null;
+      }
+      resolvedMediaType = resolvedMediaType || match[1];
+      base64 = match[2];
+    } else if (/^https?:\/\//i.test(raw)) {
+      log.warn("remote URL images are not supported by Claude CLI, skipping");
+      return null;
+    } else {
+      base64 = raw;
+    }
+  } else if (raw instanceof URL) {
+    log.warn("remote URL images are not supported by Claude CLI, skipping");
+    return null;
+  } else if (raw instanceof Uint8Array || Buffer.isBuffer(raw)) {
+    base64 = Buffer.from(raw).toString("base64");
+  } else {
+    log.warn("unsupported file part data type", { dataType: typeof raw });
+    return null;
+  }
+  if (!resolvedMediaType || !SUPPORTED_IMAGE_TYPES.has(resolvedMediaType)) {
+    log.warn("unsupported media type for Claude image block, skipping", {
+      mediaType: resolvedMediaType
     });
     return null;
   }
-  return root;
+  return {
+    type: "image",
+    source: { type: "base64", media_type: resolvedMediaType, data: base64 }
+  };
 }
-async function resolveSkillPluginDirs(opts) {
-  const user = opts.enabled ? discoverOpencodeSkills(opts.cwd) : [];
-  const claimed = new Set(user.map((s) => s.name));
-  const bundled = discoverBundledSkills().filter((s) => !claimed.has(s.name));
-  const skills = [...user, ...bundled].sort(byName);
-  if (skills.length === 0) return [];
-  const supported = await detectCliSupportsFlag(opts.cliPath, "--plugin-dir");
-  if (!supported) {
-    log.notice(
-      "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
-      { skills: skills.length }
-    );
-    return [];
+function getToolResultText(part) {
+  const value = part.output ?? part.result;
+  if (typeof value === "string") {
+    return value;
   }
-  const dir = buildSkillPluginDir(skills);
-  if (!dir) return [];
-  log.info("bridged opencode skills into claude", {
-    count: skills.length,
-    names: skills.map((s) => s.name),
-    bundled: bundled.map((s) => s.name),
-    pluginDir: dir
-  });
-  return [dir];
-}
-
-// src/mcp-bridge.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
-import * as os3 from "os";
-import * as crypto3 from "crypto";
-import {
-  parse as parseJsonc,
-  printParseErrorCode
-} from "jsonc-parser";
-var FILE_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
-var PROJECT_FILE_NAMES = ["opencode.json", "opencode.jsonc"];
-function fileExists2(p) {
-  try {
-    return fs4.statSync(p).isFile();
-  } catch {
-    return false;
+  if (!value || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  switch (value.type) {
+    case "text":
+    case "error-text":
+      return String(value.value);
+    case "json":
+    case "error-json":
+      return JSON.stringify(value.value);
+    case "execution-denied":
+      return value.reason ? `Execution denied: ${value.reason}` : "Execution denied";
+    case "content":
+      return Array.isArray(value.value) ? value.value.map((item) => {
+        if (item?.type === "text") return item.text;
+        return JSON.stringify(item);
+      }).join("\n") : JSON.stringify(value.value);
+    default:
+      return JSON.stringify(value);
   }
 }
-function dirExists2(p) {
+var MAX_HISTORY_CHARS = 18e4;
+var MAX_TOOL_RESULT_CHARS = 1e4;
+var MAX_TOOL_INPUT_CHARS = 2e3;
+function clipWithMarker(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}
+\u2026[truncated ${text.length - max} chars]`;
+}
+function renderToolInput(input) {
+  let raw;
   try {
-    return fs4.statSync(p).isDirectory();
+    raw = typeof input === "string" ? input : JSON.stringify(input);
   } catch {
-    return false;
+    raw = String(input);
   }
+  return clipWithMarker(raw, MAX_TOOL_INPUT_CHARS);
 }
-function readAndParse(file) {
-  try {
-    const raw = fs4.readFileSync(file, "utf8");
-    const errors = [];
-    const parsed = parseJsonc(raw, errors, { allowTrailingComma: true });
-    if (errors.length > 0) {
-      const first = errors[0];
-      throw new Error(
-        `${printParseErrorCode(first.error)} at offset ${first.offset}`
-      );
+function renderMessageContentForCompaction(msg) {
+  const lines = [];
+  let toolResultCount = 0;
+  if (typeof msg.content === "string") {
+    return { text: msg.content, toolResultCount: 0 };
+  }
+  if (!Array.isArray(msg.content)) {
+    return { text: "", toolResultCount: 0 };
+  }
+  for (const part of msg.content) {
+    if (!part) continue;
+    switch (part.type) {
+      case "text":
+        if (part.text) lines.push(part.text);
+        break;
+      case "tool-call":
+        lines.push(
+          `[tool_use:${part.toolName ?? "unknown"}(${renderToolInput(part.input)})]`
+        );
+        break;
+      case "tool-result":
+        toolResultCount++;
+        lines.push(
+          `[tool_result:${part.toolName ?? part.toolCallId ?? "unknown"}]
+${clipWithMarker(
+            getToolResultText(part),
+            MAX_TOOL_RESULT_CHARS
+          )}`
+        );
+        break;
+      case "image":
+        lines.push(
+          `[image: ${part.mediaType ?? part.mimeType ?? "unknown"}]`
+        );
+        break;
+      case "file":
+        lines.push(
+          `[file: ${part.mediaType ?? part.mimeType ?? "unknown"}]`
+        );
+        break;
+      case "reasoning":
+        break;
     }
-    return parsed;
-  } catch (e) {
-    log.warn("failed to parse opencode config", {
-      file,
-      error: e instanceof Error ? e.message : String(e)
-    });
-    return null;
   }
+  return { text: lines.join("\n"), toolResultCount };
 }
-function isPlainObject(x) {
-  return typeof x === "object" && x !== null && !Array.isArray(x);
+function compactConversationHistory(prompt, opts = {}) {
+  const mode = opts.mode ?? "fresh-session";
+  prompt = filterSideQuestionHistory(prompt);
+  if (mode === "compaction") {
+    return buildCompactionHistory(prompt);
+  }
+  const conversationMessages = prompt.filter(
+    (m) => m.role === "user" || m.role === "assistant" || m.role === "tool"
+  );
+  if (conversationMessages.length <= 1) {
+    return null;
+  }
+  const historyParts = [];
+  for (let i = 0; i < conversationMessages.length - 1; i++) {
+    const msg = conversationMessages[i];
+    const role = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "Tool";
+    const { text } = renderMessageContentForCompaction(msg);
+    if (text.trim()) {
+      const truncated = text.length > 2e3 ? text.slice(0, 2e3) + "..." : text;
+      historyParts.push(`${role}: ${truncated}`);
+    }
+  }
+  if (historyParts.length === 0) {
+    return null;
+  }
+  return historyParts.join("\n\n");
+}
+function buildCompactionHistory(prompt) {
+  const entries = [];
+  let total = 0;
+  let totalToolResults = 0;
+  let droppedOldest = 0;
+  const end = prompt.length > 0 && prompt[prompt.length - 1].role === "user" ? prompt.length - 1 : prompt.length;
+  for (let i = end - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    const roleLabel = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : msg.role === "tool" ? "Tool" : msg.role;
+    const { text, toolResultCount } = renderMessageContentForCompaction(msg);
+    if (!text.trim()) continue;
+    const entry = `${roleLabel}: ${text}`;
+    if (total + entry.length > MAX_HISTORY_CHARS) {
+      droppedOldest = i + 1;
+      break;
+    }
+    entries.push(entry);
+    total += entry.length + 2;
+    totalToolResults += toolResultCount;
+  }
+  if (entries.length === 0) return null;
+  entries.reverse();
+  log.info("built compaction history", {
+    entries: entries.length,
+    chars: total,
+    toolResults: totalToolResults,
+    droppedOldestBefore: droppedOldest
+  });
+  return entries.join("\n\n");
+}
+function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {}) {
+  const compactionMode = opts.compactionMode === true;
+  const cliToolCallIds = opts.cliToolCallIds;
+  const content = [];
+  const pushToolResult = (part) => {
+    const id = part.toolCallId;
+    const text = getToolResultText(part);
+    if (!cliToolCallIds || cliToolCallIds.has(id)) {
+      content.push({ type: "tool_result", tool_use_id: id, content: text });
+      return;
+    }
+    log.info("rendering opencode-side tool result as text", {
+      toolCallId: id,
+      toolName: part.toolName,
+      chars: text.length
+    });
+    content.push({
+      type: "text",
+      text: `<opencode_tool_result tool="${part.toolName ?? "unknown"}">
+${text}
+</opencode_tool_result>`
+    });
+  };
+  if (compactionMode) {
+    const transcript = compactConversationHistory(prompt, {
+      mode: "compaction"
+    });
+    if (transcript) {
+      log.info("including compaction transcript", {
+        historyLength: transcript.length
+      });
+      content.push({
+        type: "text",
+        text: `<conversation_transcript>
+${transcript}
+</conversation_transcript>
+
+The complete prior conversation appears above. The synthesis instructions follow below.
+
+`
+      });
+    }
+  } else if (includeHistoryContext) {
+    const historyContext = compactConversationHistory(prompt);
+    if (historyContext) {
+      log.info("including conversation history context", {
+        historyLength: historyContext.length
+      });
+      content.push({
+        type: "text",
+        text: `<conversation_history>
+The following is a summary of our conversation so far (from a previous session that couldn't be resumed):
+
+${historyContext}
+
+</conversation_history>
+
+Now continuing with the current message:
+
+`
+      });
+    }
+  }
+  const messages = [];
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    if (prompt[i].role === "assistant") break;
+    messages.unshift(prompt[i]);
+  }
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (parseSideQuestionContent(msg.content) !== null) continue;
+      if (typeof msg.content === "string") {
+        const str2 = msg.content;
+        if (str2.trim()) {
+          content.push({ type: "text", text: str2 });
+        }
+      } else if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            if (part.text && part.text.trim()) {
+              content.push({ type: "text", text: part.text });
+            }
+          } else if (part.type === "file" || part.type === "image") {
+            const block = toImageBlock(part);
+            if (block) {
+              content.push(block);
+            } else {
+              log.debug("skipped non-image file part", {
+                mediaType: part.mediaType
+              });
+            }
+          } else if (part.type === "tool-result") {
+            pushToolResult(part);
+          }
+        }
+      }
+    } else if (msg.role === "tool") {
+      if (Array.isArray(msg.content)) {
+        for (const part of msg.content) {
+          if (part?.type === "tool-result") {
+            pushToolResult(part);
+          }
+        }
+      }
+    }
+  }
+  if (content.length === 0) {
+    log.warn("empty user content; sending sentinel to satisfy CLI");
+    return JSON.stringify({
+      type: "user",
+      message: {
+        role: "user",
+        content: [{ type: "text", text: "(empty)" }]
+      }
+    });
+  }
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content
+    }
+  });
+}
+
+// src/agent-models.ts
+import { readFile, readdir } from "fs/promises";
+import path5 from "path";
+
+// src/models.ts
+var PROVIDER_ID = "claude-code";
+var NPM = "@khalilgharbaoui/opencode-claude-code-plugin";
+var reasoningVariants = {
+  low: { reasoningEffort: "low" },
+  medium: { reasoningEffort: "medium" },
+  high: { reasoningEffort: "high" },
+  xhigh: { reasoningEffort: "xhigh" },
+  max: { reasoningEffort: "max" }
+};
+var baseCapabilities = {
+  temperature: false,
+  attachment: true,
+  toolcall: true,
+  input: { text: true, audio: false, image: true, video: false, pdf: false },
+  output: { text: true, audio: false, image: false, video: false, pdf: false },
+  interleaved: false
+};
+function defineModel(opts) {
+  return {
+    id: opts.id,
+    providerID: PROVIDER_ID,
+    api: { id: opts.id, url: "", npm: NPM },
+    name: `${opts.name} (${opts.multiplier}\xD7)`,
+    family: opts.family,
+    capabilities: { ...baseCapabilities, reasoning: opts.reasoning },
+    cost: {
+      input: opts.cost.input,
+      output: opts.cost.output,
+      cache: { read: opts.cost.cacheRead, write: opts.cost.cacheWrite }
+    },
+    limit: { context: opts.context, output: opts.output },
+    status: opts.status ?? "active",
+    options: {},
+    headers: {},
+    release_date: opts.releaseDate,
+    variants: opts.reasoning ? reasoningVariants : void 0
+  };
+}
+var haikuCost = { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 };
+var sonnetCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+var opusCost = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
+var fableCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
+var fable51Cost = { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 };
+var opusFastCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
+function toConfigModel(model) {
+  const inputMods = [];
+  const outputMods = [];
+  for (const [k, v] of Object.entries(model.capabilities.input)) {
+    if (v) inputMods.push(k);
+  }
+  for (const [k, v] of Object.entries(model.capabilities.output)) {
+    if (v) outputMods.push(k);
+  }
+  return {
+    id: model.api.id,
+    name: model.name,
+    status: model.status,
+    family: model.family ?? "",
+    release_date: model.release_date,
+    temperature: model.capabilities.temperature,
+    reasoning: model.capabilities.reasoning,
+    attachment: model.capabilities.attachment,
+    tool_call: model.capabilities.toolcall,
+    modalities: { input: inputMods, output: outputMods },
+    cost: {
+      input: model.cost.input,
+      output: model.cost.output,
+      cache_read: model.cost.cache.read,
+      cache_write: model.cost.cache.write
+    },
+    limit: model.limit,
+    options: model.options,
+    headers: model.headers,
+    variants: model.variants
+  };
+}
+var defaultModels = {
+  "claude-haiku-4-5": defineModel({
+    id: "claude-haiku-4-5",
+    name: "Claude Haiku 4.5",
+    family: "haiku",
+    reasoning: false,
+    context: 2e5,
+    output: 64e3,
+    cost: haikuCost,
+    multiplier: 1,
+    releaseDate: "2025-10-01"
+  }),
+  "claude-sonnet-4-5": defineModel({
+    id: "claude-sonnet-4-5",
+    name: "Claude Sonnet 4.5",
+    family: "sonnet",
+    reasoning: true,
+    context: 2e5,
+    output: 64e3,
+    cost: sonnetCost,
+    multiplier: 3,
+    releaseDate: "2025-09-29"
+  }),
+  "claude-sonnet-4-6": defineModel({
+    id: "claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6",
+    family: "sonnet",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: sonnetCost,
+    multiplier: 3,
+    releaseDate: "2025-06-19"
+  }),
+  "claude-sonnet-5": defineModel({
+    id: "claude-sonnet-5",
+    name: "Claude Sonnet 5",
+    family: "sonnet",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: sonnetCost,
+    multiplier: 3,
+    releaseDate: "2026-06-30"
+  }),
+  "claude-opus-4-5": defineModel({
+    id: "claude-opus-4-5",
+    name: "Claude Opus 4.5",
+    family: "opus",
+    reasoning: true,
+    context: 2e5,
+    output: 64e3,
+    cost: opusCost,
+    multiplier: 5,
+    releaseDate: "2025-11-01"
+  }),
+  "claude-opus-4-6": defineModel({
+    id: "claude-opus-4-6",
+    name: "Claude Opus 4.6",
+    family: "opus",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: opusCost,
+    multiplier: 5,
+    releaseDate: "2025-06-19"
+  }),
+  "claude-opus-4-7": defineModel({
+    id: "claude-opus-4-7",
+    name: "Claude Opus 4.7",
+    family: "opus",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: opusCost,
+    multiplier: 5,
+    releaseDate: "2025-07-16"
+  }),
+  "claude-opus-4-8": defineModel({
+    id: "claude-opus-4-8",
+    name: "Claude Opus 4.8",
+    family: "opus",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: opusCost,
+    multiplier: 5,
+    releaseDate: "2026-05-28"
+  }),
+  // Fast mode. The `-fast` suffix is OUR marker, not a model name Anthropic
+  // serves: `parseModelId` strips it before `--model` and turns it into
+  // `--settings {"fastMode":true}` on the spawn. Retired `-fast` model strings
+  // (`claude-opus-4-6-fast`) are a different thing and are not registered here.
+  //
+  // Only Opus 4.8 and Opus 5 qualify: the CLI gates fast mode on the resolved
+  // model name containing `opus-4-8` or `opus-5`, so registering a fast entry
+  // for any other model would produce a picker option that silently runs at
+  // standard speed while displaying the 10x price.
+  "claude-opus-4-8-fast": defineModel({
+    id: "claude-opus-4-8-fast",
+    name: "Claude Opus 4.8 Fast",
+    family: "opus",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: opusFastCost,
+    multiplier: 10,
+    releaseDate: "2026-05-28"
+  }),
+  "claude-opus-5": defineModel({
+    id: "claude-opus-5",
+    name: "Claude Opus 5",
+    family: "opus",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: opusCost,
+    multiplier: 5,
+    releaseDate: "2026-07-24"
+  }),
+  "claude-opus-5-fast": defineModel({
+    id: "claude-opus-5-fast",
+    name: "Claude Opus 5 Fast",
+    family: "opus",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: opusFastCost,
+    multiplier: 10,
+    releaseDate: "2026-07-24"
+  }),
+  "claude-fable-5": defineModel({
+    id: "claude-fable-5",
+    name: "Claude Fable 5",
+    family: "fable",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: fableCost,
+    multiplier: 10,
+    releaseDate: "2026-06-09"
+  }),
+  "claude-fable-5-1": defineModel({
+    id: "claude-fable-5-1",
+    name: "Claude Fable 5.1",
+    family: "fable",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: fable51Cost,
+    multiplier: 10,
+    releaseDate: "2026-09-01"
+  }),
+  // Mythos 5 and 5.1 share the corresponding Fable models' capabilities and
+  // pricing without the safety classifiers; limited availability via Project
+  // Glasswing. `claude --model` simply errors for accounts without access, so
+  // they are safe to register unconditionally.
+  "claude-mythos-5": defineModel({
+    id: "claude-mythos-5",
+    name: "Claude Mythos 5",
+    family: "mythos",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: fableCost,
+    multiplier: 10,
+    releaseDate: "2026-06-09"
+  }),
+  "claude-mythos-5-1": defineModel({
+    id: "claude-mythos-5-1",
+    name: "Claude Mythos 5.1",
+    family: "mythos",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: fable51Cost,
+    multiplier: 10,
+    releaseDate: "2026-09-01"
+  })
+};
+var FAST_SUFFIX = "-fast";
+function parseModelId(modelId) {
+  const at = modelId.indexOf("@");
+  const base = at === -1 ? modelId : modelId.slice(0, at);
+  const account = at === -1 ? "" : modelId.slice(at);
+  if (!base.endsWith(FAST_SUFFIX)) return { model: modelId, fast: false };
+  if (!Object.hasOwn(defaultModels, base)) return { model: modelId, fast: false };
+  return { model: base.slice(0, -FAST_SUFFIX.length) + account, fast: true };
 }
-function deepMerge(target, source) {
-  const out = { ...target };
-  for (const [k, v] of Object.entries(source)) {
-    if (v === void 0) continue;
-    const existing = out[k];
-    if (isPlainObject(existing) && isPlainObject(v)) {
-      out[k] = deepMerge(existing, v);
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
+
+// src/agent-models.ts
+var AGENT_DIR_NAMES = ["agents", "agent"];
+var REASONING_EFFORTS = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var registry = {};
+var defaultSubagentModel;
+function setAgentRegistry(records) {
+  registry = records;
 }
-function walkUp(opts) {
-  const out = [];
-  let current = path5.resolve(opts.start);
-  while (true) {
-    for (const target of opts.targets) {
-      const candidate = path5.join(current, target);
-      if (opts.predicate(candidate)) out.push(candidate);
-    }
-    if (opts.stop && current === path5.resolve(opts.stop)) break;
-    const parent = path5.dirname(current);
-    if (parent === current) break;
-    current = parent;
-  }
-  return out;
+function getAgentRegistry() {
+  return registry;
 }
-function detectWorktree(cwd) {
-  const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path5.resolve(override);
-  let current = path5.resolve(cwd);
-  while (true) {
-    const gitPath = path5.join(current, ".git");
-    try {
-      if (fs4.existsSync(gitPath)) return current;
-    } catch {
-    }
-    const parent = path5.dirname(current);
-    if (parent === current) return void 0;
-    current = parent;
-  }
+function setDefaultSubagentModel(model) {
+  defaultSubagentModel = model?.trim() || void 0;
 }
-function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path5.join(os3.homedir(), ".config");
-  return path5.join(xdg, "opencode");
+function getDefaultSubagentModel() {
+  return defaultSubagentModel;
 }
-function loadGlobalConfig() {
-  const dir = globalConfigDir();
-  let merged = {};
-  for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path5.join(dir, name);
-    if (!fileExists2(file)) continue;
-    const parsed = readAndParse(file);
-    if (parsed) merged = deepMerge(merged, parsed);
-  }
-  return merged;
+function accountMarker(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? "" : modelId.slice(at);
 }
-function loadProjectFilesInDir(dir) {
-  let merged = {};
-  for (const name of PROJECT_FILE_NAMES) {
-    const file = path5.join(dir, name);
-    if (!fileExists2(file)) continue;
-    const parsed = readAndParse(file);
-    if (parsed) merged = deepMerge(merged, parsed);
-  }
-  return merged;
+function withoutAccountMarker(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? modelId : modelId.slice(0, at);
 }
-function dotOpencodeDirs(cwd, worktree) {
-  const dirs = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (p) => {
-    const abs = path5.resolve(p);
-    if (!seen.has(abs) && dirExists2(abs)) {
-      seen.add(abs);
-      dirs.push(abs);
-    }
-  };
-  for (const dir of walkUp({
-    start: cwd,
-    stop: worktree,
-    targets: [".opencode"],
-    predicate: dirExists2
-  })) {
-    push(dir);
+function resolveAgentModel(agent, modelId, overrides) {
+  if (!agent) return modelId;
+  const record = (overrides?.records ?? registry)[agent];
+  if (!record) return modelId;
+  if (record.model?.includes("/")) return modelId;
+  const fallback = overrides ? overrides.defaultSubagentModel : defaultSubagentModel;
+  const declared = record.forceModel?.trim();
+  const wanted = declared || (record.mode === "subagent" ? fallback : void 0);
+  if (!wanted) return modelId;
+  const base = withoutAccountMarker(wanted);
+  if (!Object.hasOwn(defaultModels, base)) {
+    log.warn("agent model override refused: unknown model", {
+      agent,
+      wanted: base,
+      keeping: modelId
+    });
+    return modelId;
   }
-  const home = os3.homedir();
-  if (home) {
-    const homeDot = path5.join(home, ".opencode");
-    if (dirExists2(homeDot)) push(homeDot);
+  const resolved = `${base}${accountMarker(modelId)}`;
+  if (resolved !== modelId) {
+    log.debug("agent model override", { agent, from: modelId, to: resolved });
   }
-  const envDir = process.env.OPENCODE_CONFIG_DIR;
-  if (envDir && dirExists2(envDir)) push(envDir);
-  return dirs;
+  return resolved;
 }
-function substituteEnvPlaceholders(source) {
-  const out = {};
-  for (const [k, v] of Object.entries(source)) {
-    if (typeof v !== "string") continue;
-    out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
-      const resolved = process.env[name];
-      return typeof resolved === "string" ? resolved : "";
+function resolveAgentEffort(agent, inherited, overrides) {
+  if (!agent) return inherited;
+  const record = (overrides?.records ?? registry)[agent];
+  const declared = record?.reasoningEffort?.trim();
+  if (!declared) return inherited;
+  if (!REASONING_EFFORTS.includes(declared)) {
+    log.warn("agent effort override refused: unknown level", {
+      agent,
+      wanted: declared,
+      keeping: inherited
     });
+    return inherited;
   }
-  return out;
-}
-function translateServer(name, spec) {
-  if (spec.enabled === false) return null;
-  const type = spec.type;
-  if (type === "local") {
-    const cmd = spec.command;
-    if (!Array.isArray(cmd) || cmd.length === 0) {
-      log.warn("skipping local MCP server with no command", { name });
-      return null;
-    }
-    const out = {
-      type: "stdio",
-      command: String(cmd[0])
-    };
-    if (cmd.length > 1) out.args = cmd.slice(1).map((s) => String(s));
-    if (spec.environment && typeof spec.environment === "object") {
-      out.env = substituteEnvPlaceholders(
-        spec.environment
-      );
-    }
-    return out;
-  }
-  if (type === "remote") {
-    if (typeof spec.url !== "string" || !spec.url) {
-      log.warn("skipping remote MCP server with no url", { name });
-      return null;
-    }
-    const out = {
-      type: "http",
-      url: spec.url
-    };
-    if (spec.headers && typeof spec.headers === "object") {
-      out.headers = substituteEnvPlaceholders(
-        spec.headers
-      );
-    }
-    return out;
+  if (declared !== inherited) {
+    log.debug("agent effort override", {
+      agent,
+      from: inherited,
+      to: declared
+    });
   }
-  log.warn("skipping MCP server with unknown type", {
-    name,
-    type: type ?? null
-  });
-  return null;
-}
-function extractMcpBlock(config) {
-  const mcp = config.mcp;
-  if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) return {};
-  return mcp;
+  return declared;
 }
-function mergeMcp(target, source) {
-  const out = { ...target };
-  for (const [name, spec] of Object.entries(source)) {
-    if (!spec || typeof spec !== "object") continue;
-    const existing = out[name];
-    if (existing && typeof existing === "object") {
-      out[name] = deepMerge(
-        existing,
-        spec
-      );
-    } else {
-      out[name] = spec;
-    }
+function parseAgentFrontmatter(text) {
+  const record = {};
+  if (!text.startsWith("---")) return record;
+  const lines = text.split(/\r?\n/);
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = /^([A-Za-z_][A-Za-z0-9_-]*):[ \t]*(.*)$/.exec(line);
+    if (!match) continue;
+    const key = match[1];
+    if (key !== "mode" && key !== "model" && key !== "forceModel" && key !== "reasoningEffort")
+      continue;
+    const value = match[2].trim().replace(/^["']|["']$/g, "");
+    if (value) record[key] = value;
   }
-  return out;
+  return record;
 }
-function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
-  const {
-    servers: merged,
-    enabledServerNames: allEnabledServerNames,
-    hash
-  } = mergeOpencodeMcp(cwd, runtimeStatus);
-  const servers = {};
-  const bridgedServerNames = [];
-  for (const [name, spec] of Object.entries(merged)) {
-    if (!spec || typeof spec !== "object") continue;
-    if (excludeServers?.has(name)) continue;
-    const translated = translateServer(name, spec);
-    if (translated) {
-      servers[name] = translated;
-      bridgedServerNames.push(name);
+async function readAgentMarkdownRecords(directories) {
+  const records = {};
+  for (const directory of directories) {
+    let entries;
+    try {
+      entries = await readdir(directory);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const name = entry.slice(0, -3);
+      if (records[name]) continue;
+      try {
+        const text = await readFile(path5.join(directory, entry), "utf8");
+        records[name] = parseAgentFrontmatter(text);
+      } catch (err) {
+        log.debug("failed to read agent markdown", {
+          file: path5.join(directory, entry),
+          error: String(err)
+        });
+      }
     }
   }
-  return finishBridge({
-    servers,
-    bridgedServerNames,
-    allEnabledServerNames,
-    hash,
-    excludeServers
-  });
+  return records;
 }
-function mergeOpencodeMcp(cwd, runtimeStatus) {
-  const worktree = detectWorktree(cwd);
-  let merged = {};
-  merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
-  const explicitConfig = process.env.OPENCODE_CONFIG;
-  if (explicitConfig && fileExists2(explicitConfig)) {
-    const parsed = readAndParse(explicitConfig);
-    if (parsed) merged = mergeMcp(merged, extractMcpBlock(parsed));
-  }
-  const projectFiles = walkUp({
-    start: cwd,
-    stop: worktree,
-    targets: PROJECT_FILE_NAMES,
-    predicate: fileExists2
-  });
-  const projectDirs = [];
-  const seenProjectDirs = /* @__PURE__ */ new Set();
-  for (const f of projectFiles) {
-    const d = path5.dirname(f);
-    if (!seenProjectDirs.has(d)) {
-      seenProjectDirs.add(d);
-      projectDirs.push(d);
+function agentDirectories(home, projectDirectory) {
+  const directories = [];
+  if (projectDirectory) {
+    for (const name of AGENT_DIR_NAMES) {
+      directories.push(path5.join(projectDirectory, ".opencode", name));
     }
   }
-  for (const dir of projectDirs.slice().reverse()) {
-    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
-  }
-  for (const dir of dotOpencodeDirs(cwd, worktree)) {
-    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
-  }
-  if (runtimeStatus) {
-    for (const name of Object.keys(merged)) {
-      const status = runtimeStatus[name];
-      if (status === void 0) continue;
-      const existing = merged[name];
-      const base = existing && typeof existing === "object" ? existing : {};
-      merged[name] = { ...base, enabled: status === "connected" };
+  if (home) {
+    for (const name of AGENT_DIR_NAMES) {
+      directories.push(path5.join(home, ".config", "opencode", name));
     }
   }
-  const enabledServerNames = [];
-  for (const [name, spec] of Object.entries(merged)) {
-    if (!spec || typeof spec !== "object") continue;
-    const enabled = spec.enabled;
-    if (enabled === false) continue;
-    enabledServerNames.push(name);
-  }
-  const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
-  const hash = crypto3.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
-  return { servers: merged, enabledServerNames, hash };
+  return directories;
 }
-function finishBridge(input) {
-  const { servers, bridgedServerNames, allEnabledServerNames, hash, excludeServers } = input;
-  if (Object.keys(servers).length === 0) {
-    const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
-    if (!allEnabledServersExcluded) return null;
-    return {
-      path: "",
-      hash,
-      serverNames: [],
-      allEnabledServerNames
-    };
-  }
-  const body = JSON.stringify({ mcpServers: servers }, null, 2);
-  const outPath = path5.join(
-    pluginTmpDir(),
-    `mcp-${hash}.json`
-  );
+
+// src/skill-bridge.ts
+import * as crypto3 from "crypto";
+import * as fs5 from "fs";
+import * as os3 from "os";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var SKILL_PLUGIN_NAME = "opencode-skills";
+function bundledSkillsDir() {
   try {
-    if (!fileExists2(outPath)) {
-      fs4.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
-    }
-  } catch (e) {
-    log.warn("failed to write bridged MCP config", {
-      error: e instanceof Error ? e.message : String(e)
-    });
+    const here = fileURLToPath2(import.meta.url);
+    const dir = path6.resolve(path6.dirname(here), "..", "skills");
+    return dirExists2(dir) ? dir : null;
+  } catch {
     return null;
   }
-  log.info("bridged opencode MCP config", {
-    target: outPath,
-    hash,
-    servers: bridgedServerNames,
-    excluded: excludeServers ? Array.from(excludeServers) : []
-  });
-  return {
-    path: outPath,
-    hash,
-    serverNames: bridgedServerNames,
-    allEnabledServerNames
-  };
 }
-
-// src/runtime-status.ts
-var opencodeClient = null;
-function setOpencodeClient(client) {
-  if (client && typeof client === "object") {
-    opencodeClient = client;
+function dirExists2(p) {
+  try {
+    return fs5.statSync(p).isDirectory();
+  } catch {
+    return false;
   }
 }
-function getOpencodeClient() {
-  return opencodeClient;
-}
-var opencodeProjectDirectory;
-function setOpencodeProjectDirectory(dir) {
-  opencodeProjectDirectory = dir;
+function fileExists2(p) {
+  try {
+    return fs5.statSync(p).isFile();
+  } catch {
+    return false;
+  }
 }
-function getOpencodeProjectDirectory() {
-  return opencodeProjectDirectory;
+function skillRoots(cwd) {
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    const abs = path6.resolve(p);
+    if (seen.has(abs)) return;
+    seen.add(abs);
+    if (dirExists2(abs)) roots.push(abs);
+  };
+  let current = path6.resolve(cwd);
+  while (true) {
+    push(path6.join(current, ".opencode", "skills"));
+    const parent = path6.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  const home = os3.homedir();
+  if (home) push(path6.join(home, ".opencode", "skills"));
+  const envDir = process.env.OPENCODE_CONFIG_DIR;
+  if (envDir) push(path6.join(envDir, "skills"));
+  const xdg = process.env.XDG_CONFIG_HOME ?? (home ? path6.join(home, ".config") : null);
+  if (xdg) push(path6.join(xdg, "opencode", "skills"));
+  return roots;
 }
-function isUsableDirectory(d) {
-  return typeof d === "string" && d.length > 1 && d !== "/";
+function collectSkills(root, claimed, found) {
+  let entries;
+  try {
+    entries = fs5.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const name = entry.name;
+    if (name.startsWith(".")) continue;
+    if (claimed.has(name)) continue;
+    const dir = path6.join(root, name);
+    if (!fileExists2(path6.join(dir, "SKILL.md"))) continue;
+    claimed.add(name);
+    found.push({ name, dir });
+  }
 }
-function resolveSpawnCwdFrom(configured, live, captured, sessionDir) {
-  if (configured) return configured;
-  if (isUsableDirectory(sessionDir)) return sessionDir;
-  if (isUsableDirectory(live)) return live;
-  return captured ?? live;
+var byName = (a, b) => a.name.localeCompare(b.name);
+function discoverOpencodeSkills(cwd) {
+  const found = [];
+  const claimed = /* @__PURE__ */ new Set();
+  for (const root of skillRoots(cwd)) collectSkills(root, claimed, found);
+  return found.sort(byName);
 }
-async function resolveSpawnCwdForSession(configured, sessionID) {
-  if (configured) return configured;
-  const sessionDir = sessionID ? await fetchSessionDirectory(sessionID) : void 0;
-  return resolveSpawnCwdFrom(
-    configured,
-    process.cwd(),
-    opencodeProjectDirectory,
-    sessionDir
-  );
+function discoverBundledSkills() {
+  const root = bundledSkillsDir();
+  if (!root) return [];
+  const found = [];
+  collectSkills(root, /* @__PURE__ */ new Set(), found);
+  return found.sort(byName);
 }
-async function fetchSessionDirectory(sessionID) {
-  if (!sessionID || sessionID === "default") return void 0;
-  const client = opencodeClient;
-  if (!client?.session?.get) return void 0;
-  try {
-    const res = await client.session.get({ path: { id: sessionID } });
-    const data = res.data;
-    if (!data || typeof data !== "object") return void 0;
-    const dir = data.directory;
-    return isUsableDirectory(dir) ? dir : void 0;
-  } catch (err) {
-    log.warn("failed to fetch opencode session directory", {
-      sessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return void 0;
-  }
+function registerBundledSkillPath(config) {
+  const dir = bundledSkillsDir();
+  if (!dir) return false;
+  config.skills ??= {};
+  const paths = config.skills.paths ??= [];
+  if (paths.some((p) => path6.resolve(p) === dir)) return false;
+  paths.push(dir);
+  return true;
 }
-async function getRuntimeMcpStatus() {
-  const client = opencodeClient;
-  if (!client?.mcp?.status) return void 0;
+function linkSkill(source, target) {
   try {
-    const res = await client.mcp.status();
-    const data = res.data;
-    if (!data || typeof data !== "object") return void 0;
-    const out = {};
-    for (const [name, entry] of Object.entries(data)) {
-      if (entry && typeof entry === "object") {
-        const status = entry.status;
-        if (typeof status === "string") out[name] = status;
-      }
-    }
-    return out;
-  } catch (err) {
-    log.warn("failed to fetch opencode MCP runtime status", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return void 0;
+    fs5.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+    return;
+  } catch {
+    fs5.cpSync(source, target, { recursive: true, dereference: true });
   }
-}
-async function fetchOpencodeToolList(provider, model, directory) {
-  const client = opencodeClient;
-  if (!client?.tool?.list) return void 0;
-  try {
-    const res = await client.tool.list({
-      query: { provider, model, ...directory ? { directory } : {} }
-    });
-    const data = res.data;
-    if (!Array.isArray(data)) return void 0;
-    const out = [];
-    for (const entry of data) {
-      if (!entry || typeof entry !== "object") continue;
-      const e = entry;
-      const id = typeof e.id === "string" ? e.id : null;
-      const description = typeof e.description === "string" ? e.description : "";
-      const parameters = e.parameters && typeof e.parameters === "object" ? e.parameters : {};
-      if (!id) continue;
-      out.push({ id, description, parameters });
+}
+function buildSkillPluginDir(skills) {
+  if (skills.length === 0) return null;
+  const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
+  const hash = crypto3.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
+  const root = path6.join(pluginTmpDir(), `skills-${hash}`);
+  const manifest = path6.join(root, ".claude-plugin", "plugin.json");
+  if (fileExists2(manifest)) return root;
+  try {
+    fs5.rmSync(root, { recursive: true, force: true });
+    fs5.mkdirSync(path6.join(root, ".claude-plugin"), { recursive: true });
+    fs5.mkdirSync(path6.join(root, "skills"), { recursive: true });
+    fs5.writeFileSync(
+      manifest,
+      JSON.stringify(
+        {
+          name: SKILL_PLUGIN_NAME,
+          description: "Skills discovered from this opencode installation, bridged into Claude Code."
+        },
+        null,
+        2
+      ),
+      { encoding: "utf8", mode: 384 }
+    );
+    for (const skill of skills) {
+      linkSkill(skill.dir, path6.join(root, "skills", skill.name));
     }
-    return out;
   } catch (err) {
-    log.warn("failed to fetch opencode tool list", {
-      provider,
-      model,
+    log.warn("failed to stage opencode skill plugin dir", {
+      root,
       error: err instanceof Error ? err.message : String(err)
     });
-    return void 0;
+    return null;
+  }
+  return root;
+}
+async function resolveSkillPluginDirs(opts) {
+  const user = opts.enabled ? discoverOpencodeSkills(opts.cwd) : [];
+  const claimed = new Set(user.map((s) => s.name));
+  const bundled = discoverBundledSkills().filter((s) => !claimed.has(s.name));
+  const skills = [...user, ...bundled].sort(byName);
+  if (skills.length === 0) return [];
+  const supported = await detectCliSupportsFlag(opts.cliPath, "--plugin-dir");
+  if (!supported) {
+    log.notice(
+      "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
+      { skills: skills.length }
+    );
+    return [];
   }
+  const dir = buildSkillPluginDir(skills);
+  if (!dir) return [];
+  log.info("bridged opencode skills into claude", {
+    count: skills.length,
+    names: skills.map((s) => s.name),
+    bundled: bundled.map((s) => s.name),
+    pluginDir: dir
+  });
+  return [dir];
 }
 
 // src/claude-session-wrapper.ts
@@ -3909,12 +4654,12 @@ import { unlink as unlink2 } from "fs/promises";
 
 // src/claude-session-bun.ts
 import * as os4 from "os";
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs6 from "fs";
+import * as path7 from "path";
 import { execFileSync } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 function resolveClaude(cmd = "claude") {
-  if (path6.isAbsolute(cmd) && fs5.existsSync(cmd)) return cmd;
+  if (path7.isAbsolute(cmd) && fs6.existsSync(cmd)) return cmd;
   const viaBun = Bun.which(cmd);
   if (viaBun) return viaBun;
   const isWin = os4.platform() === "win32";
@@ -3923,25 +4668,25 @@ function resolveClaude(cmd = "claude") {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
-    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs5.existsSync(p));
+    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs6.existsSync(p));
     if (first) return first;
   } catch {
   }
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  return path6.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+  return path7.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
 }
 var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path6.join(os4.homedir(), ".claude");
+  if (!value) return path7.join(os4.homedir(), ".claude");
   if (value === "~") return os4.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path6.join(os4.homedir(), value.slice(2));
+    return path7.join(os4.homedir(), value.slice(2));
   }
-  return path6.resolve(value);
+  return path7.resolve(value);
 }
 var ClaudeSession = class {
   sessionId;
@@ -3959,11 +4704,11 @@ var ClaudeSession = class {
   signal;
   o;
   constructor(opts = {}) {
-    this.cwd = path6.resolve(opts.cwd ?? process.cwd());
+    this.cwd = path7.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
     this.signal = opts.signal;
     this.sessionId = randomUUID4();
-    this.jsonlPath = path6.join(
+    this.jsonlPath = path7.join(
       this.configDir,
       "projects",
       encodeCwd(this.cwd),
@@ -4086,7 +4831,7 @@ var ClaudeSession = class {
   }
   readRawLines() {
     try {
-      return fs5.readFileSync(this.jsonlPath, "utf8").split("\n");
+      return fs6.readFileSync(this.jsonlPath, "utf8").split("\n");
     } catch {
       return [];
     }
@@ -4464,11 +5209,11 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/claude-code-language-model.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname5, join as join8 } from "path";
 var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
 function resolveCompactionModel(configured) {
   const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
@@ -4532,7 +5277,11 @@ var AUTO_CONTINUE_MAX_ATTEMPTS = 8;
 var AUTO_CONTINUE_MAX_ELAPSED_MS = 10 * 60 * 1e3;
 var AUTO_CONTINUE_NO_PROGRESS_LIMIT = 2;
 var PROXY_RESULT_BOUNDARY_GRACE_MS = 250;
+var CHILD_EXIT_STATUS_GRACE_MS = 250;
 var AUTO_CONTINUE_PROMPT = "Continue the task from where you stopped. Do not summarize; keep working until the requested task is complete, you need clarification, or you hit a real blocker.";
+function autoContinueEnabledFor(compactionMode, configured) {
+  return compactionMode ? false : configured;
+}
 function isTruncationStopReason(stopReason) {
   return stopReason === "max_tokens" || stopReason === "max_output_tokens";
 }
@@ -4690,7 +5439,7 @@ ${body}`;
 }
 function readPromptFileIfPresent(path9) {
   try {
-    const content = readFileSync3(path9, "utf8").trim();
+    const content = readFileSync4(path9, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -4699,9 +5448,9 @@ function readPromptFileIfPresent(path9) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join7(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join8(dir, "AGENTS.md"));
     if (content) return content;
-    const parent = dirname4(dir);
+    const parent = dirname5(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -4785,8 +5534,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join7(homedir5(), ".config");
-  const globalAgents = readPromptFileIfPresent(join7(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir5(), ".config");
+  const globalAgents = readPromptFileIfPresent(join8(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -4797,7 +5546,7 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path9 = join7(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
+  const path9 = join8(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
     writeFileSync4(path9, content, "utf8");
     return path9;
@@ -5593,6 +6342,13 @@ var ClaudeCodeLanguageModel = class {
               setClaudeSessionId(sk, msg.session_id);
             }
             reportFastModeState(msg, fastMode);
+            reportSystemInit(msg, {
+              ignoreAnthropicApiKey: this.config.ignoreAnthropicApiKey
+            });
+          }
+          if (msg.type === "rate_limit_event") {
+            reportRateLimitEvent(msg);
+            return;
           }
           if (msg.type === "assistant" && msg.message?.content && !gotPartialEvents) {
             for (const block of msg.message.content) {
@@ -5702,8 +6458,21 @@ ${plan}
               sessionId: msg.session_id,
               costUsd: msg.total_cost_usd,
               durationMs: msg.duration_ms,
-              usage: msg.usage
+              durationApiMs: msg.duration_api_ms,
+              numTurns: msg.num_turns,
+              usage: msg.usage,
+              modelUsage: msg.modelUsage,
+              permissionDenials: msg.permission_denials?.map((denial) => ({
+                tool_name: denial.tool_name,
+                tool_use_id: denial.tool_use_id
+              }))
             };
+            log.info("conversation result", {
+              sessionId: msg.session_id,
+              isError: msg.is_error,
+              subtype: msg.subtype,
+              ...turnStatsLogPayload(extractTurnStats(msg))
+            });
             cleanup();
             resolve5({
               ...resultMeta,
@@ -5851,6 +6620,39 @@ ${plan}
     const useInteractive = interactivePref && typeof globalThis.Bun?.Terminal === "function";
     const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
     const asideTransportRef = { cliPath, interactive: !!useInteractive };
+    const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
+    if (doctor) {
+      const doctorOptions = {
+        cliPath,
+        interactive: !!useInteractive,
+        turnStats: this.config.turnStats === true
+      };
+      const stream2 = new ReadableStream({
+        async start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+          try {
+            const text = await buildDoctorReport(doctorOptions);
+            const id = generateId();
+            controller.enqueue({ type: "text-start", id });
+            controller.enqueue({ type: "text-delta", id, delta: text });
+            controller.enqueue({ type: "text-end", id });
+            controller.enqueue({
+              type: "finish",
+              finishReason: toFinishReason("stop"),
+              usage: toUsage({ input_tokens: 0, output_tokens: 0 }),
+              providerMetadata: {
+                "claude-code": { path: "doctor", synthetic: true, usageUnavailable: true }
+              }
+            });
+          } catch (error) {
+            controller.enqueue({ type: "error", error });
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      return { stream: stream2, request: { body: { text: `/${DOCTOR_COMMAND}` } } };
+    }
     const aside = !compactionMode && scope !== "no-tools" ? parseSideQuestion(options.prompt) : null;
     if (aside) {
       const active = getActiveProcess(sk);
@@ -6289,7 +7091,10 @@ ${plan}
           let hadProxyActivitySinceContinue = false;
           let lastStopReason = null;
           const autoContinueState = {
-            enabled: self.config.autoContinueIncompleteTurns,
+            enabled: autoContinueEnabledFor(
+              compactionMode,
+              self.config.autoContinueIncompleteTurns
+            ),
             attempts: 0,
             startedAt: Date.now(),
             noProgressCount: 0
@@ -6436,6 +7241,7 @@ ${plan}
           const skipResultForIds = /* @__PURE__ */ new Set();
           const toolCallsById = /* @__PURE__ */ new Map();
           let resultMeta = {};
+          let resultFailure;
           const drainBuffer = [];
           let drainTimer = null;
           const DRAIN_QUIET_MS = 100;
@@ -6658,11 +7464,12 @@ ${plan}
             }
             controller.enqueue({
               type: "finish",
-              finishReason: toFinishReason("stop"),
+              finishReason: resultFailure ? { unified: "error", raw: resultFailure } : toFinishReason("stop"),
               usage: toUsage(msg.usage),
               providerMetadata: {
                 "claude-code": {
                   ...resultMeta,
+                  ...resultFailure ? { resultSubtype: resultFailure } : {},
                   ...compactionMode ? { compactionModel: effectiveModelId } : {}
                 },
                 ...typeof msg.usage?.cache_creation_input_tokens === "number" ? {
@@ -6714,6 +7521,24 @@ ${plan}
                   });
                 }
                 reportFastModeState(msg, fastMode);
+                reportSystemInit(msg, {
+                  ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey
+                });
+              }
+              if (msg.type === "system" && msg.subtype === "compact_boundary") {
+                const note = reportCompactBoundary(msg);
+                if (note) {
+                  controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: note });
+                  endTextBlock();
+                }
+              }
+              if (msg.type === "rate_limit_event") {
+                const note = reportRateLimitEvent(msg);
+                if (note) {
+                  controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: note });
+                  endTextBlock();
+                }
+                return;
               }
               if (msg.type === "content_block_start" && msg.content_block && msg.index !== void 0) {
                 const block = msg.content_block;
@@ -7152,12 +7977,12 @@ ${plan}
                     }
                     const claudeSessionId = getClaudeSessionId(sk);
                     if (claudeSessionId) {
-                      const list = applyTaskCreateToolResult(
+                      const list2 = applyTaskCreateToolResult(
                         claudeSessionId,
                         block.tool_use_id,
                         resultText
                       );
-                      if (list) {
+                      if (list2) {
                         const synthId = `todowrite_${block.tool_use_id}`;
                         controller.enqueue({
                           type: "tool-input-start",
@@ -7170,7 +7995,7 @@ ${plan}
                           toolCallId: synthId,
                           toolName: "todowrite",
                           input: JSON.stringify({
-                            todos: list.map((t) => ({
+                            todos: list2.map((t) => ({
                               id: t.id,
                               content: t.content,
                               status: t.status,
@@ -7184,6 +8009,7 @@ ${plan}
                     }
                     const toolCall = toolCallsById.get(block.tool_use_id);
                     if (toolCall) {
+                      const isError = block.is_error === true;
                       controller.enqueue({
                         type: "tool-result",
                         toolCallId: block.tool_use_id,
@@ -7191,14 +8017,16 @@ ${plan}
                         result: {
                           output: resultText,
                           title: toolCall.name,
-                          metadata: {}
+                          metadata: isError ? { error: true } : {}
                         },
+                        ...isError ? { isError: true } : {},
                         providerExecuted: true
                       });
                       noteToolActivity();
                       log.info("tool result emitted", {
                         toolUseId: block.tool_use_id,
-                        name: toolCall.name
+                        name: toolCall.name,
+                        isError
                       });
                       toolCallsById.delete(block.tool_use_id);
                     }
@@ -7221,18 +8049,49 @@ ${plan}
                     delta: msg.result
                   });
                 }
+                const failure = describeResultFailure(msg);
+                if (failure) {
+                  resultFailure = msg.subtype;
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: startTextBlock(),
+                    delta: formatResultFailureNote(failure)
+                  });
+                  log.warn(failure, { sessionKey: sk, subtype: msg.subtype });
+                }
+                const turnStats = extractTurnStats(msg);
                 resultMeta = {
                   sessionId: msg.session_id,
                   costUsd: msg.total_cost_usd,
                   durationMs: msg.duration_ms,
-                  usage: msg.usage
+                  durationApiMs: msg.duration_api_ms,
+                  numTurns: msg.num_turns,
+                  usage: msg.usage,
+                  modelUsage: msg.modelUsage,
+                  // Names and ids only: a denial's `tool_input` can be a whole
+                  // file write payload and has no business in metadata.
+                  permissionDenials: msg.permission_denials?.map((denial) => ({
+                    tool_name: denial.tool_name,
+                    tool_use_id: denial.tool_use_id
+                  }))
                 };
                 log.info("conversation result", {
                   sessionId: msg.session_id,
-                  durationMs: msg.duration_ms,
                   numTurns: msg.num_turns,
-                  isError: msg.is_error
+                  isError: msg.is_error,
+                  subtype: msg.subtype,
+                  ...turnStatsLogPayload(turnStats)
                 });
+                if (self.config.turnStats && !compactionMode && !msg.is_error && !failure) {
+                  const footer = formatTurnStatsBlock(turnStats);
+                  if (footer) {
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: startTextBlock(),
+                      delta: footer
+                    });
+                  }
+                }
                 turnCompleted = true;
                 endTextBlock();
                 const shouldDeferResult = !msg.is_error && !autoContinueState.aborted && !autoContinueState.sawAskUserQuestion;
@@ -7284,24 +8143,59 @@ ${plan}
               );
               drainBuffer.length = 0;
             }
+            const crashed = !turnCompleted && !autoContinueState.aborted;
             controllerClosed = true;
             cleanupTurn();
             endTextBlock();
-            controller.enqueue({
-              type: "finish",
-              finishReason: toFinishReason("stop"),
-              usage: toUsage(),
-              providerMetadata: {
-                "claude-code": {
-                  ...resultMeta,
-                  ...compactionMode ? { compactionModel: effectiveModelId } : {}
+            const finishClose = (exitCode, signal) => {
+              if (crashed) {
+                log.warn("claude process closed without a result", {
+                  sessionKey: sk,
+                  exitCode,
+                  signal,
+                  stderrBytes: activeProcess?.lastStderr?.length ?? 0
+                });
+                controller.enqueue({
+                  type: "error",
+                  error: new Error(
+                    describeChildCrash(exitCode, signal, activeProcess?.lastStderr)
+                  )
+                });
+              }
+              controller.enqueue({
+                type: "finish",
+                finishReason: toFinishReason(crashed ? "error" : "stop"),
+                usage: toUsage(),
+                providerMetadata: {
+                  "claude-code": {
+                    ...resultMeta,
+                    ...compactionMode ? { compactionModel: effectiveModelId } : {}
+                  }
                 }
+              });
+              try {
+                controller.close();
+              } catch {
               }
-            });
-            try {
-              controller.close();
-            } catch {
+            };
+            if (crashed && proc.exitCode === null && proc.signalCode === null) {
+              let reported = false;
+              const report = (exitCode, signal) => {
+                if (reported) return;
+                reported = true;
+                clearTimeout(exitGrace);
+                proc.off("exit", onExit);
+                finishClose(exitCode, signal);
+              };
+              const onExit = (code, signal) => report(code, signal);
+              const exitGrace = setTimeout(
+                () => report(proc.exitCode, proc.signalCode),
+                CHILD_EXIT_STATUS_GRACE_MS
+              );
+              proc.once("exit", onExit);
+              return;
             }
+            finishClose(proc.exitCode, proc.signalCode);
           };
           let cleanedUp = false;
           const cleanupTurn = () => {
@@ -7567,7 +8461,7 @@ ${plan}
 
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 var BASE_PROVIDER_ID = "claude-code";
 var DEFAULT_ACCOUNT = "default";
 var SHARED_CAPABILITY_ITEMS = [
@@ -7605,7 +8499,7 @@ function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path7.join(home, value.slice(2)) : value;
+    return home ? path8.join(home, value.slice(2)) : value;
   }
   return value;
 }
@@ -7637,8 +8531,8 @@ async function ensureSharedCapabilities(targetRoot) {
   }
 }
 async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path7.join(sourceRoot, item);
-  const target = path7.join(targetRoot, item);
+  const source = path8.join(sourceRoot, item);
+  const target = path8.join(targetRoot, item);
   let sourceStat;
   try {
     sourceStat = await lstat(source);
@@ -7649,8 +8543,8 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     const targetStat = await lstat(target);
     if (targetStat.isSymbolicLink()) {
       const current = await readlink(target);
-      const resolvedCurrent = path7.resolve(path7.dirname(target), current);
-      const resolvedSource = path7.resolve(source);
+      const resolvedCurrent = path8.resolve(path8.dirname(target), current);
+      const resolvedSource = path8.resolve(source);
       if (resolvedCurrent === resolvedSource) return;
     }
     log.warn("shared Claude capability already exists; leaving untouched", {
@@ -7665,11 +8559,11 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
   await symlink(source, target, type);
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path7.join(
+  const cacheRoot = path8.join(
     process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
     "opencode-claude-code-plugin"
   );
-  const wrapperPath = path7.join(cacheRoot, `claude-${account}`);
+  const wrapperPath = path8.join(cacheRoot, `claude-${account}`);
   const suffix = `@${account}`;
   await mkdir(cacheRoot, { recursive: true });
   const script = `#!/usr/bin/env bash
@@ -7710,34 +8604,34 @@ function titleizeAccount(account) {
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync4,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   realpathSync,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join8, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { join as join9, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
 var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join8(xdg, "opencode") : null,
-    join8(homedir6(), ".cache", "opencode"),
-    join8(homedir6(), "Library", "Caches", "opencode")
+    xdg ? join9(xdg, "opencode") : null,
+    join9(homedir6(), ".cache", "opencode"),
+    join9(homedir6(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join8(homedir6(), ".config");
-  return join8(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join9(homedir6(), ".config");
+  return join9(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync4(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync4(cfg, "utf8"));
+    const json = JSON.parse(readFileSync5(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -7749,7 +8643,7 @@ function userIntendsToUseUnscoped() {
 }
 function ourLoadedDir() {
   try {
-    const filePath = fileURLToPath2(import.meta.url);
+    const filePath = fileURLToPath3(import.meta.url);
     return realpathSync(resolve4(filePath, "..", ".."));
   } catch {
     return null;
@@ -7774,7 +8668,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync4(cacheRoot)) return;
-  const stalePath = join8(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join9(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync4(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -7782,11 +8676,11 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join8(stalePath, "package.json");
+  const pkgJsonPath = join9(stalePath, "package.json");
   if (!existsSync4(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync4(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -7802,10 +8696,10 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join8(cacheRoot, "package.json");
+  const cachePkgJson = join9(cacheRoot, "package.json");
   if (!existsSync4(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync4(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync5(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
       writeFileSync5(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
@@ -7818,131 +8712,6 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
-// src/startup-diagnostics.ts
-import { execFile as execFile2 } from "child_process";
-import * as fs6 from "fs";
-import * as path8 from "path";
-import { promisify as promisify2 } from "util";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var cachedPluginVersion;
-function pluginVersion() {
-  if (cachedPluginVersion) return cachedPluginVersion;
-  try {
-    const here = path8.dirname(fileURLToPath3(import.meta.url));
-    const raw = fs6.readFileSync(path8.join(here, "..", "package.json"), "utf8");
-    const version = JSON.parse(raw).version;
-    cachedPluginVersion = typeof version === "string" ? version : "unknown";
-  } catch {
-    cachedPluginVersion = "unknown";
-  }
-  return cachedPluginVersion;
-}
-function pickOpencodeVersion(input) {
-  if (!input || typeof input !== "object") return void 0;
-  const app = input.app;
-  if (app && typeof app === "object") {
-    const version = app.version;
-    if (typeof version === "string" && version.length > 0) return version;
-  }
-  const direct = input.version;
-  if (typeof direct === "string" && direct.length > 0) return direct;
-  return void 0;
-}
-var execFileAsync2 = promisify2(execFile2);
-var opencodeVersionProbe;
-function detectOpencodeVersion(execPath = process.execPath) {
-  if (opencodeVersionProbe) return opencodeVersionProbe;
-  opencodeVersionProbe = (async () => {
-    if (!path8.basename(execPath).toLowerCase().includes("opencode")) {
-      log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
-      return void 0;
-    }
-    try {
-      const { stdout } = await execFileAsync2(execPath, ["--version"], { timeout: 5e3 });
-      const match = /\d+\.\d+\.\d+\S*/.exec(stdout.trim());
-      return match ? match[0] : void 0;
-    } catch (err) {
-      log.debug("opencode version probe failed", {
-        execPath,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      return void 0;
-    }
-  })();
-  return opencodeVersionProbe;
-}
-function describeSpawnCwd(configured, live = process.cwd(), captured = getOpencodeProjectDirectory()) {
-  if (typeof configured === "string" && configured.length > 0) {
-    return { resolved: configured, source: "configured" };
-  }
-  if (isUsableDirectory(live)) return { resolved: live, source: "process" };
-  if (isUsableDirectory(captured)) return { resolved: captured, source: "captured" };
-  return { resolved: live, source: "unresolved" };
-}
-function stringList(value) {
-  if (!Array.isArray(value)) return [];
-  return value.filter((entry) => typeof entry === "string");
-}
-function firstOption(providers, key) {
-  for (const entry of Object.values(providers)) {
-    const value = entry?.options?.[key];
-    if (value !== void 0) return value;
-  }
-  return void 0;
-}
-function collectStartupDiagnostics(providers, opencodeVersion) {
-  const accounts = [];
-  for (const entry of Object.values(providers)) {
-    const account = entry?.options?.account;
-    if (typeof account === "string" && account.length > 0) accounts.push(account);
-  }
-  const cwd = describeSpawnCwd(firstOption(providers, "cwd"));
-  let mcpServers = [];
-  try {
-    mcpServers = mergeOpencodeMcp(cwd.resolved).enabledServerNames;
-  } catch (err) {
-    log.debug("startup diagnostics could not read MCP config", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-  return {
-    plugin: pluginVersion(),
-    opencode: opencodeVersion ?? process.env.OPENCODE_VERSION ?? "unknown",
-    claudeCliPath: String(firstOption(providers, "cliPath") ?? "claude"),
-    cwd,
-    providers: Object.keys(providers),
-    accounts,
-    proxyTools: stringList(firstOption(providers, "proxyTools")),
-    mcpServers,
-    interactiveTransport: firstOption(providers, "interactive") === true || process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT === "1",
-    planModeQuestion: firstOption(providers, "planModeQuestion") === true,
-    anthropicApiKeyInEnv: Boolean(
-      process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
-    )
-  };
-}
-var logged = false;
-function logStartupDiagnostics(providers, opencodeVersion) {
-  if (logged) return;
-  logged = true;
-  void (async () => {
-    try {
-      const version = opencodeVersion ?? process.env.OPENCODE_VERSION ?? await detectOpencodeVersion();
-      const { claudeCliPath, ...rest } = collectStartupDiagnostics(providers, version);
-      const cli = await detectCliVersion(claudeCliPath);
-      const diagnostics = {
-        ...rest,
-        claudeCli: { path: claudeCliPath, version: cli?.raw ?? "not detected" }
-      };
-      log.notice("claude-code plugin ready", { ...diagnostics });
-    } catch (err) {
-      log.debug("startup diagnostics failed", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  })();
-}
-
 // src/index.ts
 function pickOpencodeDirectory(input) {
   if (!input || typeof input !== "object") return void 0;
@@ -7969,6 +8738,15 @@ function registerSideQuestionCommand(config) {
   };
   return true;
 }
+function registerDoctorCommand(config) {
+  config.command ??= {};
+  if (config.command[DOCTOR_COMMAND]) return false;
+  config.command[DOCTOR_COMMAND] = {
+    template: `/${DOCTOR_COMMAND} $ARGUMENTS`,
+    description: "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls"
+  };
+  return true;
+}
 var ownsSideQuestionCommand = false;
 function warnIfAnthropicApiKey(ignore) {
   if (warnedAnthropicApiKey) return;
@@ -8039,6 +8817,7 @@ function createClaudeCode(settings = {}) {
       ignoreAnthropicApiKey: settings.ignoreAnthropicApiKey,
       idleProcessTimeoutMs: settings.idleProcessTimeoutMs,
       bridgeOpencodeSkills: settings.bridgeOpencodeSkills === true,
+      turnStats: settings.turnStats === true,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
       interactiveAllowTools: settings.interactiveAllowTools,
@@ -8238,6 +9017,7 @@ var server = async (input) => {
   return {
     config: async (config) => {
       if (registerSideQuestionCommand(config)) ownsSideQuestionCommand = true;
+      registerDoctorCommand(config);
       registerBundledSkillPath(config);
       config.provider ??= {};
       await buildAgentRegistry(config);
@@ -8323,6 +9103,7 @@ export {
   defaultModels,
   getAgentRegistry,
   getDefaultSubagentModel,
+  registerDoctorCommand,
   registerSideQuestionCommand,
   resolveAgentModel,
   warnIfPlanModeCannotExit