@khalilgharbaoui/opencode-claude-code-plugin 0.18.3 → 0.20.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 };
   }
@@ -475,9 +475,6 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
 import { unlink } from "fs/promises";
 
-// src/proxy-broker.ts
-import { EventEmitter as EventEmitter2 } from "events";
-
 // src/proxy-mcp.ts
 import { createServer } from "http";
 import * as fs2 from "fs";
@@ -511,7 +508,7 @@ function pluginTmpDir() {
 }
 
 // src/proxy-mcp.ts
-var SSE_KEEPALIVE_MS = 15e3;
+var PROXY_KEEPALIVE_MS = 15e3;
 function acceptsEventStream(acceptHeader) {
   return typeof acceptHeader === "string" && acceptHeader.toLowerCase().includes("text/event-stream");
 }
@@ -523,11 +520,11 @@ var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_NAME = "opencode_proxy";
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
 var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var PROXY_NO_DEADLINE_MS = 0;
 var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
-  task: 60 * 60 * 1e3,
-  // 60 min
-  task_batch: 60 * 60 * 1e3,
-  // 60 min, same reasoning: it IS task calls
+  task: PROXY_NO_DEADLINE_MS,
+  task_batch: PROXY_NO_DEADLINE_MS,
+  // same reasoning: it IS task calls
   question: 30 * 60 * 1e3
   // 30 min
 };
@@ -537,7 +534,7 @@ function resolveProxyCallTimeoutMs(toolName, input, overrides) {
   let ms = PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS[key] ?? PROXY_DEFAULT_TIMEOUT_MS;
   if (overrides) {
     const ov = lookupCaseInsensitive(overrides, key);
-    if (typeof ov === "number" && ov > 0) ms = ov;
+    if (isDeadlineOverride(ov)) ms = ov;
   }
   if (key === "bash") {
     const requested = input?.timeout;
@@ -545,6 +542,9 @@ function resolveProxyCallTimeoutMs(toolName, input, overrides) {
   }
   return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
+function isDeadlineOverride(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
 function lookupCaseInsensitive(map, key) {
   if (Object.prototype.hasOwnProperty.call(map, key)) return map[key];
   for (const k of Object.keys(map)) {
@@ -554,14 +554,20 @@ function lookupCaseInsensitive(map, key) {
 }
 function resolveProxyClientCeilingMs(overrides) {
   let ms = PROXY_DEFAULT_TIMEOUT_MS;
-  for (const v of Object.values(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
-    if (v > ms) ms = v;
-  }
-  if (overrides) {
-    for (const v of Object.values(overrides)) {
-      if (typeof v === "number" && v > ms) ms = v;
+  const consider = (deadlineMs) => {
+    if (deadlineMs === PROXY_NO_DEADLINE_MS) return true;
+    if (deadlineMs > ms) ms = deadlineMs;
+    return false;
+  };
+  for (const [toolName, defaultMs] of Object.entries(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
+    const override = overrides ? lookupCaseInsensitive(overrides, toolName) : void 0;
+    if (consider(isDeadlineOverride(override) ? override : defaultMs)) {
+      return MAX_PROXY_TIMEOUT_MS;
     }
   }
+  for (const value of Object.values(overrides ?? {})) {
+    if (isDeadlineOverride(value) && consider(value)) return MAX_PROXY_TIMEOUT_MS;
+  }
   return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
 function buildProxyTimeoutError(toolName, ms) {
@@ -574,9 +580,9 @@ function buildProxyTimeoutError(toolName, ms) {
   }
   return new Error(base);
 }
-var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls have no proxy deadline by default: the call waits for the subagent to finish (a positive proxyToolTimeoutMs override adds a deadline).";
 var TASK_BATCH_TOOL_NAME = "task_batch";
-var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Same 60-minute proxy deadline as task (configurable via proxyToolTimeoutMs).";
+var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Like task it has no proxy deadline by default (a positive proxyToolTimeoutMs override adds one).";
 var TASK_INPUT_REQUIRED = ["description", "prompt", "subagent_type"];
 function taskBatchInputError(input) {
   const tasks = input?.tasks;
@@ -874,9 +880,10 @@ var DEFAULT_PROXY_TOOLS = [
     }
   }
 ];
-async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors) {
+async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors, options = {}) {
   const calls = new EventEmitter();
   const pending = /* @__PURE__ */ new Map();
+  const keepaliveMs = options.keepaliveMs ?? PROXY_KEEPALIVE_MS;
   const authToken = crypto.randomBytes(32).toString("hex");
   const expectedAuth = Buffer.from(`Bearer ${authToken}`);
   let boundAuthority = "";
@@ -925,7 +932,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
     }
     let requestId = null;
     let requestMethod = null;
-    let sse = null;
+    let reply = null;
     try {
       const body = await readBody(req);
       const request = JSON.parse(body);
@@ -1020,11 +1027,9 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           sse: acceptsEventStream(req.headers.accept)
         });
         const channel = { closed: false };
-        if (acceptsEventStream(req.headers.accept)) {
-          sse = openEventStream(res);
-        }
+        reply = acceptsEventStream(req.headers.accept) ? openEventStream(res, keepaliveMs) : openJsonStream(res, keepaliveMs);
         res.once("close", () => {
-          sse?.stop();
+          reply?.stop();
           if (res.writableFinished) return;
           channel.closed = true;
           log.notice("proxy-mcp client closed a tool call before its result", {
@@ -1049,16 +1054,18 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
               input,
               timeoutOverrides
             );
-            timer = setTimeout(() => {
-              if (!pending.has(callId)) return;
-              pending.delete(callId);
-              log.notice("proxy-mcp tool call timed out", {
-                callId,
-                toolName,
-                deadlineMs
-              });
-              reject2(buildProxyTimeoutError(toolName, deadlineMs));
-            }, deadlineMs);
+            if (deadlineMs > PROXY_NO_DEADLINE_MS) {
+              timer = setTimeout(() => {
+                if (!pending.has(callId)) return;
+                pending.delete(callId);
+                log.notice("proxy-mcp tool call timed out", {
+                  callId,
+                  toolName,
+                  deadlineMs
+                });
+                reject2(buildProxyTimeoutError(toolName, deadlineMs));
+              }, deadlineMs);
+            }
             calls.emit("call", entry);
           }
         ).finally(() => {
@@ -1072,7 +1079,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           });
           return;
         }
-        writeToolCallResult(res, requestId, result, sse);
+        writeToolCallResult(res, requestId, result, reply);
         return;
       }
       writeJson(res, {
@@ -1092,7 +1099,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
             res,
             requestId,
             { kind: "error", message: errorMessage },
-            sse
+            reply
           );
         } catch {
           try {
@@ -1174,6 +1181,9 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       configFilePath = outPath;
       return outPath;
     },
+    pendingCallIds() {
+      return [...pending.keys()];
+    },
     async close() {
       for (const entry of pending.values()) {
         entry.reject(new Error(SERVER_CLOSED_MESSAGE));
@@ -1246,7 +1256,7 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
-function writeToolCallResult(res, requestId, result, sse = null) {
+function writeToolCallResult(res, requestId, result, reply = null) {
   const text = result.kind === "error" ? result.message : result.text;
   const isError = result.kind === "error" || result.isError === true;
   const envelope = {
@@ -1257,26 +1267,20 @@ function writeToolCallResult(res, requestId, result, sse = null) {
       isError
     }
   };
-  if (sse) {
-    sse.finish(envelope);
+  if (reply) {
+    reply.finish(envelope);
     return;
   }
   writeJson(res, envelope);
 }
-function openEventStream(res) {
-  res.statusCode = 200;
-  res.setHeader("Content-Type", "text/event-stream");
-  res.setHeader("Cache-Control", "no-cache, no-transform");
-  res.setHeader("Connection", "keep-alive");
-  res.flushHeaders();
-  res.write(": open\n\n");
+function startKeepalive(res, keepaliveMs, ping) {
   let timer = setInterval(() => {
     if (res.writableEnded || res.destroyed) {
       stop();
       return;
     }
-    res.write(": keepalive\n\n");
-  }, SSE_KEEPALIVE_MS);
+    res.write(ping);
+  }, keepaliveMs);
   timer.unref?.();
   const stop = () => {
     if (timer) {
@@ -1284,6 +1288,16 @@ function openEventStream(res) {
       timer = null;
     }
   };
+  return stop;
+}
+function openEventStream(res, keepaliveMs) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+  res.write(": open\n\n");
+  const stop = startKeepalive(res, keepaliveMs, ": keepalive\n\n");
   return {
     stop,
     finish(envelope) {
@@ -1296,6 +1310,21 @@ data: ${JSON.stringify(envelope)}
     }
   };
 }
+function openJsonStream(res, keepaliveMs) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.flushHeaders();
+  const stop = startKeepalive(res, keepaliveMs, " ");
+  return {
+    stop,
+    finish(envelope) {
+      stop();
+      if (res.writableEnded || res.destroyed) return;
+      res.end(JSON.stringify(envelope));
+    }
+  };
+}
 function writeJson(res, body) {
   if (res.destroyed || res.writableEnded) return;
   const payload = JSON.stringify(body);
@@ -1306,6 +1335,7 @@ function writeJson(res, body) {
 }
 
 // src/proxy-broker.ts
+import { EventEmitter as EventEmitter2 } from "events";
 var pendingByCallId = /* @__PURE__ */ new Map();
 var callIdsBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter2();
@@ -1334,7 +1364,7 @@ function onPendingProxyCall(sessionKey2, handler) {
 function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
   const previous = pendingByCallId.get(call.id);
   if (previous) {
-    clearTimeout(previous.timer);
+    if (previous.timer) clearTimeout(previous.timer);
     previous.reject(
       new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
     );
@@ -1346,7 +1376,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     call.input,
     timeoutOverrides
   );
-  const timer = setTimeout(() => {
+  const timer = deadlineMs > PROXY_NO_DEADLINE_MS ? setTimeout(() => {
     const current = pendingByCallId.get(call.id);
     if (!current) return;
     pendingByCallId.delete(call.id);
@@ -1358,7 +1388,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
       toolName: call.toolName,
       deadlineMs
     });
-  }, deadlineMs);
+  }, deadlineMs) : null;
   const pending = {
     sessionKey: sessionKey2,
     toolCallId: call.id,
@@ -1366,6 +1396,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     input: call.input,
     channel: call.channel,
     createdAt: Date.now(),
+    deadlineMs,
     timer,
     resolve: call.resolve,
     reject: call.reject
@@ -1397,12 +1428,27 @@ 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;
   pendingByCallId.delete(toolCallId);
   indexRemove(pending.sessionKey, toolCallId);
-  clearTimeout(pending.timer);
+  if (pending.timer) clearTimeout(pending.timer);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
     sessionKey: pending.sessionKey,
@@ -1416,7 +1462,7 @@ function rejectPendingProxyCallById(toolCallId, error) {
   if (!pending) return false;
   pendingByCallId.delete(toolCallId);
   indexRemove(pending.sessionKey, toolCallId);
-  clearTimeout(pending.timer);
+  if (pending.timer) clearTimeout(pending.timer);
   pending.reject(error);
   log.notice("rejected pending proxy call", {
     sessionKey: pending.sessionKey,
@@ -1832,13 +1878,30 @@ 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();
 var MAX_IDLE_TIMEOUT_MS = 2147483647;
+var DEFAULT_IDLE_PROCESS_TIMEOUT_MS = 0;
+function resolveIdleProcessTimeoutMs(configured) {
+  return configured === void 0 ? DEFAULT_IDLE_PROCESS_TIMEOUT_MS : configured;
+}
 var MAX_ACTIVE_PROCESSES = 16;
 var PROCESS_EXIT_TIMEOUT_MS = 1500;
 var PROCESS_FORCE_EXIT_TIMEOUT_MS = 500;
+var CHILD_EXITED_MESSAGE = "Claude CLI subprocess closed before pending tool calls were resolved";
 function envFlagEnabled(value) {
   if (value === void 0) return false;
   const normalized = value.trim().toLowerCase();
@@ -1877,10 +1940,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;
@@ -1976,6 +2051,11 @@ function scheduleIdleProcessEviction(key, timeoutMs) {
   const timer = setTimeout(() => {
     idleEvictionTimers.delete(key);
     if (activeProcesses.get(key) !== scheduledProcess) return;
+    if (isTurnInFlight(scheduledProcess)) {
+      log.info("idle timer found a turn in flight; re-arming", { sessionKey: key, timeoutMs });
+      scheduleIdleProcessEviction(key, timeoutMs);
+      return;
+    }
     log.info("evicting idle claude process", { sessionKey: key, timeoutMs });
     deleteActiveProcess(key);
   }, timeoutMs);
@@ -1987,9 +2067,44 @@ function detachActiveProcess(key) {
   const ap = activeProcesses.get(key);
   if (!ap) return void 0;
   activeProcesses.delete(key);
-  void ap.proxyServer?.close();
+  if (ap.proxyServer) {
+    void ap.proxyServer.close();
+    rejectAllPendingProxyCallsForSession(key, new Error(SERVER_CLOSED_MESSAGE));
+  }
   return ap;
 }
+function deleteActiveProcessesForSession(sessionID) {
+  if (!sessionID || sessionID === "default") return [];
+  const released = [];
+  for (const [key, ap] of [...activeProcesses]) {
+    const owned = ap.opencodeSessionID === sessionID || describeSessionKey(key).session === sessionID;
+    if (!owned) continue;
+    log.info("releasing claude process for deleted session", { sessionKey: key, sessionID });
+    void deleteActiveProcessAndWait(key);
+    released.push(key);
+  }
+  for (const key of [...claudeSessions.keys()]) {
+    if (describeSessionKey(key).session !== sessionID) continue;
+    deleteClaudeSessionId(key);
+    clearCompression(key);
+    if (!released.includes(key)) released.push(key);
+  }
+  return released;
+}
+function killAllActiveProcesses() {
+  const keys = [...activeProcesses.keys()];
+  for (const key of keys) deleteActiveProcess(key);
+  return keys;
+}
+var processExitCleanupWired = false;
+function ensureProcessExitCleanup() {
+  if (processExitCleanupWired) return false;
+  processExitCleanupWired = true;
+  process.once("exit", () => {
+    killAllActiveProcesses();
+  });
+  return true;
+}
 function deleteActiveProcess(key) {
   const ap = detachActiveProcess(key);
   ap?.proc.kill();
@@ -2095,6 +2210,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     mcpHash,
     systemPromptFile,
     effort,
+    startedAt: Date.now(),
     cliArgs: [...cliArgs],
     unattendedLines: [],
     unattendedDropped: 0
@@ -2118,6 +2234,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();
@@ -2129,6 +2253,12 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     if (ownsSessionKey) {
       cancelIdleProcessEviction(sessionKey2);
       activeProcesses.delete(sessionKey2);
+      if (getPendingProxyCalls(sessionKey2).length > 0) {
+        rejectAllPendingProxyCallsForSession(
+          sessionKey2,
+          new Error(CHILD_EXITED_MESSAGE)
+        );
+      }
     }
     if (ownsSessionKey && code !== 0 && code !== null) {
       log.info("process exited with error, clearing session", {
@@ -2141,6 +2271,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", {
@@ -2168,6 +2299,7 @@ function appendResumeIfNeeded(sessionKey2, cliArgs) {
 function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropicApiKey) {
   const old = activeProcesses.get(sessionKey2);
   if (!old) return void 0;
+  const turnWasInFlight = isTurnInFlight(old);
   activeProcesses.delete(sessionKey2);
   old.proc.removeAllListeners("exit");
   try {
@@ -2187,6 +2319,7 @@ function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropi
   );
   replacement.pendingProxyCompletions = old.pendingProxyCompletions;
   delete old.pendingProxyCompletions;
+  if (turnWasInFlight) noteTurnStarted(replacement);
   return replacement;
 }
 function buildCliArgs(opts) {
@@ -2263,6 +2396,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 +2711,2023 @@ 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 };
+function dirExists(p) {
+  try {
+    return fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
   }
-  if (!Array.isArray(msg.content)) {
-    return { text: "", toolResultCount: 0 };
+}
+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}`
+      );
+    }
+    return parsed;
+  } catch (e) {
+    log.warn("failed to parse opencode config", {
+      file,
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return null;
   }
-  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 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;
     }
   }
-  return { text: lines.join("\n"), toolResultCount };
+  return out;
 }
-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;
+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);
+    }
+    if (opts.stop && current === path3.resolve(opts.stop)) break;
+    const parent = path3.dirname(current);
+    if (parent === current) break;
+    current = parent;
   }
-  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}`);
+  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;
   }
-  if (historyParts.length === 0) {
-    return null;
+}
+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);
   }
-  return historyParts.join("\n\n");
+  return merged;
 }
-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;
+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);
   }
-  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 merged;
 }
-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;
+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);
     }
-    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"
+  for (const dir of walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: [".opencode"],
+    predicate: dirExists
+  })) {
+    push(dir);
+  }
+  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 : "";
     });
-    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.
-
-`
-      });
+  }
+  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;
     }
-  } 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 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;
   }
-  const messages = [];
-  for (let i = prompt.length - 1; i >= 0; i--) {
-    if (prompt[i].role === "assistant") break;
-    messages.unshift(prompt[i]);
+  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;
   }
-  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);
-          }
-        }
-      }
+  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;
+}
+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;
     }
   }
-  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
+  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
   });
 }
-
-// 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 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 };
 }
-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 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
+    };
   }
-  for (const [k, v] of Object.entries(model.capabilities.output)) {
-    if (v) outputMods.push(k);
+  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
-    });
-    return inherited;
-  }
-  if (declared !== inherited) {
-    log.debug("agent effort override", {
-      agent,
-      from: inherited,
-      to: declared
+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;
   }
-  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;
-  }
-  return record;
 }
-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(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)
-        });
+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 records;
 }
-function agentDirectories(home, projectDirectory) {
-  const directories = [];
-  if (projectDirectory) {
-    for (const name of AGENT_DIR_NAMES) {
-      directories.push(path3.join(projectDirectory, ".opencode", name));
-    }
-  }
-  if (home) {
-    for (const name of AGENT_DIR_NAMES) {
-      directories.push(path3.join(home, ".config", "opencode", name));
+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 directories;
 }
 
-// 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() {
+// src/startup-diagnostics.ts
+var cachedPluginVersion;
+function pluginVersion() {
+  if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = fileURLToPath(import.meta.url);
-    const dir = path4.resolve(path4.dirname(here), "..", "skills");
-    return dirExists(dir) ? dir : null;
+    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 {
-    return null;
+    cachedPluginVersion = "unknown";
   }
+  return cachedPluginVersion;
 }
-function dirExists(p) {
-  try {
-    return fs3.statSync(p).isDirectory();
-  } catch {
-    return false;
+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;
 }
-function fileExists(p) {
-  try {
-    return fs3.statSync(p).isFile();
-  } catch {
-    return false;
+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;
+    }
+    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 skillRoots(cwd) {
-  const roots = [];
-  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;
+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;
   }
-  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 void 0;
 }
-function collectSkills(root, claimed, found) {
-  let entries;
-  try {
-    entries = fs3.readdirSync(root, { withFileTypes: true });
-  } catch {
-    return;
+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);
   }
-  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 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 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);
+var logged = false;
+var lastProviders = {};
+var lastOpencodeVersion;
+function lastDiagnosticsProviders() {
+  return lastProviders;
 }
-function discoverBundledSkills() {
-  const root = bundledSkillsDir();
-  if (!root) return [];
-  const found = [];
-  collectSkills(root, /* @__PURE__ */ new Set(), found);
-  return found.sort(byName);
+function lastKnownOpencodeVersion() {
+  return lastOpencodeVersion;
 }
-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;
+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)
+      });
+    }
+  })();
 }
-function linkSkill(source, target) {
-  try {
-    fs3.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
-    return;
-  } catch {
-    fs3.cpSync(source, target, { recursive: true, dereference: true });
-  }
+
+// 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);
 }
-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));
+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);
     }
-  } catch (err) {
-    log.warn("failed to stage opencode skill plugin dir", {
-      root,
-      error: err instanceof Error ? err.message : String(err)
-    });
+    text = parts.join("\n");
+  } else {
     return null;
   }
-  return root;
+  const match = new RegExp(`^/${DOCTOR_COMMAND}(?:\\s+([\\s\\S]*))?$`).exec(
+    text.replace(SYSTEM_REMINDER_BLOCK2, "").trim()
+  );
+  return match ? { rest: (match[1] ?? "").trim() } : null;
 }
-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 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"} |`
+      );
+    }
   }
-  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];
+  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) {
+      const deadline = call.deadlineMs > 0 ? formatAge(call.deadlineMs) : "none";
+      lines.push(
+        `| ${call.toolName} | \`${call.toolCallId}\` | ${formatAge(call.ageMs)} | ${deadline} |`
+      );
+    }
+  }
+  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");
 }
-
-// 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) {
+async function checkProxyAuth(url, fetchImpl = fetch, timeoutMs = 3e3) {
+  let authority;
   try {
-    return fs4.statSync(p).isFile();
+    authority = new URL(url).host;
   } catch {
-    return false;
+    return { status: "skipped" };
   }
-}
-function dirExists2(p) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
-    return fs4.statSync(p).isDirectory();
-  } catch {
-    return false;
+    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 readAndParse(file) {
+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 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)
+    });
+  }
+  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
+  };
+}
+async function buildDoctorReport(options) {
   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}`
-      );
-    }
-    return parsed;
-  } catch (e) {
-    log.warn("failed to parse opencode config", {
-      file,
-      error: e instanceof Error ? e.message : String(e)
+    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 null;
+    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}`;
   }
 }
-function isPlainObject(x) {
-  return typeof x === "object" && x !== null && !Array.isArray(x);
+
+// 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 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);
+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
+  };
+}
+
+// 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 stripPluginNotes(content) {
+  if (!Array.isArray(content)) return content;
+  const kept = content.filter((part) => !isPluginNote(part));
+  return kept.length === content.length ? content : kept;
+}
+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;
+    }
+    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 {
-      out[k] = v;
+      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;
   }
-  return out;
+  if (!resolvedMediaType || !SUPPORTED_IMAGE_TYPES.has(resolvedMediaType)) {
+    log.warn("unsupported media type for Claude image block, skipping", {
+      mediaType: resolvedMediaType
+    });
+    return null;
+  }
+  return {
+    type: "image",
+    source: { type: "base64", media_type: resolvedMediaType, data: base64 }
+  };
+}
+function getToolResultText(part) {
+  const value = part.output ?? part.result;
+  if (typeof value === "string") {
+    return value;
+  }
+  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);
+  }
+}
+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 {
+    raw = typeof input === "string" ? input : JSON.stringify(input);
+  } catch {
+    raw = String(input);
+  }
+  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;
+    }
+  }
+  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}`);
+    }
+  }
+  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 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;
+
+// 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 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 getAgentRegistry() {
+  return registry;
 }
-function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path5.join(os3.homedir(), ".config");
-  return path5.join(xdg, "opencode");
+function setDefaultSubagentModel(model) {
+  defaultSubagentModel = model?.trim() || void 0;
 }
-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 getDefaultSubagentModel() {
+  return defaultSubagentModel;
 }
-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 accountMarker(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? "" : modelId.slice(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);
-  }
-  const home = os3.homedir();
-  if (home) {
-    const homeDot = path5.join(home, ".opencode");
-    if (dirExists2(homeDot)) push(homeDot);
-  }
-  const envDir = process.env.OPENCODE_CONFIG_DIR;
-  if (envDir && dirExists2(envDir)) push(envDir);
-  return dirs;
+function withoutAccountMarker(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? modelId : modelId.slice(0, at);
 }
-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 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;
   }
-  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;
+  const resolved = `${base}${accountMarker(modelId)}`;
+  if (resolved !== modelId) {
+    log.debug("agent model override", { agent, from: modelId, to: resolved });
   }
-  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 resolved;
 }
-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 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 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);
-    }
+  if (declared !== inherited) {
+    log.debug("agent effort override", {
+      agent,
+      from: inherited,
+      to: declared
+    });
   }
-  return finishBridge({
-    servers,
-    bridgedServerNames,
-    allEnabledServerNames,
-    hash,
-    excludeServers
-  });
+  return declared;
 }
-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));
+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;
   }
-  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);
+  return record;
+}
+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)
+        });
+      }
     }
   }
-  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" };
+  return records;
+}
+function agentDirectories(home, projectDirectory) {
+  const directories = [];
+  if (projectDirectory) {
+    for (const name of AGENT_DIR_NAMES) {
+      directories.push(path5.join(projectDirectory, ".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);
+  if (home) {
+    for (const name of AGENT_DIR_NAMES) {
+      directories.push(path5.join(home, ".config", "opencode", 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;
+function fileExists2(p) {
+  try {
+    return fs5.statSync(p).isFile();
+  } catch {
+    return false;
+  }
 }
-var opencodeProjectDirectory;
-function setOpencodeProjectDirectory(dir) {
-  opencodeProjectDirectory = dir;
+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 getOpencodeProjectDirectory() {
-  return opencodeProjectDirectory;
+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 isUsableDirectory(d) {
-  return typeof d === "string" && d.length > 1 && d !== "/";
+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);
 }
-function resolveSpawnCwdFrom(configured, live, captured, sessionDir) {
-  if (configured) return configured;
-  if (isUsableDirectory(sessionDir)) return sessionDir;
-  if (isUsableDirectory(live)) return live;
-  return captured ?? live;
+function discoverBundledSkills() {
+  const root = bundledSkillsDir();
+  if (!root) return [];
+  const found = [];
+  collectSkills(root, /* @__PURE__ */ new Set(), 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 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 fetchSessionDirectory(sessionID) {
-  if (!sessionID || sessionID === "default") return void 0;
-  const client = opencodeClient;
-  if (!client?.session?.get) return void 0;
+function linkSkill(source, target) {
   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;
+    fs5.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
+    return;
+  } catch {
+    fs5.cpSync(source, target, { recursive: true, dereference: true });
   }
 }
-async function getRuntimeMcpStatus() {
-  const client = opencodeClient;
-  if (!client?.mcp?.status) return void 0;
+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 {
-    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;
-      }
+    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 MCP runtime status", {
+    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 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;
+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 +4736,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 +4750,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 +4786,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 +4913,7 @@ var ClaudeSession = class {
   }
   readRawLines() {
     try {
-      return fs5.readFileSync(this.jsonlPath, "utf8").split("\n");
+      return fs6.readFileSync(this.jsonlPath, "utf8").split("\n");
     } catch {
       return [];
     }
@@ -4314,7 +5141,7 @@ ${text}`
   }
   return parts.join("\n\n");
 }
-function spawnInteractiveProcess(opts) {
+function interactiveExtraArgs(opts) {
   const extraArgs = [];
   if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
     extraArgs.push(
@@ -4323,6 +5150,9 @@ function spawnInteractiveProcess(opts) {
       "--strict-mcp-config"
     );
   }
+  for (const dir of opts.pluginDirs ?? []) {
+    extraArgs.push("--plugin-dir", dir);
+  }
   const flagSettings = {};
   if (opts.permissionsAllow && opts.permissionsAllow.length > 0) {
     flagSettings.permissions = { allow: opts.permissionsAllow };
@@ -4343,6 +5173,10 @@ function spawnInteractiveProcess(opts) {
   if (opts.systemPromptFile) {
     extraArgs.push("--append-system-prompt-file", opts.systemPromptFile);
   }
+  return extraArgs;
+}
+function spawnInteractiveProcess(opts) {
+  const extraArgs = interactiveExtraArgs(opts);
   const session = new ClaudeSession({
     cwd: opts.cwd,
     cliPath: opts.cliPath,
@@ -4464,11 +5298,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,6 +5366,7 @@ 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;
@@ -4693,7 +5528,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;
@@ -4702,9 +5537,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;
   }
@@ -4788,8 +5623,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);
@@ -4800,7 +5635,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;
@@ -5528,6 +6363,11 @@ var ClaudeCodeLanguageModel = class {
       { compressEnabled: false, compressionSummary: getCompressionSummary(sk) }
     );
     const { model: spawnModelId, fast: fastMode } = parseModelId(effectiveModelId);
+    const skillPluginDirs = await resolveSkillPluginDirs({
+      cwd,
+      cliPath: this.config.cliPath,
+      enabled: this.config.bridgeOpencodeSkills === true
+    });
     const cliArgs = buildCliArgs({
       sessionKey: sk,
       skipPermissions: this.config.skipPermissions !== false,
@@ -5538,6 +6378,7 @@ var ClaudeCodeLanguageModel = class {
       strictMcpConfig: this.config.strictMcpConfig,
       disallowedTools: this.config.webSearch === "disabled" ? ["WebSearch"] : void 0,
       appendSystemPromptFile: systemPromptFile,
+      pluginDirs: skillPluginDirs,
       ...this.thinkingCliOptions(),
       fastMode,
       cliVersion
@@ -5596,6 +6437,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) {
@@ -5705,8 +6553,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,
@@ -5854,6 +6715,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);
@@ -6084,6 +6978,11 @@ ${plan}
                   "interactiveBypass ignored: Claude Code prompts for bypassPermissions confirmation in the interactive TUI"
                 );
               }
+              const skillPluginDirs = await resolveSkillPluginDirs({
+                cwd,
+                cliPath,
+                enabled: self.config.bridgeOpencodeSkills === true
+              });
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -6091,6 +6990,7 @@ ${plan}
                 model: spawnModelId,
                 fastMode,
                 mcpConfigPaths: mcp.paths,
+                pluginDirs: skillPluginDirs,
                 permissionsAllow: allow,
                 systemPromptFile,
                 ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
@@ -6422,6 +7322,7 @@ ${plan}
             if (entries.length === 0) return false;
             endTextBlock();
             watchdogMessage = makeLateProxyResultMessage(entries);
+            if (activeProcess) noteTurnStarted(activeProcess);
             proc.stdin.write(watchdogMessage + "\n");
             for (const { call } of entries) pending.delete(call.toolCallId);
             log.warn("delivering proxy results after interrupted continuation", {
@@ -6442,6 +7343,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;
@@ -6664,11 +7566,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" ? {
@@ -6681,7 +7584,10 @@ ${plan}
             controllerClosed = true;
             cleanupTurn();
             if (!useInteractive && !compactionMode) {
-              scheduleIdleProcessEviction(sk, self.config.idleProcessTimeoutMs);
+              scheduleIdleProcessEviction(
+                sk,
+                resolveIdleProcessTimeoutMs(self.config.idleProcessTimeoutMs)
+              );
             }
             try {
               controller.close();
@@ -6720,6 +7626,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;
@@ -7158,12 +8082,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",
@@ -7176,7 +8100,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,
@@ -7190,6 +8114,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,
@@ -7197,14 +8122,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);
                     }
@@ -7227,18 +8154,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;
@@ -7290,24 +8248,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 = () => {
@@ -7389,7 +8382,7 @@ ${plan}
                       if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
                       if (msg.is_error && msg.result) text = msg.result;
                     }
-                    if (text) controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: text });
+                    if (text) controller.enqueue({ type: "text-delta", id: currentTextId ?? startTextBlock(), delta: text });
                   } catch {
                   }
                 }
@@ -7446,9 +8439,25 @@ ${plan}
           });
           proc.on("error", procErrorHandler);
           if (options.abortSignal) {
+            const releaseAbandonedProxyCalls = (reason) => {
+              if (drainBuffer.length === 0 && getPendingProxyCalls(sk).length === 0) return;
+              rejectAllPendingProxyCallsForSession(sk, new Error(reason));
+              drainBuffer.length = 0;
+            };
             options.abortSignal.addEventListener("abort", () => {
               autoContinueState.aborted = true;
-              if (turnCompleted || controllerClosed) return;
+              if (turnCompleted || controllerClosed) {
+                if (activeProcess && activeProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
+                  log.info("abort between proxy tool boundaries; releasing pending calls", { sk });
+                  void interruptTurn(activeProcess).then((idle) => {
+                    log.info("interrupt sent for aborted turn", { sk, idle });
+                  });
+                  releaseAbandonedProxyCalls(
+                    "Provider stream was aborted while opencode was running its proxy tool calls"
+                  );
+                }
+                return;
+              }
               if (activeProcess) {
                 void interruptTurn(activeProcess).then((idle) => {
                   log.info("interrupt sent for aborted turn", { sk, idle });
@@ -7459,15 +8468,9 @@ ${plan}
                   "abort signal received before content, closing stream immediately",
                   { cwd }
                 );
-                if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
-                  rejectAllPendingProxyCallsForSession(
-                    sk,
-                    new Error(
-                      "Provider stream was aborted before pending proxy calls were emitted"
-                    )
-                  );
-                  drainBuffer.length = 0;
-                }
+                releaseAbandonedProxyCalls(
+                  "Provider stream was aborted before pending proxy calls were emitted"
+                );
                 controllerClosed = true;
                 cleanupTurn();
                 try {
@@ -7480,6 +8483,9 @@ ${plan}
                 "abort signal received mid-turn, starting grace period",
                 { cwd }
               );
+              releaseAbandonedProxyCalls(
+                "Provider stream was aborted while proxy tool calls were pending"
+              );
               startResultFallback(5e3);
             });
           }
@@ -7573,7 +8579,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 = [
@@ -7611,7 +8617,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;
 }
@@ -7643,8 +8649,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);
@@ -7655,8 +8661,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", {
@@ -7671,11 +8677,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
@@ -7716,34 +8722,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(
@@ -7755,7 +8761,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;
@@ -7780,7 +8786,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 {
@@ -7788,11 +8794,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;
   }
@@ -7808,10 +8814,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");
@@ -7824,131 +8830,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;
@@ -7975,6 +8856,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;
@@ -8045,6 +8935,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,
@@ -8234,8 +9125,16 @@ async function buildAgentRegistry(config) {
     defaultSubagentModel: getDefaultSubagentModel()
   });
 }
+function extractDeletedSessionId(event) {
+  const payload = event?.payload ?? event;
+  if (!payload || payload.type !== "session.deleted") return void 0;
+  const properties = payload.properties;
+  const id = properties?.info?.id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
 var server = async (input) => {
   cleanupStaleUnscopedInstall();
+  ensureProcessExitCleanup();
   const opencodeVersion = pickOpencodeVersion(input);
   if (input && typeof input === "object" && "client" in input) {
     setOpencodeClient(input.client);
@@ -8244,6 +9143,7 @@ var server = async (input) => {
   return {
     config: async (config) => {
       if (registerSideQuestionCommand(config)) ownsSideQuestionCommand = true;
+      registerDoctorCommand(config);
       registerBundledSkillPath(config);
       config.provider ??= {};
       await buildAgentRegistry(config);
@@ -8269,10 +9169,21 @@ var server = async (input) => {
         opencodeVersion
       );
     },
-    // No `event` hook: MCP config drift is detected at turn start by the
-    // hot-reload check in `claude-code-language-model.ts`, which respawns
-    // claude safely between turns. Eviction on `global.disposed` would kill
-    // an in-flight stream and abort the user's current turn.
+    // Only `session.deleted` is acted on. MCP config drift is still detected
+    // at turn start by the hot-reload check in `claude-code-language-model.ts`,
+    // which respawns claude safely between turns, and eviction on
+    // `global.disposed` would kill an in-flight stream and abort the user's
+    // current turn. A deleted session has no turn left to abort, and its
+    // `claude` child would otherwise linger until the idle timer or LRU
+    // pressure took it, with its session id kept for a resume that never comes.
+    event: async ({ event }) => {
+      const sessionID = extractDeletedSessionId(event);
+      if (!sessionID) return;
+      const released = deleteActiveProcessesForSession(sessionID);
+      if (released.length > 0) {
+        log.info("released claude state for deleted session", { sessionID, released });
+      }
+    },
     provider: {
       id: PROVIDER_ID2,
       models: async (provider) => defaultModelsForProvider(provider.models)
@@ -8327,8 +9238,10 @@ export {
   createClaudeCode,
   index_default as default,
   defaultModels,
+  extractDeletedSessionId,
   getAgentRegistry,
   getDefaultSubagentModel,
+  registerDoctorCommand,
   registerSideQuestionCommand,
   resolveAgentModel,
   warnIfPlanModeCannotExit