@khalilgharbaoui/opencode-claude-code-plugin 0.33.2 → 0.34.1

package/dist/index.js

@@ -1306,6 +1306,34 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var cache = /* @__PURE__ */ new Map();
+var PROBE_TIMEOUT_MS = 5e3;
+var probeTimeoutMs = PROBE_TIMEOUT_MS;
+var MAX_DEADLINE_REPROBES = 2;
+var deadlineReprobes = /* @__PURE__ */ new Map();
+function killedByDeadline(error) {
+  const failure = error;
+  return failure?.killed === true && typeof failure.signal === "string" && typeof failure.code !== "string";
+}
+function forgetDeadlineKill(entries, key, probe, killed) {
+  void probe.then(() => {
+    if (entries.get(key) !== probe) return;
+    if (!killed()) {
+      deadlineReprobes.delete(key);
+      return;
+    }
+    const reprobes = deadlineReprobes.get(key) ?? 0;
+    if (reprobes >= MAX_DEADLINE_REPROBES) {
+      log.warn("claude kept missing the probe deadline; keeping the conservative answer for this process", {
+        key: key.replace("\0", " "),
+        deadlineMs: probeTimeoutMs,
+        attempts: reprobes + 1
+      });
+      return;
+    }
+    deadlineReprobes.set(key, reprobes + 1);
+    entries.delete(key);
+  });
+}
 var CLI_HYGIENE_ENV_VARS = [
   "DISABLE_AUTOUPDATER",
   "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"
@@ -1320,10 +1348,11 @@ function cliHygieneEnv(inherited = process.env) {
 function detectCliVersion(cliPath) {
   const cached = cache.get(cliPath);
   if (cached) return cached;
+  let deadlineKill = false;
   const promise = (async () => {
     try {
       const { stdout } = await execFileAsync(cliPath, ["--version"], {
-        timeout: 5e3
+        timeout: probeTimeoutMs
       });
       const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout.trim());
       if (!match) {
@@ -1345,14 +1374,17 @@ function detectCliVersion(cliPath) {
       }
       return v;
     } catch (err) {
+      deadlineKill = killedByDeadline(err);
       log.warn("failed to detect claude cli version", {
         cliPath,
-        error: err instanceof Error ? err.message : String(err)
+        error: err instanceof Error ? err.message : String(err),
+        deadlineKill
       });
       return null;
     }
   })();
   cache.set(cliPath, promise);
+  forgetDeadlineKill(cache, cliPath, promise, () => deadlineKill);
   return promise;
 }
 function gte(v, target) {
@@ -1389,10 +1421,11 @@ function detectCliSupportsFlag(cliPath, flag) {
   const key = `${cliPath}\0${flag}`;
   const cached = flagSupport.get(key);
   if (cached) return cached;
+  let deadlineKill = false;
   const promise = (async () => {
     try {
       const execution = execFileAsync(cliPath, ["--help"], {
-        timeout: 5e3,
+        timeout: probeTimeoutMs,
         killSignal: "SIGKILL",
         maxBuffer: 4 * 1024 * 1024
       });
@@ -1400,15 +1433,18 @@ function detectCliSupportsFlag(cliPath, flag) {
       const { stdout } = await execution;
       return stdout.includes(flag);
     } catch (err) {
+      deadlineKill = killedByDeadline(err);
       log.warn("failed to probe claude cli flag support", {
         cliPath,
         flag,
-        error: err instanceof Error ? err.message : String(err)
+        error: err instanceof Error ? err.message : String(err),
+        deadlineKill
       });
       return false;
     }
   })();
   flagSupport.set(key, promise);
+  forgetDeadlineKill(flagSupport, key, promise, () => deadlineKill);
   return promise;
 }
 
@@ -2945,2063 +2981,2109 @@ function clearCompression(sessionKey2) {
   compressions.delete(sessionKey2);
 }
 
-// src/runtime-status.ts
-var opencodeClient = null;
-function setOpencodeClient(client) {
-  if (client && typeof client === "object") {
-    opencodeClient = client;
-  }
-}
-function getOpencodeClient() {
-  return opencodeClient;
-}
-var opencodeProjectDirectory;
-function setOpencodeProjectDirectory(dir) {
-  opencodeProjectDirectory = dir;
-}
-function getOpencodeProjectDirectory() {
-  return opencodeProjectDirectory;
-}
-function isUsableDirectory(d) {
-  return typeof d === "string" && d.length > 1 && d !== "/";
-}
-function resolveSpawnCwdFrom(configured, live, captured, sessionDir) {
-  if (configured) return configured;
-  if (isUsableDirectory(sessionDir)) return sessionDir;
-  if (isUsableDirectory(live)) return live;
-  return captured ?? live;
-}
-async function resolveSpawnCwdForSession(configured, sessionID) {
-  if (configured) return configured;
-  const sessionDir = sessionID ? await fetchSessionDirectory(sessionID) : void 0;
-  return resolveSpawnCwdFrom(
-    configured,
-    process.cwd(),
-    opencodeProjectDirectory,
-    sessionDir
-  );
-}
-async function fetchSessionDirectory(sessionID) {
-  if (!sessionID || sessionID === "default") return void 0;
-  const client = opencodeClient;
-  if (!client?.session?.get) return void 0;
+// src/mcp-bridge.ts
+import * as fs3 from "fs";
+import * as path4 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 {
-    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 fs3.statSync(p).isFile();
+  } catch {
+    return false;
   }
 }
-async function fetchSessionParentId(sessionID) {
-  if (!sessionID || sessionID === "default") return void 0;
-  const client = opencodeClient;
-  if (!client?.session?.get) return void 0;
+function dirExists(p) {
   try {
-    const res = await client.session.get({ path: { id: sessionID } });
-    const data = res.data;
-    if (!data || typeof data !== "object") return void 0;
-    const parentID = data.parentID;
-    return typeof parentID === "string" && parentID.length > 0 ? parentID : void 0;
-  } catch (err) {
-    log.warn("failed to fetch opencode session parent", {
-      sessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return void 0;
+    return fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
   }
 }
-async function fetchSessionRunState(sessionID) {
-  if (!sessionID || sessionID === "default") return "unknown";
-  const status = opencodeClient?.session?.status;
-  if (!status) return "unknown";
+function readAndParse(file) {
   try {
-    const res = await status.call(opencodeClient.session);
-    const data = res.data;
-    if (!data || typeof data !== "object") return "unknown";
-    const entry = data[sessionID];
-    if (!entry || typeof entry !== "object") return "idle";
-    const type = entry.type;
-    return type === "idle" ? "idle" : "busy";
-  } catch (err) {
-    log.debug("failed to read opencode session status", {
-      sessionID,
-      error: err instanceof Error ? err.message : String(err)
+    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 "unknown";
+    return null;
   }
 }
-async function settleSessionRunState(sessionID, options = {}) {
-  const pollMs = options.pollMs ?? 150;
-  const windowMs = options.windowMs ?? 1500;
-  const started = Date.now();
-  let last = "unknown";
-  for (; ; ) {
-    const state = await fetchSessionRunState(sessionID);
-    if (state === "busy") return "busy";
-    if (state !== "unknown") last = state;
-    if (Date.now() - started >= windowMs) return last;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
-  }
+function isPlainObject(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
 }
-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;
-      }
+function deepMerge(target, source) {
+  const out = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    if (v === void 0) continue;
+    const existing = out[k];
+    if (isPlainObject(existing) && isPlainObject(v)) {
+      out[k] = deepMerge(existing, v);
+    } else {
+      out[k] = v;
     }
-    return out;
-  } catch (err) {
-    log.warn("failed to fetch opencode MCP runtime status", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return void 0;
   }
+  return out;
 }
-async function fetchOpencodeToolList(provider, model, directory) {
-  const client = opencodeClient;
-  if (!client?.tool?.list) return void 0;
-  try {
-    const res = await client.tool.list({
-      query: { provider, model, ...directory ? { directory } : {} }
-    });
-    const data = res.data;
-    if (!Array.isArray(data)) return void 0;
-    const out = [];
-    for (const entry of data) {
-      if (!entry || typeof entry !== "object") continue;
-      const e = entry;
-      const id = typeof e.id === "string" ? e.id : null;
-      const description = typeof e.description === "string" ? e.description : "";
-      const parameters = e.parameters && typeof e.parameters === "object" ? e.parameters : {};
-      if (!id) continue;
-      out.push({ id, description, parameters });
+function walkUp(opts) {
+  const out = [];
+  let current = path4.resolve(opts.start);
+  while (true) {
+    for (const target of opts.targets) {
+      const candidate = path4.join(current, target);
+      if (opts.predicate(candidate)) out.push(candidate);
     }
-    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;
+    if (opts.stop && current === path4.resolve(opts.stop)) break;
+    const parent = path4.dirname(current);
+    if (parent === current) break;
+    current = parent;
   }
+  return out;
 }
-async function fetchSessionReplies(sessionID) {
-  if (!sessionID || sessionID === "default") return void 0;
-  const client = opencodeClient;
-  if (!client?.session?.messages) return void 0;
-  try {
-    const res = await client.session.messages({ path: { id: sessionID } });
-    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 info = entry.info;
-      if (!info || typeof info !== "object") continue;
-      const record = info;
-      const parts = entry.parts;
-      const text = Array.isArray(parts) ? parts.flatMap((part) => {
-        if (!part || typeof part !== "object") return [];
-        const p = part;
-        if (p.type !== "text" || typeof p.text !== "string") return [];
-        return p.synthetic === true ? [] : [p.text];
-      }).join("\n").trim() : "";
-      const error = record.error;
-      const message = error && typeof error === "object" ? typeof error.data?.message === "string" ? error.data.message : typeof error.name === "string" ? error.name : void 0 : void 0;
-      out.push({
-        role: typeof record.role === "string" ? record.role : "",
-        completed: typeof record.time?.completed === "number",
-        error: message,
-        text
-      });
+function detectWorktree(cwd) {
+  const override = process.env.OPENCODE_WORKTREE;
+  if (override) return path4.resolve(override);
+  let current = path4.resolve(cwd);
+  while (true) {
+    const gitPath = path4.join(current, ".git");
+    try {
+      if (fs3.existsSync(gitPath)) return current;
+    } catch {
     }
-    return out;
-  } catch (err) {
-    log.warn("failed to fetch opencode session messages", {
-      sessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return void 0;
+    const parent = path4.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
   }
 }
-async function abortSession(sessionID) {
-  if (!sessionID || sessionID === "default") return false;
-  const client = opencodeClient;
-  if (!client?.session?.abort) return false;
-  try {
-    const res = await client.session.abort({ path: { id: sessionID } });
-    return res.data !== false;
-  } catch (err) {
-    log.warn("failed to abort opencode session", {
-      sessionID,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return false;
-  }
+function globalConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME ?? path4.join(os2.homedir(), ".config");
+  return path4.join(xdg, "opencode");
 }
-
-// src/background-tasks.ts
-var TASK_STATUS_TOOL_NAME = "task_status";
-var TASK_CANCEL_TOOL_NAME = "task_cancel";
-var MAX_LEDGERS = 32;
-var MAX_COLLECTED_PER_SESSION = 64;
-var collected = /* @__PURE__ */ new Map();
-var cancelled = /* @__PURE__ */ new Map();
-function ledgerIn(ledgers2, sessionKey2) {
-  let ids = ledgers2.get(sessionKey2);
-  if (!ids) {
-    ids = /* @__PURE__ */ new Set();
-    ledgers2.set(sessionKey2, ids);
-    while (ledgers2.size > MAX_LEDGERS) {
-      const oldest = ledgers2.keys().next();
-      if (oldest.done) break;
-      ledgers2.delete(oldest.value);
-    }
+function loadGlobalConfig(hostApi = "v1") {
+  const dir = globalConfigDir();
+  let merged = {};
+  for (const name of FILE_NAMES.slice().reverse()) {
+    const file = path4.join(dir, name);
+    if (!fileExists(file)) continue;
+    const parsed = readAndParse(file);
+    if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
   }
-  return ids;
+  return merged;
 }
-function mark(ledgers2, sessionKey2, taskId) {
-  const ids = ledgerIn(ledgers2, sessionKey2);
-  ids.add(taskId);
-  while (ids.size > MAX_COLLECTED_PER_SESSION) {
-    const oldest = ids.values().next();
-    if (oldest.done) break;
-    ids.delete(oldest.value);
+function loadProjectFilesInDir(dir, hostApi = "v1") {
+  let merged = {};
+  for (const name of PROJECT_FILE_NAMES) {
+    const file = path4.join(dir, name);
+    if (!fileExists(file)) continue;
+    const parsed = readAndParse(file);
+    if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
   }
+  return merged;
 }
-function markCollected(sessionKey2, taskId) {
-  mark(collected, sessionKey2, taskId);
-}
-function hasCollectedBackgroundTask(sessionKey2, taskId) {
-  return collected.get(sessionKey2)?.has(taskId) === true;
-}
-function clearBackgroundTasks(sessionKey2) {
-  collected.delete(sessionKey2);
-  cancelled.delete(sessionKey2);
-}
-var lastGate;
-function recordBackgroundSubagentGate(gate, now = Date.now()) {
-  lastGate = { ...gate, at: now };
-}
-function snapshotBackgroundSubagentGate() {
-  return lastGate ? { ...lastGate } : void 0;
-}
-function snapshotBackgroundTasks() {
-  const keys = /* @__PURE__ */ new Set([...collected.keys(), ...cancelled.keys()]);
-  return [...keys].map((sessionKey2) => ({
-    sessionKey: sessionKey2,
-    collected: [...collected.get(sessionKey2) ?? []],
-    cancelled: [...cancelled.get(sessionKey2) ?? []]
-  }));
-}
-function readTaskId(input) {
-  const raw = input.task_id ?? input.taskId ?? input.sessionID;
-  if (typeof raw !== "string") return null;
-  const id = raw.trim();
-  return id.length > 0 ? id : null;
-}
-var MISSING_TASK_ID = 'task_id is required: pass the background subagent\'s own opencode session id, from the `<task id="...">` envelope on opencode 1.x or the `sessionID` the background dispatch reported on opencode 2.';
-async function guardParent(taskId, callerSessionId) {
-  if (!callerSessionId || callerSessionId === "default") {
-    return `Cannot check that task_id ${taskId} belongs to this conversation (this turn has no opencode session id), so it is not inspected or cancelled.`;
+function dotOpencodeDirs(cwd, worktree) {
+  const dirs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    const abs = path4.resolve(p);
+    if (!seen.has(abs) && dirExists(abs)) {
+      seen.add(abs);
+      dirs.push(abs);
+    }
+  };
+  for (const dir of walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: [".opencode"],
+    predicate: dirExists
+  })) {
+    push(dir);
   }
-  const parent = await fetchSessionParentId(taskId);
-  if (parent === callerSessionId) return null;
-  return `task_id ${taskId} is not a subagent of this conversation, so it cannot be inspected or cancelled from here. Use the session id from a background dispatch this conversation itself made.`;
-}
-function isBackgroundTaskRunning(runState, replies) {
-  if (runState === "busy") return true;
-  if (runState === "idle") return false;
-  const reply = lastAssistantReply(replies);
-  return reply !== void 0 && !reply.completed && reply.error === void 0;
+  const home = os2.homedir();
+  if (home) {
+    const homeDot = path4.join(home, ".opencode");
+    if (dirExists(homeDot)) push(homeDot);
+  }
+  const envDir = process.env.OPENCODE_CONFIG_DIR;
+  if (envDir && dirExists(envDir)) push(envDir);
+  return dirs;
 }
-function lastAssistantReply(replies) {
-  for (let index = replies.length - 1; index >= 0; index--) {
-    const reply = replies[index];
-    if (reply.role === "assistant") return reply;
+function substituteEnvPlaceholders(source) {
+  const out = {};
+  for (const [k, v] of Object.entries(source)) {
+    if (typeof v !== "string") continue;
+    out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
+      const resolved = process.env[name];
+      return typeof resolved === "string" ? resolved : "";
+    });
   }
-  return void 0;
+  return out;
 }
-async function collectBackgroundTask(input, options) {
-  const taskId = readTaskId(input);
-  if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
-  const refused = await guardParent(taskId, options.callerSessionId);
-  if (refused) return { kind: "error", message: refused };
-  const replies = await fetchSessionReplies(taskId);
-  if (replies === void 0) {
-    return {
-      kind: "error",
-      message: `Could not read background task ${taskId} from opencode. It may have been deleted, or this opencode build does not expose the session transcript. The completion notification is still the primary delivery path: end your turn and wait for it.`
+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;
   }
-  const runState = await fetchSessionRunState(taskId);
-  if (isBackgroundTaskRunning(runState, replies)) {
-    return {
-      kind: "text",
-      text: `<task id="${taskId}" state="running">
-Still working. Do not call this again in a loop: when it finishes opencode delivers the result to this conversation on its own. End your turn, or work on something that does not overlap it.
-</task>`
+  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 reply = lastAssistantReply(replies);
-  if (!reply) {
-    return {
-      kind: "text",
-      text: `<task id="${taskId}" state="unknown">
-opencode has no assistant reply for this task yet and it is not running. It may still be starting up.
-</task>`
+  log.warn("skipping MCP server with unknown type", {
+    name,
+    type: type ?? null
+  });
+  return null;
+}
+function extractMcpBlock(config) {
+  const mcp = config.mcp;
+  if (!isPlainObject(mcp)) return {};
+  if ("servers" in mcp && !isPlainObject(mcp.servers)) return {};
+  const native = isPlainObject(mcp.servers) && typeof mcp.servers.type !== "string" && typeof mcp.servers.enabled !== "boolean" && typeof mcp.servers.disabled !== "boolean";
+  const block = native ? mcp.servers : mcp;
+  return Object.fromEntries(
+    Object.entries(block).filter(([name, spec]) => isPlainObject(spec) && (native || name !== "timeout" || typeof spec.type === "string")).map(([name, spec]) => {
+      const server2 = spec;
+      return [name, {
+        ...server2,
+        ...typeof server2.disabled === "boolean" ? { enabled: !server2.disabled } : {}
+      }];
+    })
+  );
+}
+function mergeConfigLayer(target, source, hostApi) {
+  const merged = deepMerge(target, source);
+  if (hostApi === "v2" && isPlainObject(source.mcp)) {
+    merged.mcp = {
+      ...isPlainObject(merged.mcp) ? merged.mcp : {},
+      servers: { ...extractMcpBlock(target), ...extractMcpBlock(source) }
     };
   }
-  if (reply.error) {
-    markCollected(options.sessionKey, taskId);
-    return {
-      kind: "text",
-      isError: true,
-      text: `<task id="${taskId}" state="error">
-${reply.error}
-</task>`
-    };
+  return merged;
+}
+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 (hasCollectedBackgroundTask(options.sessionKey, taskId)) {
-    return {
-      kind: "text",
-      text: `<task id="${taskId}" state="completed">
-Already delivered to this conversation earlier (by this tool or by opencode's completion notification). Scroll back for the result rather than collecting it again.
-</task>`
-    };
+  return out;
+}
+var MCP_PENDING_STATUS = "pending";
+function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers, hostApi = "v1") {
+  const {
+    servers: merged,
+    enabledServerNames: allEnabledServerNames,
+    hash
+  } = mergeOpencodeMcp(cwd, runtimeStatus, hostApi);
+  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);
+    }
   }
-  markCollected(options.sessionKey, taskId);
-  log.info("collected background subagent result", {
-    sessionKey: options.sessionKey,
-    taskId,
-    textLength: reply.text.length
+  return finishBridge({
+    servers,
+    bridgedServerNames,
+    allEnabledServerNames,
+    hash,
+    excludeServers
   });
-  return {
-    kind: "text",
-    text: `<task id="${taskId}" state="completed">
-<task_result>
-${reply.text || "(the subagent produced no text)"}
-</task_result>
-</task>`
-  };
 }
-async function cancelBackgroundTask(input, options) {
-  const taskId = readTaskId(input);
-  if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
-  const refused = await guardParent(taskId, options.callerSessionId);
-  if (refused) return { kind: "error", message: refused };
-  const running = isBackgroundTaskRunning(
-    await fetchSessionRunState(taskId),
-    await fetchSessionReplies(taskId) ?? []
-  );
-  const aborted = await abortSession(taskId);
-  if (!aborted) {
-    return {
-      kind: "error",
-      message: `Could not cancel background task ${taskId}: opencode did not accept the abort. It may have already finished, or this opencode build does not expose session abort.`
-    };
+function opencodeConfigLayers(cwd, hostApi = "v1") {
+  const worktree = hostApi === "v2" ? void 0 : detectWorktree(cwd);
+  const layers = [];
+  layers.push(loadGlobalConfig(hostApi));
+  const explicitConfig = process.env.OPENCODE_CONFIG;
+  if (explicitConfig && fileExists(explicitConfig)) {
+    const parsed = readAndParse(explicitConfig);
+    if (parsed) layers.push(parsed);
   }
-  collected.get(options.sessionKey)?.delete(taskId);
-  mark(cancelled, options.sessionKey, taskId);
-  log.info("cancelled background subagent", {
-    sessionKey: options.sessionKey,
-    taskId,
-    wasRunning: running
+  const projectFiles = walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: PROJECT_FILE_NAMES,
+    predicate: fileExists
   });
-  return {
-    kind: "text",
-    text: `<task id="${taskId}" state="cancelled">
-` + (running ? "Stopped. No completion notification will arrive for it." : "It was not running when the cancel was sent, so nothing was interrupted. No completion notification will arrive for it.") + "\n</task>"
-  };
-}
-
-// src/permission-presets.ts
-var READ_ONLY_DISALLOWED_CLI_TOOLS = [
-  "Bash",
-  "Write",
-  "Edit",
-  "NotebookEdit",
-  "REPL",
-  "JavaScript",
-  "WebFetch"
-];
-var READ_ONLY_DENIED_PROXY_TOOLS = /* @__PURE__ */ new Set([
-  "bash",
-  "write",
-  "edit",
-  "webfetch",
-  "task",
-  "task_batch"
-]);
-function dedupe(names) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const name of names) {
-    const trimmed = String(name).trim();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    out.push(trimmed);
+  const projectDirs = [];
+  const seenProjectDirs = /* @__PURE__ */ new Set();
+  for (const f of projectFiles) {
+    const d = path4.dirname(f);
+    if (!seenProjectDirs.has(d)) {
+      seenProjectDirs.add(d);
+      projectDirs.push(d);
+    }
   }
-  return out;
+  for (const dir of projectDirs.slice().reverse()) {
+    layers.push(loadProjectFilesInDir(dir, hostApi));
+  }
+  if (hostApi === "v2") {
+    const dirs = walkUp({ start: cwd, targets: [".opencode"], predicate: dirExists }).reverse();
+    const extra = process.env.OPENCODE_CONFIG_DIR;
+    if (extra && dirExists(extra)) layers.push(loadProjectFilesInDir(extra, hostApi));
+    for (const dir of dirs) layers.push(loadProjectFilesInDir(dir, hostApi));
+  } else {
+    for (const dir of dotOpencodeDirs(cwd, worktree)) {
+      layers.push(loadProjectFilesInDir(dir));
+    }
+  }
+  return layers;
 }
-function resolveReadOnly(settings, defaultProxyTools) {
-  const overridden = [];
-  if (settings.permissionMode !== void 0) {
-    overridden.push(
-      `permissionMode: "${settings.permissionMode}" is dropped; read-only sends --restricted instead, which is stricter than every mode except plan and incompatible with bypassPermissions`
-    );
+function loadMergedOpencodeConfig(cwd, hostApi = "v1") {
+  let merged = {};
+  for (const layer of opencodeConfigLayers(cwd, hostApi)) merged = mergeConfigLayer(merged, layer, hostApi);
+  return merged;
+}
+function mergeOpencodeMcp(cwd, runtimeStatus, hostApi = "v1") {
+  let merged = {};
+  for (const layer of opencodeConfigLayers(cwd, hostApi)) {
+    const servers = extractMcpBlock(layer);
+    merged = hostApi === "v2" ? { ...merged, ...servers } : mergeMcp(merged, servers);
   }
-  if (settings.skipPermissions === true) {
-    overridden.push(
-      'skipPermissions: forced to false; the CLI exits with "bypassPermissions not supported in restricted mode" when both are passed'
-    );
+  if (runtimeStatus) {
+    for (const name of Object.keys(merged)) {
+      const status = runtimeStatus[name];
+      if (status === void 0) continue;
+      if (status === MCP_PENDING_STATUS) continue;
+      const existing = merged[name];
+      const base = existing && typeof existing === "object" ? existing : {};
+      merged[name] = { ...base, enabled: status === "connected" };
+    }
   }
-  if (settings.controlRequestBehavior === "allow") {
-    overridden.push(
-      'controlRequestBehavior: forced to "deny"; read-only answers every permission request the same way the CLI does under --permission-prompts none'
-    );
+  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 (settings.controlRequestToolBehaviors !== void 0) {
-    overridden.push(
-      "controlRequestToolBehaviors: ignored; a per-tool allow would apply only on CLIs older than 2.1.263, so the preset would mean different things on different versions"
-    );
+  const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
+  const hash = crypto2.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
+  return { servers: merged, enabledServerNames, hash };
+}
+function finishBridge(input) {
+  const { servers, bridgedServerNames, allEnabledServerNames, hash, excludeServers } = input;
+  if (Object.keys(servers).length === 0) {
+    const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
+    if (!allEnabledServersExcluded) return null;
+    return {
+      path: "",
+      hash,
+      serverNames: [],
+      allEnabledServerNames
+    };
   }
-  const requested = settings.proxyTools ?? defaultProxyTools;
-  const proxyTools = dedupe(requested).filter(
-    (name) => !READ_ONLY_DENIED_PROXY_TOOLS.has(name.toLowerCase())
-  );
-  const dropped = dedupe(requested).filter(
-    (name) => READ_ONLY_DENIED_PROXY_TOOLS.has(name.toLowerCase())
+  const body = JSON.stringify({ mcpServers: servers }, null, 2);
+  const bodyDigest = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
+  const outPath = path4.join(
+    pluginTmpDir(),
+    `mcp-${bodyDigest}.json`
   );
-  if (dropped.length > 0) {
-    overridden.push(
-      `proxyTools: dropped ${dropped.join(", ")}; those execute in opencode, where no Claude CLI flag reaches them`
-    );
+  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 {
-    preset: "read-only",
-    permissionMode: READ_ONLY_PERMISSION_MODE,
-    skipPermissions: false,
-    proxyTools,
-    extraDisallowedTools: dedupe([
-      ...READ_ONLY_DISALLOWED_CLI_TOOLS,
-      ...settings.extraDisallowedTools ?? []
-    ]),
-    controlRequestBehavior: "deny",
-    controlRequestToolBehaviors: void 0,
-    overridden
+    path: outPath,
+    hash,
+    serverNames: bridgedServerNames,
+    allEnabledServerNames
   };
 }
-function resolvePermissionPreset(settings, defaultProxyTools) {
-  const preset = settings.permissionPreset;
-  if (preset === void 0) return null;
-  if (preset === "read-only") return resolveReadOnly(settings, defaultProxyTools);
-  return { unknown: String(preset) };
+
+// src/runtime-status.ts
+var opencodeClient = null;
+function setOpencodeClient(client) {
+  if (client && typeof client === "object") {
+    opencodeClient = client;
+  }
 }
-function isUnknownPreset(resolved) {
-  return resolved !== null && "unknown" in resolved;
+function getOpencodeClient() {
+  return opencodeClient;
 }
-var NO_PERMISSION_PRESET = "none";
-function summarizePermissionPreset(provider, options, defaultProxyTools = DEFAULT_PROXY_TOOL_NAMES) {
-  const settings = options !== null && typeof options === "object" && !Array.isArray(options) ? options : {};
-  const resolved = resolvePermissionPreset(settings, defaultProxyTools);
-  if (resolved === null) {
-    return { provider, preset: NO_PERMISSION_PRESET, applied: false, overrides: [] };
-  }
-  if (isUnknownPreset(resolved)) {
-    return { provider, preset: resolved.unknown, applied: false, overrides: [] };
-  }
-  return {
-    provider,
-    preset: resolved.preset,
-    applied: true,
-    overrides: resolved.overridden
-  };
+var opencodeProjectDirectory;
+function setOpencodeProjectDirectory(dir) {
+  opencodeProjectDirectory = dir;
 }
-function isReadOnlyPermissionMode(mode) {
-  return mode === READ_ONLY_PERMISSION_MODE;
+function getOpencodeProjectDirectory() {
+  return opencodeProjectDirectory;
 }
-
-// src/side-question.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var MAX_HISTORY_EXCHANGES = 20;
-var SIDE_QUESTION_USAGE = "Usage: /btw <question>. Ask a side question about the current conversation without adding it to the main context.";
-var pendingProcesses = /* @__PURE__ */ new WeakSet();
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function isUsableDirectory(d) {
+  return typeof d === "string" && d.length > 1 && d !== "/";
 }
-var SYSTEM_REMINDER_BLOCK = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
-function parseSideQuestionContent(content) {
-  let text;
-  if (typeof content === "string") {
-    text = content;
-  } else if (Array.isArray(content)) {
-    const parts = [];
-    for (const part of content) {
-      if (!isRecord2(part) || part.type !== "text" || typeof part.text !== "string") return null;
-      parts.push(part.text);
-    }
-    text = parts.join("\n");
-  } else {
-    return null;
-  }
-  const match = /^\/btw(?:\s+([\s\S]*))?$/.exec(text.replace(SYSTEM_REMINDER_BLOCK, "").trim());
-  return match ? { question: (match[1] ?? "").trim() } : null;
+function resolveSpawnCwdFrom(configured, live, captured, sessionDir) {
+  if (configured) return configured;
+  if (isUsableDirectory(sessionDir)) return sessionDir;
+  if (isUsableDirectory(live)) return live;
+  return captured ?? live;
 }
-function parseSideQuestion(prompt) {
-  const latest = prompt.at(-1);
-  return latest?.role === "user" ? parseSideQuestionContent(latest.content) : null;
+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 assistantText(content) {
-  if (typeof content === "string") return content.trim();
-  if (!Array.isArray(content)) return "";
-  const parts = [];
-  for (const part of content) {
-    if (isRecord2(part) && part.type === "text" && typeof part.text === "string") parts.push(part.text);
+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 parts.join("\n").trim();
 }
-function collectSideQuestionHistory(prompt) {
-  const history = [];
-  for (let index = 0; index < prompt.length - 1; index++) {
-    const message = prompt[index];
-    if (message.role !== "user") continue;
-    const aside = parseSideQuestionContent(message.content);
-    if (!aside?.question) continue;
-    const reply = prompt[index + 1];
-    if (reply.role !== "assistant") continue;
-    const response = assistantText(reply.content);
-    if (!response || response === SIDE_QUESTION_USAGE) continue;
-    history.push({ question: aside.question, response });
+async function fetchSessionParentId(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 parentID = data.parentID;
+    return typeof parentID === "string" && parentID.length > 0 ? parentID : void 0;
+  } catch (err) {
+    log.warn("failed to fetch opencode session parent", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
   }
-  return history.slice(-MAX_HISTORY_EXCHANGES);
-}
-function isSideQuestionPending(activeProcess) {
-  return pendingProcesses.has(activeProcess.proc);
 }
-function dispatchSideQuestionResponse(activeProcess, line) {
-  if (!pendingProcesses.has(activeProcess.proc)) return false;
-  let message;
+async function fetchSessionRunState(sessionID) {
+  if (!sessionID || sessionID === "default") return "unknown";
+  const status = opencodeClient?.session?.status;
+  if (!status) return "unknown";
   try {
-    message = JSON.parse(line);
-  } catch {
-    return false;
+    const res = await status.call(opencodeClient.session);
+    const data = res.data;
+    if (!data || typeof data !== "object") return "unknown";
+    const entry = data[sessionID];
+    if (!entry || typeof entry !== "object") return "idle";
+    const type = entry.type;
+    return type === "idle" ? "idle" : "busy";
+  } catch (err) {
+    log.debug("failed to read opencode session status", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return "unknown";
   }
-  if (!isRecord2(message) || message.type !== "control_response") return false;
-  const response = message.response;
-  if (!isRecord2(response) || typeof response.request_id !== "string") return false;
-  return activeProcess.lineEmitter.emit(`side-question:${response.request_id}`, response);
 }
-async function requestSideQuestion(activeProcess, question, options) {
-  question = question.trim();
-  if (!question) return { response: SIDE_QUESTION_USAGE, synthetic: true };
-  options.abortSignal?.throwIfAborted();
-  const { proc, lineEmitter } = activeProcess;
-  if (options.interactive || !proc.stdout) {
-    throw new Error("/btw requires the headless Claude Code transport; interactive sessions are not supported.");
-  }
-  if (!cliSupportsSideQuestion(options.cliVersion)) {
-    throw new Error("/btw requires Claude Code CLI 2.1.258 or newer (the oldest verified version).");
-  }
-  if (pendingProcesses.has(proc)) {
-    throw new Error("Wait for the current /btw to finish before asking another.");
-  }
-  const stdin = proc.stdin;
-  if (proc.killed || proc.exitCode != null || proc.signalCode != null || !stdin || stdin.destroyed || stdin.writableEnded || !stdin.writable) {
-    throw new Error("/btw requires a live Claude Code session with writable stdin.");
+async function settleSessionRunState(sessionID, options = {}) {
+  const pollMs = options.pollMs ?? 150;
+  const windowMs = options.windowMs ?? 1500;
+  const started = Date.now();
+  let last = "unknown";
+  for (; ; ) {
+    const state = await fetchSessionRunState(sessionID);
+    if (state === "busy") return "busy";
+    if (state !== "unknown") last = state;
+    if (Date.now() - started >= windowMs) return last;
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
-  const timeoutMs = options.timeoutMs ?? 12e4;
-  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
-    throw new Error("/btw timeoutMs must be a positive 32-bit integer.");
+}
+var DEFAULT_MCP_CONNECT_WAIT_MS = 3e3;
+var MCP_CONNECT_POLL_MS = 100;
+function resolveMcpConnectWaitMs(configured) {
+  if (typeof configured !== "number" || !Number.isFinite(configured)) {
+    return DEFAULT_MCP_CONNECT_WAIT_MS;
   }
-  const requestId = randomUUID2();
-  const request = JSON.stringify({
-    type: "control_request",
-    request_id: requestId,
-    request: {
-      subtype: "side_question",
-      question,
-      ...options.history === void 0 ? {} : { history: options.history }
+  if (configured < 0) return DEFAULT_MCP_CONNECT_WAIT_MS;
+  return configured;
+}
+function pendingMcpServers(status) {
+  return Object.keys(status).filter(
+    (name) => status[name] === MCP_PENDING_STATUS
+  );
+}
+async function fetchRuntimeMcpStatus() {
+  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;
+  }
+}
+async function getRuntimeMcpStatus(options = {}) {
+  const current = await fetchRuntimeMcpStatus();
+  const budgetMs = options.waitForPendingMs ?? 0;
+  if (!current || budgetMs <= 0) return current;
+  return waitForPendingMcpServers(current, budgetMs, options.signal);
+}
+async function waitForPendingMcpServers(first, budgetMs, signal) {
+  let current = first;
+  const waitedFor = pendingMcpServers(current);
+  if (waitedFor.length === 0) return current;
+  const started = Date.now();
+  for (; ; ) {
+    if (Date.now() - started >= budgetMs) break;
+    if (signal?.aborted) break;
+    await new Promise((resolve6) => setTimeout(resolve6, MCP_CONNECT_POLL_MS));
+    if (signal?.aborted) break;
+    const next = await fetchRuntimeMcpStatus();
+    if (!next) break;
+    current = next;
+    if (pendingMcpServers(current).length === 0) break;
+  }
+  const stillPending = pendingMcpServers(current);
+  log.info("waited for opencode MCP servers to finish connecting", {
+    waitedFor,
+    stillPending,
+    budgetMs,
+    elapsedMs: Date.now() - started,
+    aborted: signal?.aborted === true
   });
-  pendingProcesses.add(proc);
-  return new Promise((resolve6, reject) => {
-    const event = `side-question:${requestId}`;
-    let settled = false;
-    let sent = false;
-    let cancelPending = false;
-    const cleanup = () => {
-      clearTimeout(timer);
-      lineEmitter.off(event, onResponse);
-      lineEmitter.off("close", onClose);
-      lineEmitter.off("error", onError);
-      proc.off("exit", onClose);
-      proc.off("close", onClose);
-      proc.off("error", onError);
-      if (!cancelPending) stdin.off("error", onError);
-      options.abortSignal?.removeEventListener("abort", onAbort);
-      pendingProcesses.delete(proc);
-    };
-    const fail = (error, cancel = false) => {
-      if (settled) return;
-      settled = true;
-      if (cancel && sent && !stdin.destroyed && !stdin.writableEnded && stdin.writable) {
-        try {
-          cancelPending = true;
-          stdin.write(
-            JSON.stringify({ type: "control_cancel_request", request_id: requestId }) + "\n",
-            () => {
-              queueMicrotask(() => stdin.off("error", onError));
-            }
-          );
-        } catch {
-          cancelPending = false;
-        }
-      }
-      cleanup();
-      reject(error);
-    };
-    const onClose = () => fail(new Error("Claude Code closed before answering /btw."));
-    const onError = (error) => fail(error);
-    const onAbort = () => fail(
-      options.abortSignal?.reason ?? new DOMException("/btw was aborted.", "AbortError"),
-      true
-    );
-    const onResponse = (response) => {
-      if (settled || response.request_id !== requestId) return;
-      if (response.subtype === "error") {
-        fail(new Error(typeof response.error === "string" ? response.error : "Claude Code rejected /btw."));
-        return;
-      }
-      const result = response.response;
-      if (response.subtype !== "success" || !isRecord2(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
-        fail(new Error("Claude Code returned an invalid /btw response."));
-        return;
-      }
-      settled = true;
-      cleanup();
-      resolve6({ response: result.response, synthetic: result.synthetic });
-    };
-    const timer = setTimeout(() => {
-      fail(new Error(`/btw timed out after ${timeoutMs}ms.`), true);
-    }, timeoutMs);
-    lineEmitter.on(event, onResponse);
-    lineEmitter.on("close", onClose);
-    lineEmitter.on("error", onError);
-    proc.on("exit", onClose);
-    proc.on("close", onClose);
-    proc.on("error", onError);
-    stdin.on("error", onError);
-    options.abortSignal?.addEventListener("abort", onAbort, { once: true });
-    if (options.abortSignal?.aborted) {
-      onAbort();
-      return;
+  return current;
+}
+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 });
     }
-    try {
-      sent = true;
-      stdin.write(request + "\n");
-    } catch (error) {
-      fail(error);
+    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 fetchSessionReplies(sessionID) {
+  if (!sessionID || sessionID === "default") return void 0;
+  const client = opencodeClient;
+  if (!client?.session?.messages) return void 0;
+  try {
+    const res = await client.session.messages({ path: { id: sessionID } });
+    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 info = entry.info;
+      if (!info || typeof info !== "object") continue;
+      const record = info;
+      const parts = entry.parts;
+      const text = Array.isArray(parts) ? parts.flatMap((part) => {
+        if (!part || typeof part !== "object") return [];
+        const p = part;
+        if (p.type !== "text" || typeof p.text !== "string") return [];
+        return p.synthetic === true ? [] : [p.text];
+      }).join("\n").trim() : "";
+      const error = record.error;
+      const message = error && typeof error === "object" ? typeof error.data?.message === "string" ? error.data.message : typeof error.name === "string" ? error.name : void 0 : void 0;
+      out.push({
+        role: typeof record.role === "string" ? record.role : "",
+        completed: typeof record.time?.completed === "number",
+        error: message,
+        text
+      });
     }
-  });
+    return out;
+  } catch (err) {
+    log.warn("failed to fetch opencode session messages", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
+}
+async function abortSession(sessionID) {
+  if (!sessionID || sessionID === "default") return false;
+  const client = opencodeClient;
+  if (!client?.session?.abort) return false;
+  try {
+    const res = await client.session.abort({ path: { id: sessionID } });
+    return res.data !== false;
+  } catch (err) {
+    log.warn("failed to abort opencode session", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return false;
+  }
 }
 
-// src/session-manager.ts
-function findActiveProcessBySessionId(sessionID) {
-  let found;
-  for (const ap of activeProcesses.values()) {
-    if (ap.opencodeSessionID === sessionID) found = ap;
+// src/background-tasks.ts
+var TASK_STATUS_TOOL_NAME = "task_status";
+var TASK_CANCEL_TOOL_NAME = "task_cancel";
+var MAX_LEDGERS = 32;
+var MAX_COLLECTED_PER_SESSION = 64;
+var collected = /* @__PURE__ */ new Map();
+var cancelled = /* @__PURE__ */ new Map();
+function ledgerIn(ledgers2, sessionKey2) {
+  let ids = ledgers2.get(sessionKey2);
+  if (!ids) {
+    ids = /* @__PURE__ */ new Set();
+    ledgers2.set(sessionKey2, ids);
+    while (ledgers2.size > MAX_LEDGERS) {
+      const oldest = ledgers2.keys().next();
+      if (oldest.done) break;
+      ledgers2.delete(oldest.value);
+    }
   }
-  return found;
+  return ids;
 }
-var UNATTENDED_LINE_CAP = 500;
-var UNATTENDED_BYTE_CAP = 2 * 1024 * 1024;
-function bufferUnattendedLine(ap, line) {
-  const lines = ap.unattendedLines ??= [];
-  lines.push(line);
-  let bytes = 0;
-  for (const kept of lines) bytes += Buffer.byteLength(kept);
-  while (lines.length > 0 && (lines.length > UNATTENDED_LINE_CAP || bytes > UNATTENDED_BYTE_CAP)) {
-    bytes -= Buffer.byteLength(lines.shift());
-    ap.unattendedDropped = (ap.unattendedDropped ?? 0) + 1;
+function mark(ledgers2, sessionKey2, taskId) {
+  const ids = ledgerIn(ledgers2, sessionKey2);
+  ids.add(taskId);
+  while (ids.size > MAX_COLLECTED_PER_SESSION) {
+    const oldest = ids.values().next();
+    if (oldest.done) break;
+    ids.delete(oldest.value);
   }
 }
-function takeUnattendedLines(ap) {
-  const lines = ap.unattendedLines ?? [];
-  const dropped = ap.unattendedDropped ?? 0;
-  ap.unattendedLines = [];
-  ap.unattendedDropped = 0;
-  return { lines, dropped };
+function markCollected(sessionKey2, taskId) {
+  mark(collected, sessionKey2, taskId);
 }
-var STDERR_RETAIN_BYTES = 2 * 1024;
-function retainStderr(ap, chunk) {
-  ap.lastStderr = ((ap.lastStderr ?? "") + chunk).slice(-STDERR_RETAIN_BYTES);
+function hasCollectedBackgroundTask(sessionKey2, taskId) {
+  return collected.get(sessionKey2)?.has(taskId) === true;
 }
-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}` : "");
+function clearBackgroundTasks(sessionKey2) {
+  collected.delete(sessionKey2);
+  cancelled.delete(sessionKey2);
 }
-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 lastGate;
+function recordBackgroundSubagentGate(gate, now = Date.now()) {
+  lastGate = { ...gate, at: now };
 }
-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();
-  if (!normalized) return false;
-  return !["0", "false", "no", "off"].includes(normalized);
+function snapshotBackgroundSubagentGate() {
+  return lastGate ? { ...lastGate } : void 0;
 }
-function isClaudeThinkingDisabled() {
-  return envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_THINKING) || envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING);
+function snapshotBackgroundTasks() {
+  const keys = /* @__PURE__ */ new Set([...collected.keys(), ...cancelled.keys()]);
+  return [...keys].map((sessionKey2) => ({
+    sessionKey: sessionKey2,
+    collected: [...collected.get(sessionKey2) ?? []],
+    cancelled: [...cancelled.get(sessionKey2) ?? []]
+  }));
 }
-function cliEffortLevel(effort) {
-  return effort === "minimal" ? "low" : effort;
+function readTaskId(input) {
+  const raw = input.task_id ?? input.taskId ?? input.sessionID;
+  if (typeof raw !== "string") return null;
+  const id = raw.trim();
+  return id.length > 0 ? id : null;
 }
-function claudeSpawnEnv(opts) {
-  const env = {
-    ...process.env,
-    TERM: "xterm-256color",
-    // Pin the child to the binary whose version we detected, and keep it off
-    // non-essential network calls. Fills gaps only, so an explicit shell value
-    // survives: see `cliHygieneEnv` for why the version has to hold still.
-    ...cliHygieneEnv()
-  };
-  if (opts?.effort) {
-    env.CLAUDE_CODE_EFFORT_LEVEL = cliEffortLevel(opts.effort);
-  }
-  if (opts?.promptCacheTtl) {
-    env.CLAUDE_CODE_PROMPT_CACHE_TTL = opts.promptCacheTtl;
-  }
-  if (opts?.ignoreAnthropicApiKey) {
-    delete env.ANTHROPIC_API_KEY;
-    delete env.ANTHROPIC_AUTH_TOKEN;
-  }
-  if (!isClaudeThinkingDisabled() && process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0) {
-    env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES = "1";
+var MISSING_TASK_ID = 'task_id is required: pass the background subagent\'s own opencode session id, from the `<task id="...">` envelope on opencode 1.x or the `sessionID` the background dispatch reported on opencode 2.';
+async function guardParent(taskId, callerSessionId) {
+  if (!callerSessionId || callerSessionId === "default") {
+    return `Cannot check that task_id ${taskId} belongs to this conversation (this turn has no opencode session id), so it is not inspected or cancelled.`;
   }
-  return env;
+  const parent = await fetchSessionParentId(taskId);
+  if (parent === callerSessionId) return null;
+  return `task_id ${taskId} is not a subagent of this conversation, so it cannot be inspected or cancelled from here. Use the session id from a background dispatch this conversation itself made.`;
 }
-function touch(key) {
-  const existing = activeProcesses.get(key);
-  if (existing) {
-    activeProcesses.delete(key);
-    activeProcesses.set(key, existing);
+function isBackgroundTaskRunning(runState, replies) {
+  if (runState === "busy") return true;
+  if (runState === "idle") return false;
+  const reply = lastAssistantReply(replies);
+  return reply !== void 0 && !reply.completed && reply.error === void 0;
+}
+function lastAssistantReply(replies) {
+  for (let index = replies.length - 1; index >= 0; index--) {
+    const reply = replies[index];
+    if (reply.role === "assistant") return reply;
   }
+  return void 0;
 }
-function evictIfNeeded() {
-  while (activeProcesses.size >= MAX_ACTIVE_PROCESSES) {
-    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);
+async function collectBackgroundTask(input, options) {
+  const taskId = readTaskId(input);
+  if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
+  const refused = await guardParent(taskId, options.callerSessionId);
+  if (refused) return { kind: "error", message: refused };
+  const replies = await fetchSessionReplies(taskId);
+  if (replies === void 0) {
+    return {
+      kind: "error",
+      message: `Could not read background task ${taskId} from opencode. It may have been deleted, or this opencode build does not expose the session transcript. The completion notification is still the primary delivery path: end your turn and wait for it.`
+    };
   }
-}
-var TURN_INTERRUPT_TIMEOUT_MS = 5e3;
-function isTerminalResultLine(line) {
-  if (!line.includes('"result"')) return false;
-  try {
-    return JSON.parse(line).type === "result";
-  } catch {
-    return false;
+  const runState = await fetchSessionRunState(taskId);
+  if (isBackgroundTaskRunning(runState, replies)) {
+    return {
+      kind: "text",
+      text: `<task id="${taskId}" state="running">
+Still working. Do not call this again in a loop: when it finishes opencode delivers the result to this conversation on its own. End your turn, or work on something that does not overlap it.
+</task>`
+    };
   }
-}
-function settleTurn(ap) {
-  ap.turnInFlight = false;
-  const waiters = ap.turnIdleWaiters ?? [];
-  ap.turnIdleWaiters = [];
-  for (const wake of waiters) wake();
-}
-function noteTurnStarted(ap) {
-  if (ap.asideTransport?.interactive) return;
-  ap.turnInFlight = true;
-}
-function noteTurnLine(ap, line) {
-  if (!ap.turnInFlight) return;
-  if (isTerminalResultLine(line)) settleTurn(ap);
-}
-function isTurnInFlight(ap) {
-  return ap.turnInFlight === true;
-}
-function awaitTurnIdle(ap, timeoutMs) {
-  if (!ap.turnInFlight) return Promise.resolve(true);
-  return new Promise((resolve6) => {
-    const wake = () => {
-      clearTimeout(timer);
-      resolve6(true);
+  const reply = lastAssistantReply(replies);
+  if (!reply) {
+    return {
+      kind: "text",
+      text: `<task id="${taskId}" state="unknown">
+opencode has no assistant reply for this task yet and it is not running. It may still be starting up.
+</task>`
     };
-    const timer = setTimeout(() => {
-      const waiters = ap.turnIdleWaiters ?? [];
-      const at = waiters.indexOf(wake);
-      if (at >= 0) waiters.splice(at, 1);
-      resolve6(false);
-    }, timeoutMs);
-    (ap.turnIdleWaiters ??= []).push(wake);
-  });
-}
-function interruptTurn(ap, timeoutMs = TURN_INTERRUPT_TIMEOUT_MS) {
-  if (!ap.turnInFlight) return Promise.resolve(true);
-  const stdin = ap.proc.stdin;
-  if (ap.asideTransport?.interactive || !stdin || !stdin.writable) {
-    log.notice("cannot interrupt this transport; waiting for the turn to end");
-    return awaitTurnIdle(ap, timeoutMs);
   }
-  try {
-    stdin.write(
-      JSON.stringify({
-        type: "control_request",
-        request_id: randomUUID3(),
-        request: { subtype: "interrupt" }
-      }) + "\n"
-    );
-  } catch (error) {
-    log.warn("failed to write interrupt control request", {
-      error: error instanceof Error ? error.message : String(error)
-    });
-    return Promise.resolve(false);
+  if (reply.error) {
+    markCollected(options.sessionKey, taskId);
+    return {
+      kind: "text",
+      isError: true,
+      text: `<task id="${taskId}" state="error">
+${reply.error}
+</task>`
+    };
   }
-  return awaitTurnIdle(ap, timeoutMs);
-}
-function cancelIdleProcessEviction(key) {
-  const timer = idleEvictionTimers.get(key);
-  if (!timer) return;
-  clearTimeout(timer);
-  idleEvictionTimers.delete(key);
-}
-function getActiveProcess(key) {
-  const ap = activeProcesses.get(key);
-  if (ap) {
-    cancelIdleProcessEviction(key);
-    touch(key);
+  if (hasCollectedBackgroundTask(options.sessionKey, taskId)) {
+    return {
+      kind: "text",
+      text: `<task id="${taskId}" state="completed">
+Already delivered to this conversation earlier (by this tool or by opencode's completion notification). Scroll back for the result rather than collecting it again.
+</task>`
+    };
   }
-  return ap;
-}
-function setActiveProcess(key, ap) {
-  cancelIdleProcessEviction(key);
-  activeProcesses.set(key, ap);
+  markCollected(options.sessionKey, taskId);
+  log.info("collected background subagent result", {
+    sessionKey: options.sessionKey,
+    taskId,
+    textLength: reply.text.length
+  });
+  return {
+    kind: "text",
+    text: `<task id="${taskId}" state="completed">
+<task_result>
+${reply.text || "(the subagent produced no text)"}
+</task_result>
+</task>`
+  };
 }
-function scheduleIdleProcessEviction(key, timeoutMs) {
-  cancelIdleProcessEviction(key);
-  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_IDLE_TIMEOUT_MS) {
-    return;
+async function cancelBackgroundTask(input, options) {
+  const taskId = readTaskId(input);
+  if (!taskId) return { kind: "error", message: MISSING_TASK_ID };
+  const refused = await guardParent(taskId, options.callerSessionId);
+  if (refused) return { kind: "error", message: refused };
+  const running = isBackgroundTaskRunning(
+    await fetchSessionRunState(taskId),
+    await fetchSessionReplies(taskId) ?? []
+  );
+  const aborted = await abortSession(taskId);
+  if (!aborted) {
+    return {
+      kind: "error",
+      message: `Could not cancel background task ${taskId}: opencode did not accept the abort. It may have already finished, or this opencode build does not expose session abort.`
+    };
   }
-  const scheduledProcess = activeProcesses.get(key);
-  if (!scheduledProcess) return;
-  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);
-  timer.unref();
-  idleEvictionTimers.set(key, timer);
+  collected.get(options.sessionKey)?.delete(taskId);
+  mark(cancelled, options.sessionKey, taskId);
+  log.info("cancelled background subagent", {
+    sessionKey: options.sessionKey,
+    taskId,
+    wasRunning: running
+  });
+  return {
+    kind: "text",
+    text: `<task id="${taskId}" state="cancelled">
+` + (running ? "Stopped. No completion notification will arrive for it." : "It was not running when the cancel was sent, so nothing was interrupted. No completion notification will arrive for it.") + "\n</task>"
+  };
 }
-function detachActiveProcess(key) {
-  cancelIdleProcessEviction(key);
-  const ap = activeProcesses.get(key);
-  if (!ap) return void 0;
-  activeProcesses.delete(key);
-  if (ap.proxyServer) {
-    void ap.proxyServer.close();
-    rejectAllPendingProxyCallsForSession(key, new Error(SERVER_CLOSED_MESSAGE));
+
+// src/permission-presets.ts
+var READ_ONLY_DISALLOWED_CLI_TOOLS = [
+  "Bash",
+  "Write",
+  "Edit",
+  "NotebookEdit",
+  "REPL",
+  "JavaScript",
+  "WebFetch"
+];
+var READ_ONLY_DENIED_PROXY_TOOLS = /* @__PURE__ */ new Set([
+  "bash",
+  "write",
+  "edit",
+  "webfetch",
+  "task",
+  "task_batch"
+]);
+function dedupe(names) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const trimmed = String(name).trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
   }
-  return ap;
+  return out;
 }
-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);
+function resolveReadOnly(settings, defaultProxyTools) {
+  const overridden = [];
+  if (settings.permissionMode !== void 0) {
+    overridden.push(
+      `permissionMode: "${settings.permissionMode}" is dropped; read-only sends --restricted instead, which is stricter than every mode except plan and incompatible with bypassPermissions`
+    );
   }
-  for (const key of released) clearBackgroundTasks(key);
-  return released;
-}
-function killAllActiveProcesses() {
-  const keys = [...activeProcesses.keys()];
-  for (const key of keys) deleteActiveProcess(key);
-  for (const key of keys) clearBackgroundTasks(key);
-  return keys;
+  if (settings.skipPermissions === true) {
+    overridden.push(
+      'skipPermissions: forced to false; the CLI exits with "bypassPermissions not supported in restricted mode" when both are passed'
+    );
+  }
+  if (settings.controlRequestBehavior === "allow") {
+    overridden.push(
+      'controlRequestBehavior: forced to "deny"; read-only answers every permission request the same way the CLI does under --permission-prompts none'
+    );
+  }
+  if (settings.controlRequestToolBehaviors !== void 0) {
+    overridden.push(
+      "controlRequestToolBehaviors: ignored; a per-tool allow would apply only on CLIs older than 2.1.263, so the preset would mean different things on different versions"
+    );
+  }
+  const requested = settings.proxyTools ?? defaultProxyTools;
+  const proxyTools = dedupe(requested).filter(
+    (name) => !READ_ONLY_DENIED_PROXY_TOOLS.has(name.toLowerCase())
+  );
+  const dropped = dedupe(requested).filter(
+    (name) => READ_ONLY_DENIED_PROXY_TOOLS.has(name.toLowerCase())
+  );
+  if (dropped.length > 0) {
+    overridden.push(
+      `proxyTools: dropped ${dropped.join(", ")}; those execute in opencode, where no Claude CLI flag reaches them`
+    );
+  }
+  return {
+    preset: "read-only",
+    permissionMode: READ_ONLY_PERMISSION_MODE,
+    skipPermissions: false,
+    proxyTools,
+    extraDisallowedTools: dedupe([
+      ...READ_ONLY_DISALLOWED_CLI_TOOLS,
+      ...settings.extraDisallowedTools ?? []
+    ]),
+    controlRequestBehavior: "deny",
+    controlRequestToolBehaviors: void 0,
+    overridden
+  };
 }
-var processExitCleanupWired = false;
-function ensureProcessExitCleanup() {
-  if (processExitCleanupWired) return false;
-  processExitCleanupWired = true;
-  process.once("exit", () => {
-    killAllActiveProcesses();
-  });
-  return true;
+function resolvePermissionPreset(settings, defaultProxyTools) {
+  const preset = settings.permissionPreset;
+  if (preset === void 0) return null;
+  if (preset === "read-only") return resolveReadOnly(settings, defaultProxyTools);
+  return { unknown: String(preset) };
 }
-function deleteActiveProcess(key) {
-  const ap = detachActiveProcess(key);
-  ap?.proc.kill();
+function isUnknownPreset(resolved) {
+  return resolved !== null && "unknown" in resolved;
 }
-function hasProcessExited(proc) {
-  return proc.exitCode !== null || proc.signalCode !== null;
+var NO_PERMISSION_PRESET = "none";
+function summarizePermissionPreset(provider, options, defaultProxyTools = DEFAULT_PROXY_TOOL_NAMES) {
+  const settings = options !== null && typeof options === "object" && !Array.isArray(options) ? options : {};
+  const resolved = resolvePermissionPreset(settings, defaultProxyTools);
+  if (resolved === null) {
+    return { provider, preset: NO_PERMISSION_PRESET, applied: false, overrides: [] };
+  }
+  if (isUnknownPreset(resolved)) {
+    return { provider, preset: resolved.unknown, applied: false, overrides: [] };
+  }
+  return {
+    provider,
+    preset: resolved.preset,
+    applied: true,
+    overrides: resolved.overridden
+  };
 }
-function waitForProcessExit(proc, timeoutMs) {
-  if (hasProcessExited(proc)) return Promise.resolve(true);
-  return new Promise((resolve6) => {
-    const onExit = () => {
-      clearTimeout(timer);
-      resolve6(true);
-    };
-    const timer = setTimeout(() => {
-      proc.off("exit", onExit);
-      resolve6(hasProcessExited(proc));
-    }, timeoutMs);
-    proc.once("exit", onExit);
-  });
+function isReadOnlyPermissionMode(mode) {
+  return mode === READ_ONLY_PERMISSION_MODE;
 }
-async function deleteActiveProcessAndWait(key, options = {}) {
-  const ap = detachActiveProcess(key);
-  if (!ap || hasProcessExited(ap.proc)) return true;
-  const gracefulExit = waitForProcessExit(
-    ap.proc,
-    options.exitTimeoutMs ?? PROCESS_EXIT_TIMEOUT_MS
-  );
-  ap.proc.kill();
-  if (await gracefulExit) return true;
-  const forcedExit = waitForProcessExit(
-    ap.proc,
-    options.forceExitTimeoutMs ?? PROCESS_FORCE_EXIT_TIMEOUT_MS
-  );
-  ap.proc.kill("SIGKILL");
-  if (await forcedExit) return true;
-  log.warn("claude process did not exit; starting a fresh session", {
-    sessionKey: key
-  });
-  deleteClaudeSessionId(key);
-  return false;
+
+// src/side-question.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var MAX_HISTORY_EXCHANGES = 20;
+var SIDE_QUESTION_USAGE = "Usage: /btw <question>. Ask a side question about the current conversation without adding it to the main context.";
+var pendingProcesses = /* @__PURE__ */ new WeakSet();
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function getClaudeSessionId(key) {
-  return claudeSessions.get(key);
+var SYSTEM_REMINDER_BLOCK = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+function parseSideQuestionContent(content) {
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (!isRecord2(part) || part.type !== "text" || typeof part.text !== "string") return null;
+      parts.push(part.text);
+    }
+    text = parts.join("\n");
+  } else {
+    return null;
+  }
+  const match = /^\/btw(?:\s+([\s\S]*))?$/.exec(text.replace(SYSTEM_REMINDER_BLOCK, "").trim());
+  return match ? { question: (match[1] ?? "").trim() } : null;
 }
-var MAX_CLAUDE_SESSION_ENTRIES = 64;
-function claudeSessionIsBusy(key) {
-  if (activeProcesses.has(key)) return true;
-  return getPendingProxyCalls(key).length > 0 || hasExitPlanModeQuestions(key);
+function parseSideQuestion(prompt) {
+  const latest = prompt.at(-1);
+  return latest?.role === "user" ? parseSideQuestionContent(latest.content) : null;
 }
-function capClaudeSessions() {
-  for (const key of [...claudeSessions.keys()]) {
-    if (claudeSessions.size <= MAX_CLAUDE_SESSION_ENTRIES) return;
-    if (claudeSessionIsBusy(key)) continue;
-    log.info("claude session cap reached; releasing an idle session", {
-      sessionKey: key,
-      size: claudeSessions.size,
-      cap: MAX_CLAUDE_SESSION_ENTRIES
-    });
-    deleteClaudeSessionId(key);
+function assistantText(content) {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const part of content) {
+    if (isRecord2(part) && part.type === "text" && typeof part.text === "string") parts.push(part.text);
   }
+  return parts.join("\n").trim();
 }
-function setClaudeSessionId(key, sessionId) {
-  claudeSessions.delete(key);
-  claudeSessions.set(key, sessionId);
-  capClaudeSessions();
+function collectSideQuestionHistory(prompt) {
+  const history = [];
+  for (let index = 0; index < prompt.length - 1; index++) {
+    const message = prompt[index];
+    if (message.role !== "user") continue;
+    const aside = parseSideQuestionContent(message.content);
+    if (!aside?.question) continue;
+    const reply = prompt[index + 1];
+    if (reply.role !== "assistant") continue;
+    const response = assistantText(reply.content);
+    if (!response || response === SIDE_QUESTION_USAGE) continue;
+    history.push({ question: aside.question, response });
+  }
+  return history.slice(-MAX_HISTORY_EXCHANGES);
 }
-function deleteClaudeSessionId(key) {
-  clearExitPlanModeQuestions(key);
-  clearAccountFailoverQuestions(key);
-  const claudeSessionId = claudeSessions.get(key);
-  if (claudeSessionId) clearLedger(claudeSessionId);
-  claudeSessions.delete(key);
+function isSideQuestionPending(activeProcess) {
+  return pendingProcesses.has(activeProcess.proc);
 }
-function effortSessionKey(baseKey, effort) {
-  return effort ? `${baseKey}::effort=${effort}` : baseKey;
+function dispatchSideQuestionResponse(activeProcess, line) {
+  if (!pendingProcesses.has(activeProcess.proc)) return false;
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (!isRecord2(message) || message.type !== "control_response") return false;
+  const response = message.response;
+  if (!isRecord2(response) || typeof response.request_id !== "string") return false;
+  return activeProcess.lineEmitter.emit(`side-question:${response.request_id}`, response);
 }
-function invalidateOtherEffortSessions(baseKey, effort) {
-  const levels = [
-    void 0,
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max"
-  ];
-  const staleKeys = levels.filter((level) => level !== effort).map((level) => effortSessionKey(baseKey, level));
-  for (const key of staleKeys) {
-    const active = activeProcesses.get(key);
-    if (getPendingProxyCalls(key).length || hasExitPlanModeQuestions(key) || active?.pendingProxyCompletions?.size || active && (active.lineEmitter.listenerCount("line") > 0 || isSideQuestionPending(active))) {
-      throw new Error(
-        "Cannot change reasoning effort while the previous effort session has pending work. Finish that work at its original effort first."
-      );
-    }
+async function requestSideQuestion(activeProcess, question, options) {
+  question = question.trim();
+  if (!question) return { response: SIDE_QUESTION_USAGE, synthetic: true };
+  options.abortSignal?.throwIfAborted();
+  const { proc, lineEmitter } = activeProcess;
+  if (options.interactive || !proc.stdout) {
+    throw new Error("/btw requires the headless Claude Code transport; interactive sessions are not supported.");
   }
-  for (const key of staleKeys) {
-    deleteActiveProcess(key);
-    deleteClaudeSessionId(key);
-    clearCompression(key);
-    clearBackgroundTasks(key);
+  if (!cliSupportsSideQuestion(options.cliVersion)) {
+    throw new Error("/btw requires Claude Code CLI 2.1.258 or newer (the oldest verified version).");
   }
-}
-function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort, promptCacheTtl) {
-  evictIfNeeded();
-  log.info("spawning new claude process", {
-    cliPath,
-    cliArgs,
-    cwd,
-    sessionKey: sessionKey2,
-    effort,
-    promptCacheTtl
-  });
-  const proc = spawn(cliPath, cliArgs, {
-    cwd,
-    stdio: ["pipe", "pipe", "pipe"],
-    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort, promptCacheTtl }),
-    shell: process.platform === "win32"
-  });
-  const lineEmitter = new EventEmitter3();
-  const ap = {
-    proc,
-    lineEmitter,
-    proxyServer: proxyServer ?? null,
-    mcpHash,
-    systemPromptFile,
-    effort,
-    promptCacheTtl,
-    startedAt: Date.now(),
-    cliPath,
-    cliArgs: [...cliArgs],
-    unattendedLines: [],
-    unattendedDropped: 0
-  };
-  const rl = createInterface({ input: proc.stdout });
-  rl.on("line", (line) => {
-    if (dispatchSideQuestionResponse(ap, line)) return;
-    noteTurnLine(ap, line);
-    if (lineEmitter.listenerCount("line") === 0) {
-      bufferUnattendedLine(ap, line);
-      return;
+  if (pendingProcesses.has(proc)) {
+    throw new Error("Wait for the current /btw to finish before asking another.");
+  }
+  const stdin = proc.stdin;
+  if (proc.killed || proc.exitCode != null || proc.signalCode != null || !stdin || stdin.destroyed || stdin.writableEnded || !stdin.writable) {
+    throw new Error("/btw requires a live Claude Code session with writable stdin.");
+  }
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  if (!Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) {
+    throw new Error("/btw timeoutMs must be a positive 32-bit integer.");
+  }
+  const requestId = randomUUID2();
+  const request = JSON.stringify({
+    type: "control_request",
+    request_id: requestId,
+    request: {
+      subtype: "side_question",
+      question,
+      ...options.history === void 0 ? {} : { history: options.history }
     }
-    lineEmitter.emit("line", line);
-  });
-  rl.on("close", () => {
-    settleTurn(ap);
-    lineEmitter.emit("close");
-  });
-  cancelIdleProcessEviction(sessionKey2);
-  activeProcesses.set(sessionKey2, ap);
-  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();
-    if (systemPromptFile) {
-      void unlink(systemPromptFile).catch(() => {
-      });
-    }
-    const ownsSessionKey = activeProcesses.get(sessionKey2) === ap;
-    if (ownsSessionKey) {
-      cancelIdleProcessEviction(sessionKey2);
-      activeProcesses.delete(sessionKey2);
-      if (getPendingProxyCalls(sessionKey2).length > 0) {
-        rejectAllPendingProxyCallsForSession(
-          sessionKey2,
-          new Error(CHILD_EXITED_MESSAGE)
-        );
+  pendingProcesses.add(proc);
+  return new Promise((resolve6, reject) => {
+    const event = `side-question:${requestId}`;
+    let settled = false;
+    let sent = false;
+    let cancelPending = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      lineEmitter.off(event, onResponse);
+      lineEmitter.off("close", onClose);
+      lineEmitter.off("error", onError);
+      proc.off("exit", onClose);
+      proc.off("close", onClose);
+      proc.off("error", onError);
+      if (!cancelPending) stdin.off("error", onError);
+      options.abortSignal?.removeEventListener("abort", onAbort);
+      pendingProcesses.delete(proc);
+    };
+    const fail = (error, cancel = false) => {
+      if (settled) return;
+      settled = true;
+      if (cancel && sent && !stdin.destroyed && !stdin.writableEnded && stdin.writable) {
+        try {
+          cancelPending = true;
+          stdin.write(
+            JSON.stringify({ type: "control_cancel_request", request_id: requestId }) + "\n",
+            () => {
+              queueMicrotask(() => stdin.off("error", onError));
+            }
+          );
+        } catch {
+          cancelPending = false;
+        }
       }
-    }
-    if (ownsSessionKey && code !== 0 && code !== null) {
-      log.info("process exited with error, clearing session", {
-        code,
-        sessionKey: sessionKey2
-      });
-      claudeSessions.delete(sessionKey2);
-    }
-  });
-  proc.stderr?.on("data", (data) => {
-    const stderr = data.toString();
-    log.debug("stderr", { data: stderr.slice(0, 200) });
-    retainStderr(ap, stderr);
-    reportUnrecognizedModel(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", {
-          sessionKey: sessionKey2,
-          error: stderr.slice(0, 200)
-        });
-        claudeSessions.delete(sessionKey2);
-      } else {
-        log.debug("ignoring session ID error from stale claude process", {
-          sessionKey: sessionKey2
-        });
+      cleanup();
+      reject(error);
+    };
+    const onClose = () => fail(new Error("Claude Code closed before answering /btw."));
+    const onError = (error) => fail(error);
+    const onAbort = () => fail(
+      options.abortSignal?.reason ?? new DOMException("/btw was aborted.", "AbortError"),
+      true
+    );
+    const onResponse = (response) => {
+      if (settled || response.request_id !== requestId) return;
+      if (response.subtype === "error") {
+        fail(new Error(typeof response.error === "string" ? response.error : "Claude Code rejected /btw."));
+        return;
+      }
+      const result = response.response;
+      if (response.subtype !== "success" || !isRecord2(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
+        fail(new Error("Claude Code returned an invalid /btw response."));
+        return;
       }
+      settled = true;
+      cleanup();
+      resolve6({ response: result.response, synthetic: result.synthetic });
+    };
+    const timer = setTimeout(() => {
+      fail(new Error(`/btw timed out after ${timeoutMs}ms.`), true);
+    }, timeoutMs);
+    lineEmitter.on(event, onResponse);
+    lineEmitter.on("close", onClose);
+    lineEmitter.on("error", onError);
+    proc.on("exit", onClose);
+    proc.on("close", onClose);
+    proc.on("error", onError);
+    stdin.on("error", onError);
+    options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    if (options.abortSignal?.aborted) {
+      onAbort();
+      return;
+    }
+    try {
+      sent = true;
+      stdin.write(request + "\n");
+    } catch (error) {
+      fail(error);
     }
   });
-  return ap;
 }
-function appendResumeIfNeeded(sessionKey2, cliArgs) {
-  if (cliArgs.includes("--resume") || cliArgs.includes("--session-id")) {
-    return cliArgs;
+
+// src/session-manager.ts
+function findActiveProcessBySessionId(sessionID) {
+  let found;
+  for (const ap of activeProcesses.values()) {
+    if (ap.opencodeSessionID === sessionID) found = ap;
   }
-  const sid = claudeSessions.get(sessionKey2);
-  if (!sid) return cliArgs;
-  return [...cliArgs, "--resume", sid];
+  return found;
 }
-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 {
-    old.proc.kill();
-  } catch {
+var UNATTENDED_LINE_CAP = 500;
+var UNATTENDED_BYTE_CAP = 2 * 1024 * 1024;
+function bufferUnattendedLine(ap, line) {
+  const lines = ap.unattendedLines ??= [];
+  lines.push(line);
+  let bytes = 0;
+  for (const kept of lines) bytes += Buffer.byteLength(kept);
+  while (lines.length > 0 && (lines.length > UNATTENDED_LINE_CAP || bytes > UNATTENDED_BYTE_CAP)) {
+    bytes -= Buffer.byteLength(lines.shift());
+    ap.unattendedDropped = (ap.unattendedDropped ?? 0) + 1;
   }
-  const replacement = spawnClaudeProcess(
-    cliPath,
-    appendResumeIfNeeded(sessionKey2, old.cliArgs ?? cliArgs),
-    cwd,
-    sessionKey2,
-    old.proxyServer,
-    old.mcpHash,
-    old.systemPromptFile,
-    ignoreAnthropicApiKey,
-    old.effort,
-    old.promptCacheTtl
-  );
-  replacement.pendingProxyCompletions = old.pendingProxyCompletions;
-  delete old.pendingProxyCompletions;
-  if (turnWasInFlight) noteTurnStarted(replacement);
-  return replacement;
 }
-function buildCliArgs(opts) {
-  const {
-    sessionKey: sessionKey2,
-    skipPermissions,
-    includeSessionId = true,
-    model,
-    permissionMode,
-    mcpConfig,
-    strictMcpConfig,
-    disallowedTools,
-    appendSystemPromptFile,
-    pluginDirs,
-    thinking,
-    thinkingDisplay,
-    fastMode,
-    cliVersion
-  } = opts;
-  const args = [
-    "--print",
-    "--output-format",
-    "stream-json",
-    "--input-format",
-    "stream-json",
-    "--include-partial-messages",
-    "--verbose"
-  ];
-  if (model) {
-    args.push("--model", model);
-  }
-  const readOnly = isReadOnlyPermissionMode(permissionMode);
-  if (readOnly) {
-    if (cliSupportsRestricted(cliVersion ?? null)) {
-      args.push("--restricted");
-    } else {
-      log.warn(
-        'permissionPreset "read-only": this claude CLI has no --restricted (2.1.258+), so file reads are not confined to the working directory. The mutating tools are still refused via --disallowedTools and every permission request is denied.',
-        { cliVersion: cliVersion?.raw ?? "unknown" }
-      );
-    }
-    if (cliSupportsPermissionPrompts(cliVersion ?? null)) {
-      args.push("--permission-prompts", "none");
-    } else {
-      log.warn(
-        `permissionPreset "read-only": this claude CLI has no --permission-prompts (2.1.263+), so permission requests are denied by the plugin's own can_use_tool handler instead of by the CLI. Same outcome, one layer fewer.`,
-        { cliVersion: cliVersion?.raw ?? "unknown" }
-      );
-    }
-  } else if (permissionMode) {
-    args.push("--permission-mode", permissionMode);
-  }
-  if (includeSessionId) {
-    const sessionId = claudeSessions.get(sessionKey2);
-    if (sessionId && !activeProcesses.has(sessionKey2)) {
-      args.push("--resume", sessionId);
-    }
-  }
-  if (mcpConfig) {
-    const configs = Array.isArray(mcpConfig) ? mcpConfig : [mcpConfig];
-    const filtered = configs.filter((c) => typeof c === "string" && c.length > 0);
-    if (filtered.length > 0) {
-      args.push("--mcp-config", ...filtered);
-    }
-  }
-  if (strictMcpConfig) {
-    args.push("--strict-mcp-config");
-  }
-  if (disallowedTools && disallowedTools.length > 0) {
-    args.push("--disallowedTools", ...disallowedTools);
-  }
-  if (thinking && cliSupportsThinking(cliVersion ?? null)) {
-    args.push("--thinking", thinking);
-  }
-  if (thinkingDisplay && cliSupportsThinkingDisplay(cliVersion ?? null)) {
-    args.push("--thinking-display", thinkingDisplay);
-  }
-  if (appendSystemPromptFile) {
-    args.push("--append-system-prompt-file", appendSystemPromptFile);
-  }
-  for (const dir of pluginDirs ?? []) {
-    args.push("--plugin-dir", dir);
-  }
-  if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
-    args.push("--settings", JSON.stringify({ fastMode: true }));
-  }
-  if (skipPermissions && permissionMode !== "plan" && !readOnly) {
-    args.push("--dangerously-skip-permissions");
-  }
-  return args;
+function takeUnattendedLines(ap) {
+  const lines = ap.unattendedLines ?? [];
+  const dropped = ap.unattendedDropped ?? 0;
+  ap.unattendedLines = [];
+  ap.unattendedDropped = 0;
+  return { lines, dropped };
 }
-function sessionKey(cwd, modelId) {
-  return `${cwd}::${modelId}`;
+var STDERR_RETAIN_BYTES = 2 * 1024;
+function retainStderr(ap, chunk) {
+  ap.lastStderr = ((ap.lastStderr ?? "") + chunk).slice(-STDERR_RETAIN_BYTES);
 }
-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 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}` : "");
 }
-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;
+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;
 }
-
-// src/btw-command.ts
-var BtwHandledError = class extends Error {
-  name = "BtwHandledError";
-  constructor(message = "/btw was handled by the claude-code plugin; nothing to add to this conversation.") {
-    super(message);
+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();
+  if (!normalized) return false;
+  return !["0", "false", "no", "off"].includes(normalized);
+}
+function isClaudeThinkingDisabled() {
+  return envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_THINKING) || envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING);
+}
+function cliEffortLevel(effort) {
+  return effort === "minimal" ? "low" : effort;
+}
+function claudeSpawnEnv(opts) {
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color",
+    // Pin the child to the binary whose version we detected, and keep it off
+    // non-essential network calls. Fills gaps only, so an explicit shell value
+    // survives: see `cliHygieneEnv` for why the version has to hold still.
+    ...cliHygieneEnv()
+  };
+  if (opts?.effort) {
+    env.CLAUDE_CODE_EFFORT_LEVEL = cliEffortLevel(opts.effort);
   }
-};
-var BTW_COMMAND_DESCRIPTION = "Ask a side question in the live Claude Code session without changing its context";
-var BTW_NO_SESSION_MESSAGE = "/btw needs a live Claude Code session in this conversation. Send a normal message with a Claude Code model first, then ask again.";
-var BTW_INLINE_HANDLED_MESSAGE = "/btw was answered inside the running turn; nothing to add to this conversation.";
-var BTW_TURN_TOO_LONG_MESSAGE = "/btw gave up waiting for this turn to end. Ask again once it is over.";
-var IDLE_POLL_MS = 500;
-var IDLE_WAIT_MAX_MS = 30 * 6e4;
-var BUSY_SETTLE_MS = 1500;
-var SPAWN_WAIT_MAX_MS = 3e4;
-var INLINE_POLL_MS = 200;
-var INLINE_WAIT_MAX_MS = 2e4;
-var PENDING_ANSWER_TTL_MS = 10 * 6e4;
-var PENDING_ANSWER_CAP = 32;
-var pendingAnswers = /* @__PURE__ */ new Map();
-function rememberSideQuestionAnswer(sessionID, question, answer, now = Date.now()) {
-  for (const [id, entry] of pendingAnswers) {
-    if (now - entry.at > PENDING_ANSWER_TTL_MS) pendingAnswers.delete(id);
+  if (opts?.promptCacheTtl) {
+    env.CLAUDE_CODE_PROMPT_CACHE_TTL = opts.promptCacheTtl;
   }
-  pendingAnswers.delete(sessionID);
-  while (pendingAnswers.size >= PENDING_ANSWER_CAP) {
-    const oldest = pendingAnswers.keys().next().value;
-    if (oldest === void 0) break;
-    pendingAnswers.delete(oldest);
+  if (opts?.ignoreAnthropicApiKey) {
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_AUTH_TOKEN;
   }
-  pendingAnswers.set(sessionID, { question: question.trim(), answer, at: now });
+  if (!isClaudeThinkingDisabled() && process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0) {
+    env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES = "1";
+  }
+  return env;
 }
-function takeSideQuestionAnswer(sessionID, question, now = Date.now()) {
-  const entry = pendingAnswers.get(sessionID);
-  if (!entry) return void 0;
-  pendingAnswers.delete(sessionID);
-  if (!question.trim().startsWith(entry.question) || now - entry.at > PENDING_ANSWER_TTL_MS) return void 0;
-  return entry.answer;
+function touch(key) {
+  const existing = activeProcesses.get(key);
+  if (existing) {
+    activeProcesses.delete(key);
+    activeProcesses.set(key, existing);
+  }
+}
+function evictIfNeeded() {
+  while (activeProcesses.size >= MAX_ACTIVE_PROCESSES) {
+    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 INLINE_ASIDE_MARKER = "\u258C **btw:**";
-var LEGACY_INLINE_ASIDE_MARKERS = ["> **btw:**"];
-function barEveryLine(text) {
-  return text.split("\n").map((line) => line.trim() === "" ? "\u258C" : `\u258C ${line}`).join("\n");
+var TURN_INTERRUPT_TIMEOUT_MS = 5e3;
+function isTerminalResultLine(line) {
+  if (!line.includes('"result"')) return false;
+  try {
+    return JSON.parse(line).type === "result";
+  } catch {
+    return false;
+  }
 }
-function oneLine(question) {
-  return question.replace(/\s+/g, " ").trim();
+function settleTurn(ap) {
+  ap.turnInFlight = false;
+  const waiters = ap.turnIdleWaiters ?? [];
+  ap.turnIdleWaiters = [];
+  for (const wake of waiters) wake();
 }
-function asideHeader(question) {
-  return `${INLINE_ASIDE_MARKER} ${oneLine(question)}`;
+function noteTurnStarted(ap) {
+  if (ap.asideTransport?.interactive) return;
+  ap.turnInFlight = true;
 }
-function formatInlineAside(question, answer) {
-  return `
-${asideHeader(question)}
-\u258C
-${barEveryLine(answer.trim())}
-`;
+function noteTurnLine(ap, line) {
+  if (!ap.turnInFlight) return;
+  if (isTerminalResultLine(line)) settleTurn(ap);
 }
-var INLINE_ASIDE_SENT_NOTE = "*sent to Claude on the side*";
-function formatInlineAsideAsk(question) {
-  return `
-${asideHeader(question)}
-\u258C ${INLINE_ASIDE_SENT_NOTE}
-`;
+function isTurnInFlight(ap) {
+  return ap.turnInFlight === true;
 }
-var asideSinks = /* @__PURE__ */ new Map();
-function registerAsideSink(sessionID, sink) {
-  asideSinks.set(sessionID, sink);
-  return () => {
-    if (asideSinks.get(sessionID) === sink) asideSinks.delete(sessionID);
-  };
+function awaitTurnIdle(ap, timeoutMs) {
+  if (!ap.turnInFlight) return Promise.resolve(true);
+  return new Promise((resolve6) => {
+    const wake = () => {
+      clearTimeout(timer);
+      resolve6(true);
+    };
+    const timer = setTimeout(() => {
+      const waiters = ap.turnIdleWaiters ?? [];
+      const at = waiters.indexOf(wake);
+      if (at >= 0) waiters.splice(at, 1);
+      resolve6(false);
+    }, timeoutMs);
+    (ap.turnIdleWaiters ??= []).push(wake);
+  });
 }
-function emitAsideInline(sessionID, text) {
-  const sink = asideSinks.get(sessionID);
-  if (!sink) return false;
-  try {
-    return sink(text);
-  } catch (error) {
-    log.debug("btw: could not write the aside into the running turn", { sessionID, error: errorText(error) });
-    return false;
+function interruptTurn(ap, timeoutMs = TURN_INTERRUPT_TIMEOUT_MS) {
+  if (!ap.turnInFlight) return Promise.resolve(true);
+  const stdin = ap.proc.stdin;
+  if (ap.asideTransport?.interactive || !stdin || !stdin.writable) {
+    log.notice("cannot interrupt this transport; waiting for the turn to end");
+    return awaitTurnIdle(ap, timeoutMs);
   }
-}
-function showToast(client, body) {
   try {
-    void client?.tui?.showToast?.({ body })?.catch((error) => {
-      log.debug("btw toast failed", { error: errorText(error) });
-    });
+    stdin.write(
+      JSON.stringify({
+        type: "control_request",
+        request_id: randomUUID3(),
+        request: { subtype: "interrupt" }
+      }) + "\n"
+    );
   } catch (error) {
-    log.debug("btw toast failed", { error: errorText(error) });
+    log.warn("failed to write interrupt control request", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return Promise.resolve(false);
   }
+  return awaitTurnIdle(ap, timeoutMs);
 }
-function isProcessBusy(active) {
-  return active.lineEmitter.listenerCount("line") > 0;
+function cancelIdleProcessEviction(key) {
+  const timer = idleEvictionTimers.get(key);
+  if (!timer) return;
+  clearTimeout(timer);
+  idleEvictionTimers.delete(key);
 }
-async function sessionStatus(client, sessionID) {
-  const status = client?.session?.status;
-  if (!status) return "unknown";
-  try {
-    const result = await status.call(client.session);
-    const entry = result.data?.[sessionID];
-    return entry && entry.type !== "idle" ? "busy" : "idle";
-  } catch (error) {
-    log.debug("btw: could not read session status", { sessionID, error: errorText(error) });
-    return "unknown";
+function getActiveProcess(key) {
+  const ap = activeProcesses.get(key);
+  if (ap) {
+    cancelIdleProcessEviction(key);
+    touch(key);
   }
+  return ap;
 }
-async function waitForSessionIdle(client, sessionID, options = {}) {
-  const pollMs = options.pollMs ?? IDLE_POLL_MS;
-  const timeoutMs = options.timeoutMs ?? IDLE_WAIT_MAX_MS;
-  const started = Date.now();
-  for (; ; ) {
-    if (options.stop?.()) return true;
-    if (await sessionStatus(client, sessionID) !== "busy") return true;
-    if (Date.now() - started >= timeoutMs) return false;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+function setActiveProcess(key, ap) {
+  cancelIdleProcessEviction(key);
+  activeProcesses.set(key, ap);
+}
+function scheduleIdleProcessEviction(key, timeoutMs) {
+  cancelIdleProcessEviction(key);
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_IDLE_TIMEOUT_MS) {
+    return;
   }
+  const scheduledProcess = activeProcesses.get(key);
+  if (!scheduledProcess) return;
+  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);
+  timer.unref();
+  idleEvictionTimers.set(key, timer);
 }
-async function deliverAsideInline(client, sessionID, text, options = {}) {
-  const pollMs = options.inlinePollMs ?? INLINE_POLL_MS;
-  const timeoutMs = options.inlineWaitMs ?? INLINE_WAIT_MAX_MS;
-  const started = Date.now();
-  for (; ; ) {
-    if (emitAsideInline(sessionID, text)) return true;
-    if (Date.now() - started >= timeoutMs) return false;
-    if (await sessionStatus(client, sessionID) !== "busy") return false;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+function detachActiveProcess(key) {
+  cancelIdleProcessEviction(key);
+  const ap = activeProcesses.get(key);
+  if (!ap) return void 0;
+  activeProcesses.delete(key);
+  if (ap.proxyServer) {
+    void ap.proxyServer.close();
+    rejectAllPendingProxyCallsForSession(key, new Error(SERVER_CLOSED_MESSAGE));
   }
+  return ap;
 }
-async function waitForAsideProcess(client, sessionID, options = {}) {
-  const pollMs = options.pollMs ?? IDLE_POLL_MS;
-  const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
-  const spawnWaitMs = options.spawnWaitMs ?? SPAWN_WAIT_MAX_MS;
-  const started = Date.now();
-  for (; ; ) {
-    const active = findActiveProcessBySessionId(sessionID);
-    if (active) return active;
-    const busy = await sessionStatus(client, sessionID) === "busy";
-    const waitedMs = Date.now() - started;
-    if (!busy && waitedMs >= settleMs) {
-      log.info("btw: no live claude process for session, leaving it to the turn", { sessionID, waitedMs });
-      return void 0;
-    }
-    if (busy && waitedMs >= spawnWaitMs) {
-      log.warn("btw: a turn is running but no claude process appeared for it", { sessionID, waitedMs });
-      return void 0;
-    }
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
+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);
   }
+  for (const key of released) clearBackgroundTasks(key);
+  return released;
+}
+function killAllActiveProcesses() {
+  const keys = [...activeProcesses.keys()];
+  for (const key of keys) deleteActiveProcess(key);
+  for (const key of keys) clearBackgroundTasks(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();
+}
+function hasProcessExited(proc) {
+  return proc.exitCode !== null || proc.signalCode !== null;
+}
+function waitForProcessExit(proc, timeoutMs) {
+  if (hasProcessExited(proc)) return Promise.resolve(true);
+  return new Promise((resolve6) => {
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve6(true);
+    };
+    const timer = setTimeout(() => {
+      proc.off("exit", onExit);
+      resolve6(hasProcessExited(proc));
+    }, timeoutMs);
+    proc.once("exit", onExit);
+  });
+}
+async function deleteActiveProcessAndWait(key, options = {}) {
+  const ap = detachActiveProcess(key);
+  if (!ap || hasProcessExited(ap.proc)) return true;
+  const gracefulExit = waitForProcessExit(
+    ap.proc,
+    options.exitTimeoutMs ?? PROCESS_EXIT_TIMEOUT_MS
+  );
+  ap.proc.kill();
+  if (await gracefulExit) return true;
+  const forcedExit = waitForProcessExit(
+    ap.proc,
+    options.forceExitTimeoutMs ?? PROCESS_FORCE_EXIT_TIMEOUT_MS
+  );
+  ap.proc.kill("SIGKILL");
+  if (await forcedExit) return true;
+  log.warn("claude process did not exit; starting a fresh session", {
+    sessionKey: key
+  });
+  deleteClaudeSessionId(key);
+  return false;
 }
-async function settleSessionBusy(client, sessionID, active, options = {}) {
-  const pollMs = options.pollMs ?? IDLE_POLL_MS;
-  const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
-  const started = Date.now();
-  for (; ; ) {
-    const status = await sessionStatus(client, sessionID);
-    if (status === "busy") return true;
-    if (status === "unknown") return isProcessBusy(active);
-    if (Date.now() - started >= settleMs) return false;
-    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
-  }
+function getClaudeSessionId(key) {
+  return claudeSessions.get(key);
 }
-function errorText(error) {
-  if (error instanceof Error) return error.message;
-  if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
-    return error.message;
+var MAX_CLAUDE_SESSION_ENTRIES = 64;
+function claudeSessionIsBusy(key) {
+  if (activeProcesses.has(key)) return true;
+  return getPendingProxyCalls(key).length > 0 || hasExitPlanModeQuestions(key);
+}
+function capClaudeSessions() {
+  for (const key of [...claudeSessions.keys()]) {
+    if (claudeSessions.size <= MAX_CLAUDE_SESSION_ENTRIES) return;
+    if (claudeSessionIsBusy(key)) continue;
+    log.info("claude session cap reached; releasing an idle session", {
+      sessionKey: key,
+      size: claudeSessions.size,
+      cap: MAX_CLAUDE_SESSION_ENTRIES
+    });
+    deleteClaudeSessionId(key);
   }
-  return String(error);
 }
-function isTextPart(part) {
-  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string";
+function setClaudeSessionId(key, sessionId) {
+  claudeSessions.delete(key);
+  claudeSessions.set(key, sessionId);
+  capClaudeSessions();
 }
-async function fetchAsideHistory(client, sessionID, question) {
-  const messages = client?.session?.messages;
-  if (!messages) return [];
-  try {
-    const result = await messages.call(client.session, { path: { id: sessionID } });
-    const prompt = [];
-    for (const message of result.data ?? []) {
-      const role = message.info?.role;
-      if (role !== "user" && role !== "assistant") continue;
-      prompt.push({ role, content: (message.parts ?? []).filter(isTextPart) });
-    }
-    prompt.push({ role: "user", content: `/btw ${question}` });
-    return collectSideQuestionHistory(prompt);
-  } catch (error) {
-    log.debug("btw: could not read aside history", { sessionID, error: errorText(error) });
-    return [];
-  }
+function deleteClaudeSessionId(key) {
+  clearExitPlanModeQuestions(key);
+  clearAccountFailoverQuestions(key);
+  const claudeSessionId = claudeSessions.get(key);
+  if (claudeSessionId) clearLedger(claudeSessionId);
+  claudeSessions.delete(key);
 }
-async function handleBtwCommand(client, input, options = {}) {
-  const question = input.arguments.trim();
-  if (!question) {
-    showToast(client, { title: "btw", message: SIDE_QUESTION_USAGE, variant: "warning", duration: 6e3 });
-    throw new BtwHandledError("/btw needs a question.");
+function effortSessionKey(baseKey, effort) {
+  return effort ? `${baseKey}::effort=${effort}` : baseKey;
+}
+function invalidateOtherEffortSessions(baseKey, effort) {
+  const levels = [
+    void 0,
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ];
+  const staleKeys = levels.filter((level) => level !== effort).map((level) => effortSessionKey(baseKey, level));
+  for (const key of staleKeys) {
+    const active = activeProcesses.get(key);
+    if (getPendingProxyCalls(key).length || hasExitPlanModeQuestions(key) || active?.pendingProxyCompletions?.size || active && (active.lineEmitter.listenerCount("line") > 0 || isSideQuestionPending(active))) {
+      throw new Error(
+        "Cannot change reasoning effort while the previous effort session has pending work. Finish that work at its original effort first."
+      );
+    }
   }
-  const active = await waitForAsideProcess(client, input.sessionID, options);
-  const transport = active?.asideTransport;
-  if (!active || !transport) {
-    if (active) log.info("btw: process has no aside transport, leaving it to the turn", { sessionID: input.sessionID });
-    return;
+  for (const key of staleKeys) {
+    deleteActiveProcess(key);
+    deleteClaudeSessionId(key);
+    clearCompression(key);
+    clearBackgroundTasks(key);
   }
-  let busy = false;
-  let inlineDone = false;
-  let markInlineDelivered = () => {
+}
+function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort, promptCacheTtl) {
+  evictIfNeeded();
+  log.info("spawning new claude process", {
+    cliPath,
+    cliArgs,
+    cwd,
+    sessionKey: sessionKey2,
+    effort,
+    promptCacheTtl
+  });
+  const proc = spawn(cliPath, cliArgs, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort, promptCacheTtl }),
+    shell: process.platform === "win32"
+  });
+  const lineEmitter = new EventEmitter3();
+  const ap = {
+    proc,
+    lineEmitter,
+    proxyServer: proxyServer ?? null,
+    mcpHash,
+    systemPromptFile,
+    effort,
+    promptCacheTtl,
+    startedAt: Date.now(),
+    cliPath,
+    cliArgs: [...cliArgs],
+    unattendedLines: [],
+    unattendedDropped: 0
   };
-  const inlineDelivered = new Promise((resolve6) => {
-    markInlineDelivered = () => {
-      inlineDone = true;
-      resolve6("inline");
-    };
+  const rl = createInterface({ input: proc.stdout });
+  rl.on("line", (line) => {
+    if (dispatchSideQuestionResponse(ap, line)) return;
+    noteTurnLine(ap, line);
+    if (lineEmitter.listenerCount("line") === 0) {
+      bufferUnattendedLine(ap, line);
+      return;
+    }
+    lineEmitter.emit("line", line);
   });
-  if (isSideQuestionPending(active)) {
-    busy = await settleSessionBusy(client, input.sessionID, active, options);
-    log.info("btw: an aside is already in flight, leaving this one to the turn", { sessionID: input.sessionID, busy });
-  } else {
-    const settling = settleSessionBusy(client, input.sessionID, active, options);
-    const history = await fetchAsideHistory(client, input.sessionID, question);
-    const answer = requestSideQuestion(active, question, {
-      cliVersion: await detectCliVersion(transport.cliPath),
-      interactive: transport.interactive,
-      ...history.length ? { history } : {}
-    });
-    answer.catch(() => void 0);
-    rememberSideQuestionAnswer(input.sessionID, question, answer);
-    busy = await settling;
-    log.info("btw: aside sent ahead of its message", {
-      sessionID: input.sessionID,
-      busy,
-      questionLength: question.length,
-      history: history.length
-    });
-    const asked = busy ? deliverAsideInline(client, input.sessionID, formatInlineAsideAsk(question), options).catch(() => false) : Promise.resolve(false);
-    answer.then(
-      async (result) => {
-        log.info("btw: early answer arrived", { sessionID: input.sessionID, busy, responseLength: result.response.length });
-        if (!busy || result.synthetic) return;
-        await asked;
-        const inline = await deliverAsideInline(
-          client,
-          input.sessionID,
-          formatInlineAside(question, result.response),
-          options
-        );
-        if (inline) {
-          log.info("btw: answer written into the running turn", { sessionID: input.sessionID });
-          markInlineDelivered();
-          return;
-        }
-        log.info("btw: no open stream for the answer; the held message will carry it", {
-          sessionID: input.sessionID
-        });
-      },
-      (error) => {
-        log.warn("btw: early aside failed; the message will ask again", {
-          sessionID: input.sessionID,
-          error: errorText(error)
-        });
-      }
-    );
-  }
-  if (!busy) return;
-  const started = Date.now();
-  const outcome = await Promise.race([
-    inlineDelivered,
-    waitForSessionIdle(client, input.sessionID, { ...options, stop: () => inlineDone }).then(
-      (idle) => idle ? "idle" : "timeout"
-    )
-  ]);
-  if (outcome === "inline") {
-    log.info("btw: answered inside the running turn, dropping the /btw message", {
-      sessionID: input.sessionID,
-      waitedMs: Date.now() - started
-    });
-    throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
-  }
-  log.info("btw: turn over, releasing the /btw message", {
-    sessionID: input.sessionID,
-    idle: outcome === "idle",
-    waitedMs: Date.now() - started
+  rl.on("close", () => {
+    settleTurn(ap);
+    lineEmitter.emit("close");
   });
-  if (outcome === "timeout") {
-    showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
-    throw new BtwHandledError(BTW_TURN_TOO_LONG_MESSAGE);
-  }
-}
-
-// src/plan-usage.ts
-import { execFile as execFile2 } from "child_process";
-var PLAN_USAGE_ARGUMENTS = /* @__PURE__ */ new Set(["usage", "cost", "stats", "limits"]);
-function wantsPlanUsage(argument) {
-  return PLAN_USAGE_ARGUMENTS.has(argument.trim().toLowerCase());
-}
-var PLAN_USAGE_MAX_CHARS = 4e3;
-function truncate(text) {
-  return text.length <= PLAN_USAGE_MAX_CHARS ? text : `${text.slice(0, PLAN_USAGE_MAX_CHARS)}
-[truncated]`;
-}
-function parsePlanUsage(stdout) {
-  const trimmed = stdout.trim();
-  if (!trimmed) return { status: "failed", error: "the CLI printed nothing" };
-  const candidates = trimmed.split("\n").reverse();
-  for (const line of candidates) {
-    const start = line.indexOf("{");
-    if (start === -1) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line.slice(start));
-    } catch {
-      continue;
+  cancelIdleProcessEviction(sessionKey2);
+  activeProcesses.set(sessionKey2, ap);
+  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();
+    if (systemPromptFile) {
+      void unlink(systemPromptFile).catch(() => {
+      });
     }
-    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) continue;
-    const record = parsed;
-    if (record.type !== void 0 && record.type !== "result") continue;
-    const text = typeof record.result === "string" ? record.result.trim() : "";
-    if (record.is_error === true) {
-      return { status: "failed", error: text || "the CLI reported an error" };
+    const ownsSessionKey = activeProcesses.get(sessionKey2) === ap;
+    if (ownsSessionKey) {
+      cancelIdleProcessEviction(sessionKey2);
+      activeProcesses.delete(sessionKey2);
+      if (getPendingProxyCalls(sessionKey2).length > 0) {
+        rejectAllPendingProxyCallsForSession(
+          sessionKey2,
+          new Error(CHILD_EXITED_MESSAGE)
+        );
+      }
     }
-    if (!text) continue;
-    return {
-      status: "ok",
-      text: truncate(text),
-      costUsd: typeof record.total_cost_usd === "number" ? record.total_cost_usd : 0,
-      numTurns: typeof record.num_turns === "number" ? record.num_turns : 0
-    };
-  }
-  return { status: "failed", error: "no result object in the CLI's reply" };
-}
-function runCli(cliPath, args, timeoutMs, env) {
-  return new Promise((resolve6, reject) => {
-    execFile2(
-      cliPath,
-      args,
-      // `killSignal` so a CLI wedged on a hook is actually gone, and a generous
-      // buffer because the reply is prose of unbounded length.
-      { timeout: timeoutMs, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024, env },
-      (error, stdout) => {
-        if (stdout && stdout.trim()) return resolve6(stdout);
-        if (error) return reject(error);
-        resolve6(stdout ?? "");
+    if (ownsSessionKey && code !== 0 && code !== null) {
+      log.info("process exited with error, clearing session", {
+        code,
+        sessionKey: sessionKey2
+      });
+      claudeSessions.delete(sessionKey2);
+    }
+  });
+  proc.stderr?.on("data", (data) => {
+    const stderr = data.toString();
+    log.debug("stderr", { data: stderr.slice(0, 200) });
+    retainStderr(ap, stderr);
+    reportUnrecognizedModel(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", {
+          sessionKey: sessionKey2,
+          error: stderr.slice(0, 200)
+        });
+        claudeSessions.delete(sessionKey2);
+      } else {
+        log.debug("ignoring session ID error from stale claude process", {
+          sessionKey: sessionKey2
+        });
       }
-    );
+    }
   });
+  return ap;
 }
-async function fetchPlanUsage(cliPath, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 2e4;
-  const run = options.runImpl ?? runCli;
-  try {
-    const env = claudeSpawnEnv({ ignoreAnthropicApiKey: options.ignoreAnthropicApiKey });
-    const stdout = await run(
-      cliPath,
-      ["-p", "/cost", "--output-format", "json"],
-      timeoutMs,
-      env
-    );
-    const usage = parsePlanUsage(stdout);
-    if (usage.status === "ok") {
-      log.info("read claude plan usage", { costUsd: usage.costUsd, numTurns: usage.numTurns });
-    } else if (usage.status === "failed") {
-      log.debug("could not read claude plan usage", { error: usage.error });
-    }
-    return usage;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    log.debug("could not read claude plan usage", { error: message });
-    return { status: "failed", error: message };
+function appendResumeIfNeeded(sessionKey2, cliArgs) {
+  if (cliArgs.includes("--resume") || cliArgs.includes("--session-id")) {
+    return cliArgs;
   }
+  const sid = claudeSessions.get(sessionKey2);
+  if (!sid) return cliArgs;
+  return [...cliArgs, "--resume", sid];
 }
-
-// src/startup-diagnostics.ts
-import { execFile as execFile3 } from "child_process";
-import * as fs4 from "fs";
-import * as path5 from "path";
-import { promisify as promisify2 } from "util";
-import { fileURLToPath } from "url";
-
-// src/mcp-bridge.ts
-import * as fs3 from "fs";
-import * as path4 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) {
+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 {
-    return fs3.statSync(p).isFile();
+    old.proc.kill();
   } catch {
-    return false;
   }
+  const replacement = spawnClaudeProcess(
+    cliPath,
+    appendResumeIfNeeded(sessionKey2, old.cliArgs ?? cliArgs),
+    cwd,
+    sessionKey2,
+    old.proxyServer,
+    old.mcpHash,
+    old.systemPromptFile,
+    ignoreAnthropicApiKey,
+    old.effort,
+    old.promptCacheTtl
+  );
+  replacement.mcpServers = old.mcpServers;
+  replacement.pendingProxyCompletions = old.pendingProxyCompletions;
+  delete old.pendingProxyCompletions;
+  if (turnWasInFlight) noteTurnStarted(replacement);
+  return replacement;
 }
-function dirExists(p) {
-  try {
-    return fs3.statSync(p).isDirectory();
-  } catch {
-    return false;
+function buildCliArgs(opts) {
+  const {
+    sessionKey: sessionKey2,
+    skipPermissions,
+    includeSessionId = true,
+    model,
+    permissionMode,
+    mcpConfig,
+    strictMcpConfig,
+    disallowedTools,
+    appendSystemPromptFile,
+    pluginDirs,
+    thinking,
+    thinkingDisplay,
+    fastMode,
+    cliVersion
+  } = opts;
+  const args = [
+    "--print",
+    "--output-format",
+    "stream-json",
+    "--input-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--verbose"
+  ];
+  if (model) {
+    args.push("--model", model);
   }
-}
-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}`
+  const readOnly = isReadOnlyPermissionMode(permissionMode);
+  if (readOnly) {
+    if (cliSupportsRestricted(cliVersion ?? null)) {
+      args.push("--restricted");
+    } else {
+      log.warn(
+        'permissionPreset "read-only": this claude CLI has no --restricted (2.1.258+), so file reads are not confined to the working directory. The mutating tools are still refused via --disallowedTools and every permission request is denied.',
+        { cliVersion: cliVersion?.raw ?? "unknown" }
       );
     }
-    return parsed;
-  } catch (e) {
-    log.warn("failed to parse opencode config", {
-      file,
-      error: e instanceof Error ? e.message : String(e)
-    });
-    return null;
+    if (cliSupportsPermissionPrompts(cliVersion ?? null)) {
+      args.push("--permission-prompts", "none");
+    } else {
+      log.warn(
+        `permissionPreset "read-only": this claude CLI has no --permission-prompts (2.1.263+), so permission requests are denied by the plugin's own can_use_tool handler instead of by the CLI. Same outcome, one layer fewer.`,
+        { cliVersion: cliVersion?.raw ?? "unknown" }
+      );
+    }
+  } else if (permissionMode) {
+    args.push("--permission-mode", permissionMode);
+  }
+  if (includeSessionId) {
+    const sessionId = claudeSessions.get(sessionKey2);
+    if (sessionId && !activeProcesses.has(sessionKey2)) {
+      args.push("--resume", sessionId);
+    }
+  }
+  if (mcpConfig) {
+    const configs = Array.isArray(mcpConfig) ? mcpConfig : [mcpConfig];
+    const filtered = configs.filter((c) => typeof c === "string" && c.length > 0);
+    if (filtered.length > 0) {
+      args.push("--mcp-config", ...filtered);
+    }
+  }
+  if (strictMcpConfig) {
+    args.push("--strict-mcp-config");
+  }
+  if (disallowedTools && disallowedTools.length > 0) {
+    args.push("--disallowedTools", ...disallowedTools);
+  }
+  if (thinking && cliSupportsThinking(cliVersion ?? null)) {
+    args.push("--thinking", thinking);
+  }
+  if (thinkingDisplay && cliSupportsThinkingDisplay(cliVersion ?? null)) {
+    args.push("--thinking-display", thinkingDisplay);
+  }
+  if (appendSystemPromptFile) {
+    args.push("--append-system-prompt-file", appendSystemPromptFile);
+  }
+  for (const dir of pluginDirs ?? []) {
+    args.push("--plugin-dir", dir);
+  }
+  if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
+    args.push("--settings", JSON.stringify({ fastMode: true }));
+  }
+  if (skipPermissions && permissionMode !== "plan" && !readOnly) {
+    args.push("--dangerously-skip-permissions");
   }
+  return args;
 }
-function isPlainObject(x) {
-  return typeof x === "object" && x !== null && !Array.isArray(x);
+function sessionKey(cwd, modelId) {
+  return `${cwd}::${modelId}`;
 }
-function deepMerge(target, source) {
-  const out = { ...target };
-  for (const [k, v] of Object.entries(source)) {
-    if (v === void 0) continue;
-    const existing = out[k];
-    if (isPlainObject(existing) && isPlainObject(v)) {
-      out[k] = deepMerge(existing, v);
-    } else {
-      out[k] = v;
-    }
-  }
-  return out;
+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 walkUp(opts) {
+function snapshotActiveProcesses(now = Date.now()) {
   const out = [];
-  let current = path4.resolve(opts.start);
-  while (true) {
-    for (const target of opts.targets) {
-      const candidate = path4.join(current, target);
-      if (opts.predicate(candidate)) out.push(candidate);
-    }
-    if (opts.stop && current === path4.resolve(opts.stop)) break;
-    const parent = path4.dirname(current);
-    if (parent === current) break;
-    current = parent;
+  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;
 }
-function detectWorktree(cwd) {
-  const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path4.resolve(override);
-  let current = path4.resolve(cwd);
-  while (true) {
-    const gitPath = path4.join(current, ".git");
-    try {
-      if (fs3.existsSync(gitPath)) return current;
-    } catch {
-    }
-    const parent = path4.dirname(current);
-    if (parent === current) return void 0;
-    current = parent;
+
+// src/btw-command.ts
+var BtwHandledError = class extends Error {
+  name = "BtwHandledError";
+  constructor(message = "/btw was handled by the claude-code plugin; nothing to add to this conversation.") {
+    super(message);
+  }
+};
+var BTW_COMMAND_DESCRIPTION = "Ask a side question in the live Claude Code session without changing its context";
+var BTW_NO_SESSION_MESSAGE = "/btw needs a live Claude Code session in this conversation. Send a normal message with a Claude Code model first, then ask again.";
+var BTW_INLINE_HANDLED_MESSAGE = "/btw was answered inside the running turn; nothing to add to this conversation.";
+var BTW_TURN_TOO_LONG_MESSAGE = "/btw gave up waiting for this turn to end. Ask again once it is over.";
+var IDLE_POLL_MS = 500;
+var IDLE_WAIT_MAX_MS = 30 * 6e4;
+var BUSY_SETTLE_MS = 1500;
+var SPAWN_WAIT_MAX_MS = 3e4;
+var INLINE_POLL_MS = 200;
+var INLINE_WAIT_MAX_MS = 2e4;
+var PENDING_ANSWER_TTL_MS = 10 * 6e4;
+var PENDING_ANSWER_CAP = 32;
+var pendingAnswers = /* @__PURE__ */ new Map();
+function rememberSideQuestionAnswer(sessionID, question, answer, now = Date.now()) {
+  for (const [id, entry] of pendingAnswers) {
+    if (now - entry.at > PENDING_ANSWER_TTL_MS) pendingAnswers.delete(id);
+  }
+  pendingAnswers.delete(sessionID);
+  while (pendingAnswers.size >= PENDING_ANSWER_CAP) {
+    const oldest = pendingAnswers.keys().next().value;
+    if (oldest === void 0) break;
+    pendingAnswers.delete(oldest);
   }
+  pendingAnswers.set(sessionID, { question: question.trim(), answer, at: now });
 }
-function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path4.join(os2.homedir(), ".config");
-  return path4.join(xdg, "opencode");
+function takeSideQuestionAnswer(sessionID, question, now = Date.now()) {
+  const entry = pendingAnswers.get(sessionID);
+  if (!entry) return void 0;
+  pendingAnswers.delete(sessionID);
+  if (!question.trim().startsWith(entry.question) || now - entry.at > PENDING_ANSWER_TTL_MS) return void 0;
+  return entry.answer;
 }
-function loadGlobalConfig(hostApi = "v1") {
-  const dir = globalConfigDir();
-  let merged = {};
-  for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path4.join(dir, name);
-    if (!fileExists(file)) continue;
-    const parsed = readAndParse(file);
-    if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
-  }
-  return merged;
+var INLINE_ASIDE_MARKER = "\u258C **btw:**";
+var LEGACY_INLINE_ASIDE_MARKERS = ["> **btw:**"];
+function barEveryLine(text) {
+  return text.split("\n").map((line) => line.trim() === "" ? "\u258C" : `\u258C ${line}`).join("\n");
 }
-function loadProjectFilesInDir(dir, hostApi = "v1") {
-  let merged = {};
-  for (const name of PROJECT_FILE_NAMES) {
-    const file = path4.join(dir, name);
-    if (!fileExists(file)) continue;
-    const parsed = readAndParse(file);
-    if (parsed) merged = mergeConfigLayer(merged, parsed, hostApi);
-  }
-  return merged;
+function oneLine(question) {
+  return question.replace(/\s+/g, " ").trim();
 }
-function dotOpencodeDirs(cwd, worktree) {
-  const dirs = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (p) => {
-    const abs = path4.resolve(p);
-    if (!seen.has(abs) && dirExists(abs)) {
-      seen.add(abs);
-      dirs.push(abs);
-    }
+function asideHeader(question) {
+  return `${INLINE_ASIDE_MARKER} ${oneLine(question)}`;
+}
+function formatInlineAside(question, answer) {
+  return `
+${asideHeader(question)}
+\u258C
+${barEveryLine(answer.trim())}
+`;
+}
+var INLINE_ASIDE_SENT_NOTE = "*sent to Claude on the side*";
+function formatInlineAsideAsk(question) {
+  return `
+${asideHeader(question)}
+\u258C ${INLINE_ASIDE_SENT_NOTE}
+`;
+}
+var asideSinks = /* @__PURE__ */ new Map();
+function registerAsideSink(sessionID, sink) {
+  asideSinks.set(sessionID, sink);
+  return () => {
+    if (asideSinks.get(sessionID) === sink) asideSinks.delete(sessionID);
   };
-  for (const dir of walkUp({
-    start: cwd,
-    stop: worktree,
-    targets: [".opencode"],
-    predicate: dirExists
-  })) {
-    push(dir);
-  }
-  const home = os2.homedir();
-  if (home) {
-    const homeDot = path4.join(home, ".opencode");
-    if (dirExists(homeDot)) push(homeDot);
+}
+function emitAsideInline(sessionID, text) {
+  const sink = asideSinks.get(sessionID);
+  if (!sink) return false;
+  try {
+    return sink(text);
+  } catch (error) {
+    log.debug("btw: could not write the aside into the running turn", { sessionID, error: errorText(error) });
+    return false;
   }
-  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 : "";
+function showToast(client, body) {
+  try {
+    void client?.tui?.showToast?.({ body })?.catch((error) => {
+      log.debug("btw toast failed", { error: errorText(error) });
     });
+  } catch (error) {
+    log.debug("btw toast failed", { error: errorText(error) });
   }
-  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;
+function isProcessBusy(active) {
+  return active.lineEmitter.listenerCount("line") > 0;
+}
+async function sessionStatus(client, sessionID) {
+  const status = client?.session?.status;
+  if (!status) return "unknown";
+  try {
+    const result = await status.call(client.session);
+    const entry = result.data?.[sessionID];
+    return entry && entry.type !== "idle" ? "busy" : "idle";
+  } catch (error) {
+    log.debug("btw: could not read session status", { sessionID, error: errorText(error) });
+    return "unknown";
   }
-  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;
+}
+async function waitForSessionIdle(client, sessionID, options = {}) {
+  const pollMs = options.pollMs ?? IDLE_POLL_MS;
+  const timeoutMs = options.timeoutMs ?? IDLE_WAIT_MAX_MS;
+  const started = Date.now();
+  for (; ; ) {
+    if (options.stop?.()) return true;
+    if (await sessionStatus(client, sessionID) !== "busy") return true;
+    if (Date.now() - started >= timeoutMs) return false;
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
-  log.warn("skipping MCP server with unknown type", {
-    name,
-    type: type ?? null
-  });
-  return null;
-}
-function extractMcpBlock(config) {
-  const mcp = config.mcp;
-  if (!isPlainObject(mcp)) return {};
-  if ("servers" in mcp && !isPlainObject(mcp.servers)) return {};
-  const native = isPlainObject(mcp.servers) && typeof mcp.servers.type !== "string" && typeof mcp.servers.enabled !== "boolean" && typeof mcp.servers.disabled !== "boolean";
-  const block = native ? mcp.servers : mcp;
-  return Object.fromEntries(
-    Object.entries(block).filter(([name, spec]) => isPlainObject(spec) && (native || name !== "timeout" || typeof spec.type === "string")).map(([name, spec]) => {
-      const server2 = spec;
-      return [name, {
-        ...server2,
-        ...typeof server2.disabled === "boolean" ? { enabled: !server2.disabled } : {}
-      }];
-    })
-  );
 }
-function mergeConfigLayer(target, source, hostApi) {
-  const merged = deepMerge(target, source);
-  if (hostApi === "v2" && isPlainObject(source.mcp)) {
-    merged.mcp = {
-      ...isPlainObject(merged.mcp) ? merged.mcp : {},
-      servers: { ...extractMcpBlock(target), ...extractMcpBlock(source) }
-    };
+async function deliverAsideInline(client, sessionID, text, options = {}) {
+  const pollMs = options.inlinePollMs ?? INLINE_POLL_MS;
+  const timeoutMs = options.inlineWaitMs ?? INLINE_WAIT_MAX_MS;
+  const started = Date.now();
+  for (; ; ) {
+    if (emitAsideInline(sessionID, text)) return true;
+    if (Date.now() - started >= timeoutMs) return false;
+    if (await sessionStatus(client, sessionID) !== "busy") return false;
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
-  return merged;
 }
-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;
+async function waitForAsideProcess(client, sessionID, options = {}) {
+  const pollMs = options.pollMs ?? IDLE_POLL_MS;
+  const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
+  const spawnWaitMs = options.spawnWaitMs ?? SPAWN_WAIT_MAX_MS;
+  const started = Date.now();
+  for (; ; ) {
+    const active = findActiveProcessBySessionId(sessionID);
+    if (active) return active;
+    const busy = await sessionStatus(client, sessionID) === "busy";
+    const waitedMs = Date.now() - started;
+    if (!busy && waitedMs >= settleMs) {
+      log.info("btw: no live claude process for session, leaving it to the turn", { sessionID, waitedMs });
+      return void 0;
+    }
+    if (busy && waitedMs >= spawnWaitMs) {
+      log.warn("btw: a turn is running but no claude process appeared for it", { sessionID, waitedMs });
+      return void 0;
     }
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
-  return out;
 }
-function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers, hostApi = "v1") {
-  const {
-    servers: merged,
-    enabledServerNames: allEnabledServerNames,
-    hash
-  } = mergeOpencodeMcp(cwd, runtimeStatus, hostApi);
-  const servers = {};
-  const bridgedServerNames = [];
-  for (const [name, spec] of Object.entries(merged)) {
-    if (!spec || typeof spec !== "object") continue;
-    if (excludeServers?.has(name)) continue;
-    const translated = translateServer(name, spec);
-    if (translated) {
-      servers[name] = translated;
-      bridgedServerNames.push(name);
-    }
+async function settleSessionBusy(client, sessionID, active, options = {}) {
+  const pollMs = options.pollMs ?? IDLE_POLL_MS;
+  const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
+  const started = Date.now();
+  for (; ; ) {
+    const status = await sessionStatus(client, sessionID);
+    if (status === "busy") return true;
+    if (status === "unknown") return isProcessBusy(active);
+    if (Date.now() - started >= settleMs) return false;
+    await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
-  return finishBridge({
-    servers,
-    bridgedServerNames,
-    allEnabledServerNames,
-    hash,
-    excludeServers
-  });
 }
-function opencodeConfigLayers(cwd, hostApi = "v1") {
-  const worktree = hostApi === "v2" ? void 0 : detectWorktree(cwd);
-  const layers = [];
-  layers.push(loadGlobalConfig(hostApi));
-  const explicitConfig = process.env.OPENCODE_CONFIG;
-  if (explicitConfig && fileExists(explicitConfig)) {
-    const parsed = readAndParse(explicitConfig);
-    if (parsed) layers.push(parsed);
+function errorText(error) {
+  if (error instanceof Error) return error.message;
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return error.message;
   }
-  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 = path4.dirname(f);
-    if (!seenProjectDirs.has(d)) {
-      seenProjectDirs.add(d);
-      projectDirs.push(d);
+  return String(error);
+}
+function isTextPart(part) {
+  return part !== null && typeof part === "object" && part.type === "text" && typeof part.text === "string";
+}
+async function fetchAsideHistory(client, sessionID, question) {
+  const messages = client?.session?.messages;
+  if (!messages) return [];
+  try {
+    const result = await messages.call(client.session, { path: { id: sessionID } });
+    const prompt = [];
+    for (const message of result.data ?? []) {
+      const role = message.info?.role;
+      if (role !== "user" && role !== "assistant") continue;
+      prompt.push({ role, content: (message.parts ?? []).filter(isTextPart) });
     }
+    prompt.push({ role: "user", content: `/btw ${question}` });
+    return collectSideQuestionHistory(prompt);
+  } catch (error) {
+    log.debug("btw: could not read aside history", { sessionID, error: errorText(error) });
+    return [];
   }
-  for (const dir of projectDirs.slice().reverse()) {
-    layers.push(loadProjectFilesInDir(dir, hostApi));
+}
+async function handleBtwCommand(client, input, options = {}) {
+  const question = input.arguments.trim();
+  if (!question) {
+    showToast(client, { title: "btw", message: SIDE_QUESTION_USAGE, variant: "warning", duration: 6e3 });
+    throw new BtwHandledError("/btw needs a question.");
   }
-  if (hostApi === "v2") {
-    const dirs = walkUp({ start: cwd, targets: [".opencode"], predicate: dirExists }).reverse();
-    const extra = process.env.OPENCODE_CONFIG_DIR;
-    if (extra && dirExists(extra)) layers.push(loadProjectFilesInDir(extra, hostApi));
-    for (const dir of dirs) layers.push(loadProjectFilesInDir(dir, hostApi));
-  } else {
-    for (const dir of dotOpencodeDirs(cwd, worktree)) {
-      layers.push(loadProjectFilesInDir(dir));
-    }
+  const active = await waitForAsideProcess(client, input.sessionID, options);
+  const transport = active?.asideTransport;
+  if (!active || !transport) {
+    if (active) log.info("btw: process has no aside transport, leaving it to the turn", { sessionID: input.sessionID });
+    return;
   }
-  return layers;
-}
-function loadMergedOpencodeConfig(cwd, hostApi = "v1") {
-  let merged = {};
-  for (const layer of opencodeConfigLayers(cwd, hostApi)) merged = mergeConfigLayer(merged, layer, hostApi);
-  return merged;
-}
-function mergeOpencodeMcp(cwd, runtimeStatus, hostApi = "v1") {
-  let merged = {};
-  for (const layer of opencodeConfigLayers(cwd, hostApi)) {
-    const servers = extractMcpBlock(layer);
-    merged = hostApi === "v2" ? { ...merged, ...servers } : mergeMcp(merged, servers);
+  let busy = false;
+  let inlineDone = false;
+  let markInlineDelivered = () => {
+  };
+  const inlineDelivered = new Promise((resolve6) => {
+    markInlineDelivered = () => {
+      inlineDone = true;
+      resolve6("inline");
+    };
+  });
+  if (isSideQuestionPending(active)) {
+    busy = await settleSessionBusy(client, input.sessionID, active, options);
+    log.info("btw: an aside is already in flight, leaving this one to the turn", { sessionID: input.sessionID, busy });
+  } else {
+    const settling = settleSessionBusy(client, input.sessionID, active, options);
+    const history = await fetchAsideHistory(client, input.sessionID, question);
+    const answer = requestSideQuestion(active, question, {
+      cliVersion: await detectCliVersion(transport.cliPath),
+      interactive: transport.interactive,
+      ...history.length ? { history } : {}
+    });
+    answer.catch(() => void 0);
+    rememberSideQuestionAnswer(input.sessionID, question, answer);
+    busy = await settling;
+    log.info("btw: aside sent ahead of its message", {
+      sessionID: input.sessionID,
+      busy,
+      questionLength: question.length,
+      history: history.length
+    });
+    const asked = busy ? deliverAsideInline(client, input.sessionID, formatInlineAsideAsk(question), options).catch(() => false) : Promise.resolve(false);
+    answer.then(
+      async (result) => {
+        log.info("btw: early answer arrived", { sessionID: input.sessionID, busy, responseLength: result.response.length });
+        if (!busy || result.synthetic) return;
+        await asked;
+        const inline = await deliverAsideInline(
+          client,
+          input.sessionID,
+          formatInlineAside(question, result.response),
+          options
+        );
+        if (inline) {
+          log.info("btw: answer written into the running turn", { sessionID: input.sessionID });
+          markInlineDelivered();
+          return;
+        }
+        log.info("btw: no open stream for the answer; the held message will carry it", {
+          sessionID: input.sessionID
+        });
+      },
+      (error) => {
+        log.warn("btw: early aside failed; the message will ask again", {
+          sessionID: input.sessionID,
+          error: errorText(error)
+        });
+      }
+    );
   }
-  if (runtimeStatus) {
-    for (const name of Object.keys(merged)) {
-      const status = runtimeStatus[name];
-      if (status === void 0) continue;
-      const existing = merged[name];
-      const base = existing && typeof existing === "object" ? existing : {};
-      merged[name] = { ...base, enabled: status === "connected" };
-    }
+  if (!busy) return;
+  const started = Date.now();
+  const outcome = await Promise.race([
+    inlineDelivered,
+    waitForSessionIdle(client, input.sessionID, { ...options, stop: () => inlineDone }).then(
+      (idle) => idle ? "idle" : "timeout"
+    )
+  ]);
+  if (outcome === "inline") {
+    log.info("btw: answered inside the running turn, dropping the /btw message", {
+      sessionID: input.sessionID,
+      waitedMs: Date.now() - started
+    });
+    throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
   }
-  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);
+  log.info("btw: turn over, releasing the /btw message", {
+    sessionID: input.sessionID,
+    idle: outcome === "idle",
+    waitedMs: Date.now() - started
+  });
+  if (outcome === "timeout") {
+    showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
+    throw new BtwHandledError(BTW_TURN_TOO_LONG_MESSAGE);
   }
-  const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
-  const hash = crypto2.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
-  return { servers: merged, enabledServerNames, hash };
 }
-function finishBridge(input) {
-  const { servers, bridgedServerNames, allEnabledServerNames, hash, excludeServers } = input;
-  if (Object.keys(servers).length === 0) {
-    const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
-    if (!allEnabledServersExcluded) return null;
+
+// src/plan-usage.ts
+import { execFile as execFile2 } from "child_process";
+var PLAN_USAGE_ARGUMENTS = /* @__PURE__ */ new Set(["usage", "cost", "stats", "limits"]);
+function wantsPlanUsage(argument) {
+  return PLAN_USAGE_ARGUMENTS.has(argument.trim().toLowerCase());
+}
+var PLAN_USAGE_MAX_CHARS = 4e3;
+function truncate(text) {
+  return text.length <= PLAN_USAGE_MAX_CHARS ? text : `${text.slice(0, PLAN_USAGE_MAX_CHARS)}
+[truncated]`;
+}
+function parsePlanUsage(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { status: "failed", error: "the CLI printed nothing" };
+  const candidates = trimmed.split("\n").reverse();
+  for (const line of candidates) {
+    const start = line.indexOf("{");
+    if (start === -1) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line.slice(start));
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+    const record = parsed;
+    if (record.type !== void 0 && record.type !== "result") continue;
+    const text = typeof record.result === "string" ? record.result.trim() : "";
+    if (record.is_error === true) {
+      return { status: "failed", error: text || "the CLI reported an error" };
+    }
+    if (!text) continue;
     return {
-      path: "",
-      hash,
-      serverNames: [],
-      allEnabledServerNames
+      status: "ok",
+      text: truncate(text),
+      costUsd: typeof record.total_cost_usd === "number" ? record.total_cost_usd : 0,
+      numTurns: typeof record.num_turns === "number" ? record.num_turns : 0
     };
   }
-  const body = JSON.stringify({ mcpServers: servers }, null, 2);
-  const bodyDigest = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-  const outPath = path4.join(
-    pluginTmpDir(),
-    `mcp-${bodyDigest}.json`
-  );
+  return { status: "failed", error: "no result object in the CLI's reply" };
+}
+function runCli(cliPath, args, timeoutMs, env) {
+  return new Promise((resolve6, reject) => {
+    execFile2(
+      cliPath,
+      args,
+      // `killSignal` so a CLI wedged on a hook is actually gone, and a generous
+      // buffer because the reply is prose of unbounded length.
+      { timeout: timeoutMs, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024, env },
+      (error, stdout) => {
+        if (stdout && stdout.trim()) return resolve6(stdout);
+        if (error) return reject(error);
+        resolve6(stdout ?? "");
+      }
+    );
+  });
+}
+async function fetchPlanUsage(cliPath, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 2e4;
+  const run = options.runImpl ?? runCli;
   try {
-    if (!fileExists(outPath)) {
-      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+    const env = claudeSpawnEnv({ ignoreAnthropicApiKey: options.ignoreAnthropicApiKey });
+    const stdout = await run(
+      cliPath,
+      ["-p", "/cost", "--output-format", "json"],
+      timeoutMs,
+      env
+    );
+    const usage = parsePlanUsage(stdout);
+    if (usage.status === "ok") {
+      log.info("read claude plan usage", { costUsd: usage.costUsd, numTurns: usage.numTurns });
+    } else if (usage.status === "failed") {
+      log.debug("could not read claude plan usage", { error: usage.error });
     }
-  } catch (e) {
-    log.warn("failed to write bridged MCP config", {
-      error: e instanceof Error ? e.message : String(e)
-    });
-    return null;
+    return usage;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.debug("could not read claude plan usage", { error: message });
+    return { status: "failed", error: message };
   }
-  log.info("bridged opencode MCP config", {
-    target: outPath,
-    hash,
-    servers: bridgedServerNames,
-    excluded: excludeServers ? Array.from(excludeServers) : []
-  });
-  return {
-    path: outPath,
-    hash,
-    serverNames: bridgedServerNames,
-    allEnabledServerNames
-  };
 }
 
 // src/startup-diagnostics.ts
+import { execFile as execFile3 } from "child_process";
+import * as fs4 from "fs";
+import * as path5 from "path";
+import { promisify as promisify2 } from "util";
+import { fileURLToPath } from "url";
 var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
@@ -8302,6 +8384,77 @@ async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCom
   return srv;
 }
 
+// src/mcp-hot-reload.ts
+var DEFAULT_MCP_HOT_RELOAD_COOLDOWN_MS = 6e4;
+var MAX_COOLDOWN_ENTRIES = 64;
+var lastReloadAt = /* @__PURE__ */ new Map();
+function resolveMcpHotReloadCooldownMs() {
+  const raw = process.env.CLAUDE_CODE_MCP_HOT_RELOAD_COOLDOWN_MS;
+  if (raw === void 0) return DEFAULT_MCP_HOT_RELOAD_COOLDOWN_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return DEFAULT_MCP_HOT_RELOAD_COOLDOWN_MS;
+  }
+  return parsed;
+}
+function noteMcpHotReload(sessionKey2, now = Date.now()) {
+  lastReloadAt.delete(sessionKey2);
+  lastReloadAt.set(sessionKey2, now);
+  while (lastReloadAt.size > MAX_COOLDOWN_ENTRIES) {
+    const oldest = lastReloadAt.keys().next();
+    if (oldest.done) break;
+    lastReloadAt.delete(oldest.value);
+  }
+}
+function difference(a, b) {
+  const other = new Set(b);
+  return a.filter((name) => !other.has(name)).sort();
+}
+function decideMcpHotReload(input) {
+  const previousServers = input.previousServers ?? [];
+  const joined = difference(input.currentServers, previousServers);
+  const left = difference(previousServers, input.currentServers);
+  const decide = (verdict) => ({
+    verdict,
+    reload: verdict === "reload",
+    joined,
+    left
+  });
+  if (!input.enabled) return decide("off");
+  if (input.compactionMode) return decide("skipped-compaction");
+  if (!input.hasActiveProcess) return decide("no-process");
+  const previousHash = input.previousHash ?? null;
+  if (previousHash === input.currentHash) return decide("unchanged");
+  if (input.interactive) return decide("skipped-interactive");
+  if (input.pendingProxyCalls > 0) return decide("deferred-proxy-calls");
+  if (input.turnInFlight) return decide("deferred-turn-in-flight");
+  if (input.planQuestionPending) return decide("deferred-plan-question");
+  const cooldownMs = input.cooldownMs ?? resolveMcpHotReloadCooldownMs();
+  const last = lastReloadAt.get(input.sessionKey);
+  if (cooldownMs > 0 && last !== void 0) {
+    const now = input.now ?? Date.now();
+    if (now - last < cooldownMs) return decide("skipped-cooldown");
+  }
+  return decide("reload");
+}
+function logMcpHotReloadDecision(decision, context) {
+  if (decision.verdict === "off" || decision.verdict === "no-process" || decision.verdict === "skipped-compaction" || decision.verdict === "unchanged") {
+    return;
+  }
+  const details = {
+    sk: context.sessionKey,
+    joined: decision.joined,
+    left: decision.left,
+    previousHash: context.previousHash ?? null,
+    currentHash: context.currentHash
+  };
+  if (decision.reload) {
+    log.info("opencode MCP servers changed, respawning claude", details);
+    return;
+  }
+  log.info(`opencode MCP servers changed; holding off (${decision.verdict})`, details);
+}
+
 // src/title.ts
 function isTitleRequest(config, scope, options) {
   if (scope === "no-tools") return true;
@@ -8471,6 +8624,8 @@ function createTurnState(init) {
     reasoningIds: /* @__PURE__ */ new Map(),
     reasoningStarted: /* @__PURE__ */ new Map(),
     hadThinkingTextFromStream: false,
+    cliAskedForWork: false,
+    streamStarted: false,
     turnCompleted: false,
     controllerClosed: false,
     cleanedUp: false,
@@ -8520,6 +8675,59 @@ function createTurnState(init) {
   return state;
 }
 
+// src/turn-abort.ts
+function watchTurnAbort(signal) {
+  let aborted = signal?.aborted === true;
+  let listeners = [];
+  let settle;
+  const whenAborted = new Promise((resolve6) => {
+    settle = resolve6;
+  });
+  const fire = () => {
+    if (aborted && listeners === null) return;
+    aborted = true;
+    const pending = listeners ?? [];
+    listeners = null;
+    settle();
+    for (const fn of pending) {
+      try {
+        fn();
+      } catch (error) {
+        log.warn("turn abort listener threw", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  };
+  const onSignalAbort = () => fire();
+  if (aborted) {
+    listeners = null;
+    settle();
+  } else {
+    signal?.addEventListener("abort", onSignalAbort, { once: true });
+  }
+  return {
+    get aborted() {
+      return aborted;
+    },
+    get reason() {
+      return signal?.reason;
+    },
+    whenAborted,
+    onAbort(fn) {
+      if (aborted) {
+        fn();
+        return;
+      }
+      listeners?.push(fn);
+    },
+    dispose() {
+      listeners = null;
+      signal?.removeEventListener("abort", onSignalAbort);
+    }
+  };
+}
+
 // src/stream-parser.ts
 import { generateId as generateId2 } from "@ai-sdk/provider-utils";
 
@@ -10194,6 +10402,21 @@ var ClaudeCodeLanguageModel = class {
   }
   async doStreamForHost(options, attempt, mode = "stream") {
     const warnings = [];
+    const turnAbort = watchTurnAbort(options.abortSignal);
+    const abortedBeforeWork = (stage) => {
+      log.info("abort before the turn asked claude for work; nothing spawned", {
+        stage,
+        reason: describeAbortReason(turnAbort.reason)
+      });
+      turnAbort.dispose();
+      const aborted = new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+          controller.close();
+        }
+      });
+      return { stream: aborted, request: { body: { text: "" } } };
+    };
     const skipPermissions = this.config.skipPermissions !== false;
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
@@ -10238,6 +10461,7 @@ var ClaudeCodeLanguageModel = class {
       modelId: effectiveModelId
     });
     let cliPath = failover.cliPath;
+    if (turnAbort.aborted) return abortedBeforeWork("resolving the spawn cwd and account");
     const asideTransportRef = { cliPath, interactive: !!useInteractive };
     const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
     if (doctor) {
@@ -10489,10 +10713,28 @@ var ClaudeCodeLanguageModel = class {
     const hasMatchedPendingResults = previousPendingProxyMatches.some(
       (m) => m.result !== null
     );
-    const [runtimeStatus, cliVersion] = await Promise.all([
-      compactionMode ? Promise.resolve(void 0) : getRuntimeMcpStatus(),
+    const prologueWork = Promise.all([
+      compactionMode ? Promise.resolve(void 0) : getRuntimeMcpStatus({
+        // Give a server opencode is still starting a bounded moment to
+        // reach a decision before the spawn is planned without it. Only
+        // opencode 2 ever reports `pending`, so on 1.x this is one status
+        // call exactly as before.
+        waitForPendingMs: resolveMcpConnectWaitMs(
+          this.config.mcpConnectWaitMs
+        ),
+        signal: options.abortSignal
+      }),
       detectCliVersion(cliPath)
     ]);
+    prologueWork.catch(() => void 0);
+    const prologue = await Promise.race([
+      prologueWork.then((value) => ({ value })),
+      turnAbort.whenAborted.then(() => void 0)
+    ]);
+    if (!prologue) {
+      return abortedBeforeWork("waiting for opencode's MCP status and the CLI version");
+    }
+    const [runtimeStatus, cliVersion] = prologue.value;
     const failoverAccounts = failoverCandidates(
       this.config.failoverAccounts,
       sourceAccount
@@ -10523,6 +10765,7 @@ var ClaudeCodeLanguageModel = class {
       opencodeAgent: this.getOpencodeAgent(options),
       providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
     });
+    if (turnAbort.aborted) return abortedBeforeWork("planning the spawn");
     const stream = new ReadableStream({
       start(controller) {
         if (compactionMode) {
@@ -10552,28 +10795,136 @@ var ClaudeCodeLanguageModel = class {
         });
         state.activeProcess = getActiveProcess(sk);
         state.proxyServer = state.activeProcess?.proxyServer ?? null;
+        const discardUnattachedProxyServer = () => {
+          const own = state.proxyServer;
+          if (!own || own === state.activeProcess?.proxyServer) return;
+          state.proxyServer = null;
+          void own.close().catch((error) => {
+            log.warn("failed to close the proxy server of an aborted turn", {
+              sessionKey: sk,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          });
+        };
+        const releaseAbandonedProxyCalls = (reason) => {
+          if (state.drainBuffer.length === 0 && getPendingProxyCalls(sk).length === 0) return;
+          rejectAllPendingProxyCallsForSession(sk, new Error(reason));
+          state.drainBuffer.length = 0;
+        };
+        turnAbort.onAbort(() => {
+          state.autoContinueState.aborted = true;
+          if (!state.cliAskedForWork) {
+            if (state.controllerClosed) return;
+            state.controllerClosed = true;
+            log.info("abort while the turn was still being prepared; nothing was sent to claude", {
+              sessionKey: sk,
+              // A process here was spawned by this turn or reused from an
+              // earlier one; either way nothing was asked of it.
+              attachedProcess: !!state.activeProcess,
+              reason: describeAbortReason(turnAbort.reason)
+            });
+            discardUnattachedProxyServer();
+            state.cleanupTurn?.();
+            if (!state.streamStarted) {
+              state.streamStarted = true;
+              controller.enqueue({ type: "stream-start", warnings });
+            }
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          if (state.turnCompleted || state.controllerClosed) {
+            const stoppedProcess = state.activeProcess;
+            if (stoppedProcess && stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
+              const reason = describeAbortReason(options.abortSignal?.reason);
+              void settleSessionRunState(affinity).then((stopped) => {
+                const stillParked = stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0;
+                if (stopped === "busy" || !stillParked) {
+                  log.debug("abort at a tool boundary while opencode is still running the turn; keeping pending calls", {
+                    sk,
+                    session: stopped,
+                    stillParked,
+                    reason
+                  });
+                  return;
+                }
+                log.info("abort between proxy tool boundaries; releasing pending calls", { sk, reason });
+                void interruptTurn(stoppedProcess).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 (state.activeProcess) {
+            void interruptTurn(state.activeProcess).then((idle) => {
+              log.info("interrupt sent for aborted turn", { sk, idle });
+            });
+          }
+          if (!state.hasReceivedContent) {
+            log.info(
+              "abort signal received before content, closing stream immediately",
+              { cwd }
+            );
+            releaseAbandonedProxyCalls(
+              "Provider stream was aborted before pending proxy calls were emitted"
+            );
+            state.controllerClosed = true;
+            state.cleanupTurn?.();
+            try {
+              controller.close();
+            } catch {
+            }
+            return;
+          }
+          log.info(
+            "abort signal received mid-turn, starting grace period",
+            { cwd }
+          );
+          releaseAbandonedProxyCalls(
+            "Provider stream was aborted while proxy tool calls were pending"
+          );
+          startResultFallback(state, 5e3);
+        });
+        const stoppedBeforeWork = () => {
+          if (!state.controllerClosed || state.cliAskedForWork) return false;
+          discardUnattachedProxyServer();
+          return true;
+        };
         const setup = async () => {
+          if (stoppedBeforeWork()) return;
           if (!compactionMode && state.activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
             const probe = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
             const previousHash = state.activeProcess.mcpHash ?? null;
-            if (previousHash !== probe.bridgedHash) {
-              if (previousPendingProxyCalls.length > 0) {
-                log.info("deferring MCP hot reload until proxy calls resolve", {
-                  sk,
-                  previousHash,
-                  currentHash: probe.bridgedHash,
-                  pendingCalls: previousPendingProxyCalls.length
-                });
-              } else {
-                log.info("opencode MCP config changed, respawning claude", {
-                  sk,
-                  previousHash,
-                  currentHash: probe.bridgedHash
-                });
-                await deleteActiveProcessAndWait(sk);
-                state.activeProcess = void 0;
-                state.proxyServer = null;
-              }
+            const decision = decideMcpHotReload({
+              sessionKey: sk,
+              enabled: true,
+              hasActiveProcess: true,
+              compactionMode,
+              interactive: !!useInteractive,
+              turnInFlight: isTurnInFlight(state.activeProcess),
+              pendingProxyCalls: previousPendingProxyCalls.length,
+              planQuestionPending: hasExitPlanModeQuestions(sk),
+              previousHash,
+              currentHash: probe.bridgedHash,
+              previousServers: state.activeProcess.mcpServers,
+              currentServers: probe.allEnabledServerNames
+            });
+            logMcpHotReloadDecision(decision, {
+              sessionKey: sk,
+              previousHash,
+              currentHash: probe.bridgedHash
+            });
+            if (decision.reload) {
+              noteMcpHotReload(sk);
+              await deleteActiveProcessAndWait(sk);
+              state.activeProcess = void 0;
+              state.proxyServer = null;
             }
           }
           if (useInteractive && !compactionMode) {
@@ -10619,6 +10970,7 @@ var ClaudeCodeLanguageModel = class {
                 enabled: self.config.bridgeOpencodeSkills === true,
                 ...self.skillBridgeSpawn(failover)
               });
+              if (stoppedBeforeWork()) return;
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -10633,6 +10985,7 @@ var ClaudeCodeLanguageModel = class {
                 effort: reasoningEffort
               });
               ap.mcpHash = mcp.bridgedHash;
+              ap.mcpServers = mcp.allEnabledServerNames;
               setActiveProcess(sk, ap);
               state.proc = ap.proc;
               state.lineEmitter = ap.lineEmitter;
@@ -10648,6 +11001,7 @@ var ClaudeCodeLanguageModel = class {
             let spawnSystemPromptFile;
             let spawnProxyServer = null;
             let spawnMcpHash = null;
+            let spawnMcpServers = [];
             if (compactionMode) {
               state.cliArgs = buildCliArgs({
                 sessionKey: sk,
@@ -10821,7 +11175,9 @@ var ClaudeCodeLanguageModel = class {
               spawnSystemPromptFile = systemPromptFile;
               spawnProxyServer = state.proxyServer;
               spawnMcpHash = mcp.bridgedHash;
+              spawnMcpServers = mcp.allEnabledServerNames;
             }
+            if (stoppedBeforeWork()) return;
             if (state.activeProcess && !compactionMode) {
               state.proc = state.activeProcess.proc;
               state.lineEmitter = state.activeProcess.lineEmitter;
@@ -10839,6 +11195,7 @@ var ClaudeCodeLanguageModel = class {
                 reasoningEffort,
                 promptCacheTtl
               );
+              ap.mcpServers = spawnMcpServers;
               state.proc = ap.proc;
               state.lineEmitter = ap.lineEmitter;
               state.activeProcess = ap;
@@ -10851,6 +11208,8 @@ var ClaudeCodeLanguageModel = class {
               log.warn("previous turn did not stop in time; this turn may see stale output", { sk });
             }
           }
+          if (stoppedBeforeWork()) return;
+          state.streamStarted = true;
           controller.enqueue({ type: "stream-start", warnings });
           if (failoverNote) {
             controller.enqueue({
@@ -11209,72 +11568,8 @@ var ClaudeCodeLanguageModel = class {
             state.drainTimer = setTimeout(() => drainNow(state), DRAIN_QUIET_MS);
           });
           state.proc.on("error", procErrorHandler);
-          if (options.abortSignal) {
-            const releaseAbandonedProxyCalls = (reason) => {
-              if (state.drainBuffer.length === 0 && getPendingProxyCalls(sk).length === 0) return;
-              rejectAllPendingProxyCallsForSession(sk, new Error(reason));
-              state.drainBuffer.length = 0;
-            };
-            options.abortSignal.addEventListener("abort", () => {
-              state.autoContinueState.aborted = true;
-              if (state.turnCompleted || state.controllerClosed) {
-                const stoppedProcess = state.activeProcess;
-                if (stoppedProcess && stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
-                  const reason = describeAbortReason(options.abortSignal?.reason);
-                  void settleSessionRunState(affinity).then((stopped) => {
-                    const stillParked = stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0;
-                    if (stopped === "busy" || !stillParked) {
-                      log.debug("abort at a tool boundary while opencode is still running the turn; keeping pending calls", {
-                        sk,
-                        session: stopped,
-                        stillParked,
-                        reason
-                      });
-                      return;
-                    }
-                    log.info("abort between proxy tool boundaries; releasing pending calls", { sk, reason });
-                    void interruptTurn(stoppedProcess).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 (state.activeProcess) {
-                void interruptTurn(state.activeProcess).then((idle) => {
-                  log.info("interrupt sent for aborted turn", { sk, idle });
-                });
-              }
-              if (!state.hasReceivedContent) {
-                log.info(
-                  "abort signal received before content, closing stream immediately",
-                  { cwd }
-                );
-                releaseAbandonedProxyCalls(
-                  "Provider stream was aborted before pending proxy calls were emitted"
-                );
-                state.controllerClosed = true;
-                cleanupTurn();
-                try {
-                  controller.close();
-                } catch {
-                }
-                return;
-              }
-              log.info(
-                "abort signal received mid-turn, starting grace period",
-                { cwd }
-              );
-              releaseAbandonedProxyCalls(
-                "Provider stream was aborted while proxy tool calls were pending"
-              );
-              startResultFallback(state, 5e3);
-            });
-          }
           if (hasMatchedPendingResults) {
+            state.cliAskedForWork = true;
             for (const { call, result } of previousPendingProxyMatches) {
               if (result) {
                 const channelClosed = isPendingProxyCallChannelClosed(call);
@@ -11332,6 +11627,7 @@ var ClaudeCodeLanguageModel = class {
               );
             }
           }
+          state.cliAskedForWork = true;
           if (state.activeProcess) noteTurnStarted(state.activeProcess);
           state.proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
@@ -12085,6 +12381,7 @@ function createClaudeCode(settings = {}) {
       planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
+      mcpConnectWaitMs: settings.mcpConnectWaitMs,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools === true,
       multiStepContinuation: settings.multiStepContinuation ?? true,
       autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart",