@khalilgharbaoui/opencode-claude-code-plugin 0.14.0 → 0.15.0

package/dist/index.js

@@ -376,18 +376,241 @@ function mapTool(name, input, opts) {
   return { name, input, executed: true };
 }
 
+// src/side-question.ts
+import { randomUUID } from "crypto";
+
+// src/cli-version.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var cache = /* @__PURE__ */ new Map();
+function detectCliVersion(cliPath) {
+  const cached = cache.get(cliPath);
+  if (cached) return cached;
+  const promise = (async () => {
+    try {
+      const { stdout } = await execFileAsync(cliPath, ["--version"], {
+        timeout: 5e3
+      });
+      const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout.trim());
+      if (!match) {
+        log.warn("claude --version output unparseable", { stdout: stdout.trim() });
+        return null;
+      }
+      const v = {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        raw: stdout.trim()
+      };
+      log.info("detected claude cli version", { cliPath, version: v.raw });
+      if (!cliSupportsThinkingDisplay(v)) {
+        log.notice(
+          "claude cli < 2.1.142 detected; Opus 4.7 thinking summaries unavailable. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
+          { version: v.raw }
+        );
+      }
+      return v;
+    } catch (err) {
+      log.warn("failed to detect claude cli version", {
+        cliPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  })();
+  cache.set(cliPath, promise);
+  return promise;
+}
+function gte(v, target) {
+  if (v.major !== target.major) return v.major > target.major;
+  if (v.minor !== target.minor) return v.minor > target.minor;
+  return v.patch >= target.patch;
+}
+function cliSupportsThinkingDisplay(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 142 });
+}
+function cliSupportsFastMode(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 220 });
+}
+function cliSupportsSideQuestion(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 258 });
+}
+function cliSupportsThinking(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 0, patch: 0 });
+}
+
+// src/side-question.ts
+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 isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseSideQuestionContent(content) {
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    const parts = [];
+    for (const part of content) {
+      if (!isRecord(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.trim());
+  return match ? { question: (match[1] ?? "").trim() } : null;
+}
+function parseSideQuestion(prompt) {
+  const latest = prompt.at(-1);
+  return latest?.role === "user" ? parseSideQuestionContent(latest.content) : null;
+}
+function isSideQuestionPending(activeProcess) {
+  return pendingProcesses.has(activeProcess.proc);
+}
+function dispatchSideQuestionResponse(activeProcess, line) {
+  if (!pendingProcesses.has(activeProcess.proc)) return false;
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (!isRecord(message) || message.type !== "control_response") return false;
+  const response = message.response;
+  if (!isRecord(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 (options.busy || lineEmitter.listenerCount("line") > 0 || pendingProcesses.has(proc)) {
+    throw new Error("/btw requires an idle Claude Code session. Wait for the current turn to finish.");
+  }
+  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 = randomUUID();
+  const request = JSON.stringify({
+    type: "control_request",
+    request_id: requestId,
+    request: {
+      subtype: "side_question",
+      question,
+      ...options.history === void 0 ? {} : { history: options.history }
+    }
+  });
+  pendingProcesses.add(proc);
+  return new Promise((resolve4, 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" || !isRecord(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
+        fail(new Error("Claude Code returned an invalid /btw response."));
+        return;
+      }
+      settled = true;
+      cleanup();
+      resolve4({ 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);
+    }
+  });
+}
+
 // src/message-builder.ts
-var THINKING_KEYWORDS = {
-  minimal: null,
-  low: "think",
-  medium: "think hard",
-  high: "think harder",
-  xhigh: "megathink",
-  max: "ultrathink"
-};
-function reasoningKeyword(effort) {
-  if (!effort) return null;
-  return THINKING_KEYWORDS[effort] ?? null;
+function filterSideQuestionHistory(prompt) {
+  let aside = false;
+  return prompt.filter((message) => {
+    if (message.role === "user") {
+      aside = parseSideQuestionContent(message.content) !== null;
+      return !aside;
+    }
+    return message.role !== "assistant" || !aside;
+  });
 }
 var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
   "image/jpeg",
@@ -529,6 +752,7 @@ ${clipWithMarker(
 }
 function compactConversationHistory(prompt, opts = {}) {
   const mode = opts.mode ?? "fresh-session";
+  prompt = filterSideQuestionHistory(prompt);
   if (mode === "compaction") {
     return buildCompactionHistory(prompt);
   }
@@ -603,7 +827,7 @@ function buildCompactionHistory(prompt) {
   });
   return entries.join("\n\n");
 }
-function getClaudeUserMessage(prompt, includeHistoryContext = false, reasoningEffort, opts = {}) {
+function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {}) {
   const compactionMode = opts.compactionMode === true;
   const content = [];
   if (compactionMode) {
@@ -653,6 +877,7 @@ Now continuing with the current message:
   }
   for (const msg of messages) {
     if (msg.role === "user") {
+      if (parseSideQuestionContent(msg.content) !== null) continue;
       if (typeof msg.content === "string") {
         const str = msg.content;
         if (str.trim()) {
@@ -708,20 +933,6 @@ Now continuing with the current message:
       }
     });
   }
-  if (!compactionMode) {
-    const keyword = reasoningKeyword(reasoningEffort);
-    if (keyword) {
-      const lastTextPart = [...content].reverse().find((p) => p.type === "text");
-      if (lastTextPart) {
-        lastTextPart.text = lastTextPart.text ? `${lastTextPart.text}
-
-(${keyword})` : `(${keyword})`;
-      } else {
-        content.push({ type: "text", text: `(${keyword})` });
-      }
-      log.debug("injected reasoning keyword", { effort: reasoningEffort, keyword });
-    }
-  }
   return JSON.stringify({
     type: "user",
     message: {
@@ -731,6 +942,10 @@ Now continuing with the current message:
   });
 }
 
+// src/agent-models.ts
+import { readFile, readdir } from "fs/promises";
+import path from "path";
+
 // src/models.ts
 var PROVIDER_ID = "claude-code";
 var NPM = "@khalilgharbaoui/opencode-claude-code-plugin";
@@ -772,9 +987,9 @@ function defineModel(opts) {
 }
 var haikuCost = { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 };
 var sonnetCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
-var sonnet5Cost = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
 var opusCost = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
 var fableCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
+var fable51Cost = { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 };
 var opusFastCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
 function toConfigModel(model) {
   const inputMods = [];
@@ -849,8 +1064,8 @@ var defaultModels = {
     reasoning: true,
     context: 1e6,
     output: 128e3,
-    cost: sonnet5Cost,
-    multiplier: 2,
+    cost: sonnetCost,
+    multiplier: 3,
     releaseDate: "2026-06-30"
   }),
   "claude-opus-4-5": defineModel({
@@ -950,10 +1165,21 @@ var defaultModels = {
     multiplier: 10,
     releaseDate: "2026-06-09"
   }),
-  // Mythos 5 shares Fable 5's capabilities and pricing without the safety
-  // classifiers; limited availability via Project Glasswing. `claude --model
-  // claude-mythos-5` simply errors for accounts without access, so it's safe to
-  // register unconditionally.
+  "claude-fable-5-1": defineModel({
+    id: "claude-fable-5-1",
+    name: "Claude Fable 5.1",
+    family: "fable",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: fable51Cost,
+    multiplier: 10,
+    releaseDate: "2026-09-01"
+  }),
+  // Mythos 5 and 5.1 share the corresponding Fable models' capabilities and
+  // pricing without the safety classifiers; limited availability via Project
+  // Glasswing. `claude --model` simply errors for accounts without access, so
+  // they are safe to register unconditionally.
   "claude-mythos-5": defineModel({
     id: "claude-mythos-5",
     name: "Claude Mythos 5",
@@ -964,6 +1190,17 @@ var defaultModels = {
     cost: fableCost,
     multiplier: 10,
     releaseDate: "2026-06-09"
+  }),
+  "claude-mythos-5-1": defineModel({
+    id: "claude-mythos-5-1",
+    name: "Claude Mythos 5.1",
+    family: "mythos",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: fable51Cost,
+    multiplier: 10,
+    releaseDate: "2026-09-01"
   })
 };
 var FAST_SUFFIX = "-fast";
@@ -976,6 +1213,142 @@ function parseModelId(modelId) {
   return { model: base.slice(0, -FAST_SUFFIX.length) + account, fast: true };
 }
 
+// src/agent-models.ts
+var AGENT_DIR_NAMES = ["agents", "agent"];
+var REASONING_EFFORTS = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+var registry = {};
+var defaultSubagentModel;
+function setAgentRegistry(records) {
+  registry = records;
+}
+function getAgentRegistry() {
+  return registry;
+}
+function setDefaultSubagentModel(model) {
+  defaultSubagentModel = model?.trim() || void 0;
+}
+function getDefaultSubagentModel() {
+  return defaultSubagentModel;
+}
+function accountMarker(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? "" : modelId.slice(at);
+}
+function withoutAccountMarker(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? modelId : modelId.slice(0, at);
+}
+function resolveAgentModel(agent, modelId, overrides) {
+  if (!agent) return modelId;
+  const record = (overrides?.records ?? registry)[agent];
+  if (!record) return modelId;
+  if (record.model?.includes("/")) return modelId;
+  const fallback = overrides ? overrides.defaultSubagentModel : defaultSubagentModel;
+  const declared = record.forceModel?.trim();
+  const wanted = declared || (record.mode === "subagent" ? fallback : void 0);
+  if (!wanted) return modelId;
+  const base = withoutAccountMarker(wanted);
+  if (!Object.hasOwn(defaultModels, base)) {
+    log.warn("agent model override refused: unknown model", {
+      agent,
+      wanted: base,
+      keeping: modelId
+    });
+    return modelId;
+  }
+  const resolved = `${base}${accountMarker(modelId)}`;
+  if (resolved !== modelId) {
+    log.debug("agent model override", { agent, from: modelId, to: resolved });
+  }
+  return resolved;
+}
+function resolveAgentEffort(agent, inherited, overrides) {
+  if (!agent) return inherited;
+  const record = (overrides?.records ?? registry)[agent];
+  const declared = record?.reasoningEffort?.trim();
+  if (!declared) return inherited;
+  if (!REASONING_EFFORTS.includes(declared)) {
+    log.warn("agent effort override refused: unknown level", {
+      agent,
+      wanted: declared,
+      keeping: inherited
+    });
+    return inherited;
+  }
+  if (declared !== inherited) {
+    log.debug("agent effort override", {
+      agent,
+      from: inherited,
+      to: declared
+    });
+  }
+  return declared;
+}
+function parseAgentFrontmatter(text) {
+  const record = {};
+  if (!text.startsWith("---")) return record;
+  const lines = text.split(/\r?\n/);
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = /^([A-Za-z_][A-Za-z0-9_-]*):[ \t]*(.*)$/.exec(line);
+    if (!match) continue;
+    const key = match[1];
+    if (key !== "mode" && key !== "model" && key !== "forceModel" && key !== "reasoningEffort")
+      continue;
+    const value = match[2].trim().replace(/^["']|["']$/g, "");
+    if (value) record[key] = value;
+  }
+  return record;
+}
+async function readAgentMarkdownRecords(directories) {
+  const records = {};
+  for (const directory of directories) {
+    let entries;
+    try {
+      entries = await readdir(directory);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".md")) continue;
+      const name = entry.slice(0, -3);
+      if (records[name]) continue;
+      try {
+        const text = await readFile(path.join(directory, entry), "utf8");
+        records[name] = parseAgentFrontmatter(text);
+      } catch (err) {
+        log.debug("failed to read agent markdown", {
+          file: path.join(directory, entry),
+          error: String(err)
+        });
+      }
+    }
+  }
+  return records;
+}
+function agentDirectories(home, projectDirectory) {
+  const directories = [];
+  if (projectDirectory) {
+    for (const name of AGENT_DIR_NAMES) {
+      directories.push(path.join(projectDirectory, ".opencode", name));
+    }
+  }
+  if (home) {
+    for (const name of AGENT_DIR_NAMES) {
+      directories.push(path.join(home, ".config", "opencode", name));
+    }
+  }
+  return directories;
+}
+
 // src/plan-mode-question.ts
 var QUESTION_TOOL_NAME = "question";
 var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
@@ -999,6 +1372,10 @@ function clearExitPlanModeQuestions(sessionKey2) {
     if (key.startsWith(prefix)) pendingQuestions.delete(key);
   }
 }
+function hasExitPlanModeQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
+  return [...pendingQuestions.keys()].some((key) => key.startsWith(prefix));
+}
 function createExitPlanModeQuestionCall(sessionKey2, exitPlanModeToolUseId, plan, questionToolCallId = `exit_plan_question_${exitPlanModeToolUseId}`) {
   pendingQuestions.set(pendingKey(sessionKey2, questionToolCallId), exitPlanModeToolUseId);
   return {
@@ -1133,7 +1510,7 @@ function consumeExitPlanModeQuestionResult(sessionKey2, prompt) {
 
 // src/mcp-bridge.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 import * as os2 from "os";
 import * as crypto from "crypto";
 import {
@@ -1144,8 +1521,8 @@ import {
 // src/tmp.ts
 import * as fs from "fs";
 import * as os from "os";
-import * as path from "path";
-var PLUGIN_TMP_DIR = path.join(
+import * as path2 from "path";
+var PLUGIN_TMP_DIR = path2.join(
   os.tmpdir(),
   `opencode-claude-code-${process.pid}`
 );
@@ -1221,14 +1598,14 @@ function deepMerge(target, source) {
 }
 function walkUp(opts) {
   const out = [];
-  let current = path2.resolve(opts.start);
+  let current = path3.resolve(opts.start);
   while (true) {
     for (const target of opts.targets) {
-      const candidate = path2.join(current, target);
+      const candidate = path3.join(current, target);
       if (opts.predicate(candidate)) out.push(candidate);
     }
-    if (opts.stop && current === path2.resolve(opts.stop)) break;
-    const parent = path2.dirname(current);
+    if (opts.stop && current === path3.resolve(opts.stop)) break;
+    const parent = path3.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -1236,28 +1613,28 @@ function walkUp(opts) {
 }
 function detectWorktree(cwd) {
   const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path2.resolve(override);
-  let current = path2.resolve(cwd);
+  if (override) return path3.resolve(override);
+  let current = path3.resolve(cwd);
   while (true) {
-    const gitPath = path2.join(current, ".git");
+    const gitPath = path3.join(current, ".git");
     try {
       if (fs2.existsSync(gitPath)) return current;
     } catch {
     }
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
 }
 function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
-  return path2.join(xdg, "opencode");
+  const xdg = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
+  return path3.join(xdg, "opencode");
 }
 function loadGlobalConfig() {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path2.join(dir, name);
+    const file = path3.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -1267,7 +1644,7 @@ function loadGlobalConfig() {
 function loadProjectFilesInDir(dir) {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
-    const file = path2.join(dir, name);
+    const file = path3.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -1278,7 +1655,7 @@ function dotOpencodeDirs(cwd, worktree) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path2.resolve(p);
+    const abs = path3.resolve(p);
     if (!seen.has(abs) && dirExists(abs)) {
       seen.add(abs);
       dirs.push(abs);
@@ -1294,7 +1671,7 @@ function dotOpencodeDirs(cwd, worktree) {
   }
   const home = os2.homedir();
   if (home) {
-    const homeDot = path2.join(home, ".opencode");
+    const homeDot = path3.join(home, ".opencode");
     if (dirExists(homeDot)) push(homeDot);
   }
   const envDir = process.env.OPENCODE_CONFIG_DIR;
@@ -1419,7 +1796,7 @@ function mergeOpencodeMcp(cwd, runtimeStatus) {
   const projectDirs = [];
   const seenProjectDirs = /* @__PURE__ */ new Set();
   for (const f of projectFiles) {
-    const d = path2.dirname(f);
+    const d = path3.dirname(f);
     if (!seenProjectDirs.has(d)) {
       seenProjectDirs.add(d);
       projectDirs.push(d);
@@ -1464,7 +1841,7 @@ function finishBridge(input) {
     };
   }
   const body = JSON.stringify({ mcpServers: servers }, null, 2);
-  const outPath = path2.join(
+  const outPath = path3.join(
     pluginTmpDir(),
     `mcp-${hash}.json`
   );
@@ -1576,1718 +1953,1807 @@ async function fetchOpencodeToolList(provider, model, directory) {
 // src/session-manager.ts
 import { spawn } from "child_process";
 import { createInterface } from "readline";
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 import { unlink } from "fs/promises";
 
-// src/cli-version.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-var cache = /* @__PURE__ */ new Map();
-function detectCliVersion(cliPath) {
-  const cached = cache.get(cliPath);
-  if (cached) return cached;
-  const promise = (async () => {
-    try {
-      const { stdout } = await execFileAsync(cliPath, ["--version"], {
-        timeout: 5e3
-      });
-      const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout.trim());
-      if (!match) {
-        log.warn("claude --version output unparseable", { stdout: stdout.trim() });
-        return null;
-      }
-      const v = {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-        raw: stdout.trim()
-      };
-      log.info("detected claude cli version", { cliPath, version: v.raw });
-      if (!cliSupportsThinkingDisplay(v)) {
-        log.notice(
-          "claude cli < 2.1.142 detected; Opus 4.7 thinking summaries unavailable. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
-          { version: v.raw }
-        );
-      }
-      return v;
-    } catch (err) {
-      log.warn("failed to detect claude cli version", {
-        cliPath,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      return null;
-    }
-  })();
-  cache.set(cliPath, promise);
-  return promise;
-}
-function gte(v, target) {
-  if (v.major !== target.major) return v.major > target.major;
-  if (v.minor !== target.minor) return v.minor > target.minor;
-  return v.patch >= target.patch;
-}
-function cliSupportsThinkingDisplay(v) {
-  if (!v) return false;
-  return gte(v, { major: 2, minor: 1, patch: 142 });
-}
-function cliSupportsFastMode(v) {
-  if (!v) return false;
-  return gte(v, { major: 2, minor: 1, patch: 220 });
-}
-function cliSupportsThinking(v) {
-  if (!v) return false;
-  return gte(v, { major: 2, minor: 0, patch: 0 });
-}
+// src/proxy-broker.ts
+import { EventEmitter as EventEmitter2 } from "events";
 
-// src/session-manager.ts
-var activeProcesses = /* @__PURE__ */ new Map();
-var claudeSessions = /* @__PURE__ */ new Map();
-var MAX_ACTIVE_PROCESSES = 16;
-var PROCESS_EXIT_TIMEOUT_MS = 1500;
-var PROCESS_FORCE_EXIT_TIMEOUT_MS = 500;
-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);
+// src/proxy-mcp.ts
+import { createServer } from "http";
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as crypto2 from "crypto";
+import { EventEmitter } from "events";
+var SSE_KEEPALIVE_MS = 15e3;
+function acceptsEventStream(acceptHeader) {
+  return typeof acceptHeader === "string" && acceptHeader.toLowerCase().includes("text/event-stream");
 }
-function isClaudeThinkingDisabled() {
-  return envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_THINKING) || envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING);
+var SERVER_CLOSED_MESSAGE = "proxy MCP server closed";
+function isExpectedCleanupError(message) {
+  return message.includes("timed out after") && message.includes("waiting for opencode to resolve") || message.includes("rejecting as orphaned") || message.includes("was orphaned by a new user turn") || message.includes("stream was aborted") || message.includes(SERVER_CLOSED_MESSAGE);
 }
-function claudeSpawnEnv(opts) {
-  const env = {
-    ...process.env,
-    TERM: "xterm-256color"
-  };
-  if (opts?.ignoreAnthropicApiKey) {
-    delete env.ANTHROPIC_API_KEY;
-    delete env.ANTHROPIC_AUTH_TOKEN;
+var PROTOCOL_VERSION = "2024-11-05";
+var SERVER_NAME = "opencode_proxy";
+var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
+var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
+  task: 60 * 60 * 1e3,
+  // 60 min
+  question: 30 * 60 * 1e3
+  // 30 min
+};
+var MAX_PROXY_TIMEOUT_MS = 2 ** 31 - 1;
+function resolveProxyCallTimeoutMs(toolName, input, overrides) {
+  const key = toolName.toLowerCase();
+  let ms = PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS[key] ?? PROXY_DEFAULT_TIMEOUT_MS;
+  if (overrides) {
+    const ov = lookupCaseInsensitive(overrides, key);
+    if (typeof ov === "number" && ov > 0) ms = ov;
   }
-  if (!isClaudeThinkingDisabled() && process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0) {
-    env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES = "1";
+  if (key === "bash") {
+    const requested = input?.timeout;
+    if (typeof requested === "number" && requested > ms) ms = requested;
   }
-  return env;
+  return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
-function touch(key) {
-  const existing = activeProcesses.get(key);
-  if (existing) {
-    activeProcesses.delete(key);
-    activeProcesses.set(key, existing);
+function lookupCaseInsensitive(map, key) {
+  if (Object.prototype.hasOwnProperty.call(map, key)) return map[key];
+  for (const k of Object.keys(map)) {
+    if (k.toLowerCase() === key) return map[k];
   }
+  return void 0;
 }
-function evictIfNeeded() {
-  while (activeProcesses.size >= MAX_ACTIVE_PROCESSES) {
-    const oldestKey = activeProcesses.keys().next().value;
-    if (!oldestKey) break;
-    log.info("evicting LRU claude process", { sessionKey: oldestKey });
-    deleteActiveProcess(oldestKey);
+function resolveProxyClientCeilingMs(overrides) {
+  let ms = PROXY_DEFAULT_TIMEOUT_MS;
+  for (const v of Object.values(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
+    if (v > ms) ms = v;
   }
+  if (overrides) {
+    for (const v of Object.values(overrides)) {
+      if (typeof v === "number" && v > ms) ms = v;
+    }
+  }
+  return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
-function getActiveProcess(key) {
-  const ap = activeProcesses.get(key);
-  if (ap) touch(key);
-  return ap;
-}
-function setActiveProcess(key, ap) {
-  activeProcesses.set(key, ap);
-}
-function detachActiveProcess(key) {
-  const ap = activeProcesses.get(key);
-  if (!ap) return void 0;
-  activeProcesses.delete(key);
-  void ap.proxyServer?.close();
-  return ap;
-}
-function deleteActiveProcess(key) {
-  const ap = detachActiveProcess(key);
-  ap?.proc.kill();
-}
-function hasProcessExited(proc) {
-  return proc.exitCode !== null || proc.signalCode !== null;
+function buildProxyTimeoutError(toolName, ms) {
+  const key = toolName.toLowerCase();
+  const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
+  if (key === "task") {
+    return new Error(
+      base + " (the subagent). The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
+    );
+  }
+  return new Error(base);
 }
-function waitForProcessExit(proc, timeoutMs) {
-  if (hasProcessExited(proc)) return Promise.resolve(true);
-  return new Promise((resolve4) => {
-    const onExit = () => {
-      clearTimeout(timer);
-      resolve4(true);
-    };
-    const timer = setTimeout(() => {
-      proc.off("exit", onExit);
-      resolve4(hasProcessExited(proc));
-    }, timeoutMs);
-    proc.once("exit", onExit);
-  });
+var TASK_PROXY_NOTE = "This is the ONLY tool that dispatches opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists \u2014 invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var AGENT_TYPES_HEADING = "Available agent types";
+var AGENT_BLURB_LIMIT = 140;
+var QUESTION_PROXY_NOTE = "This routes structured questions through opencode's native `question` tool, which renders a TUI form with the options you provide and blocks until the operator answers. Claude Code's built-in AskUserQuestion is disabled in this environment; this proxy is the ONLY way to ask the operator for a decision or clarification. Answers come back as arrays of selected labels (set `multiple: true` to allow more than one). If the operator dismisses the form the call returns an error \u2014 treat that as 'no answer' and stop, do not guess. Question calls get a 30-minute proxy deadline by default (configurable via proxyToolTimeoutMs); for long-AFK scenarios prefer fewer, high-signal questions.";
+var COMPRESS_PROXY_NOTE = "The current turn continues normally after this call \u2014 finish what you are doing. The reset happens at the START of the next turn: the Claude Code session is discarded and a fresh one begins with your summary as its only prior context. Everything else, including tool output and files you read, is gone, so write the summary as the authoritative record. Call this once per compression, when older resolved work no longer needs full detail.";
+function extractAgentTypeList(liveDescription) {
+  const live = liveDescription?.trim();
+  if (!live) return void 0;
+  const start = live.indexOf(AGENT_TYPES_HEADING);
+  if (start === -1) return void 0;
+  const entries = [];
+  for (const raw of live.slice(start).split("\n")) {
+    const match = /^-\s*([^:]+):\s*(.+)$/.exec(raw.trim());
+    if (!match) continue;
+    const name = match[1].trim();
+    const blurb = match[2].trim();
+    entries.push(
+      `- ${name}: ${blurb.length > AGENT_BLURB_LIMIT ? `${blurb.slice(0, AGENT_BLURB_LIMIT).trimEnd()}\u2026` : blurb}`
+    );
+  }
+  if (entries.length === 0) return void 0;
+  return `Valid subagent_type values, from opencode's live registry \u2014 anything else fails:
+${entries.join("\n")}`;
 }
-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
+function overlayTaskProxyDescription(tools, liveDescription) {
+  const agentTypes = extractAgentTypeList(liveDescription);
+  if (!agentTypes) return tools;
+  return tools.map(
+    (t) => t.name === "task" ? { ...t, description: `${agentTypes}
+
+${t.description}` } : t
   );
-  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;
-}
-function getClaudeSessionId(key) {
-  return claudeSessions.get(key);
 }
-function setClaudeSessionId(key, sessionId) {
-  claudeSessions.set(key, sessionId);
+function overlayQuestionProxyDescription(tools, liveDescription) {
+  const live = liveDescription?.trim();
+  if (!live) return tools;
+  return tools.map(
+    (t) => t.name === "question" ? { ...t, description: `${live}
+
+${QUESTION_PROXY_NOTE}` } : t
+  );
 }
-function deleteClaudeSessionId(key) {
-  clearExitPlanModeQuestions(key);
-  const claudeSessionId = claudeSessions.get(key);
-  if (claudeSessionId) clearLedger(claudeSessionId);
-  claudeSessions.delete(key);
+function filterQuestionProxyByOpencodeSupport(tools, opencodeHasQuestion) {
+  if (opencodeHasQuestion) return tools;
+  return tools.filter((t) => t.name !== "question");
 }
-function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey) {
-  evictIfNeeded();
-  log.info("spawning new claude process", { cliPath, cliArgs, cwd, sessionKey: sessionKey2 });
-  const proc = spawn(cliPath, cliArgs, {
-    cwd,
-    stdio: ["pipe", "pipe", "pipe"],
-    env: claudeSpawnEnv({ ignoreAnthropicApiKey }),
-    shell: process.platform === "win32"
-  });
-  const lineEmitter = new EventEmitter();
-  const rl = createInterface({ input: proc.stdout });
-  rl.on("line", (line) => {
-    lineEmitter.emit("line", line);
-  });
-  rl.on("close", () => {
-    lineEmitter.emit("close");
-  });
-  const ap = {
-    proc,
-    lineEmitter,
-    proxyServer: proxyServer ?? null,
-    mcpHash,
-    systemPromptFile
-  };
-  activeProcesses.set(sessionKey2, ap);
-  proc.on("error", (err) => {
-    log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
-  });
-  proc.on("exit", (code, signal) => {
-    log.info("claude process exited", { code, signal, sessionKey: sessionKey2 });
-    void proxyServer?.close();
-    if (systemPromptFile) {
-      void unlink(systemPromptFile).catch(() => {
-      });
+var DEFAULT_PROXY_TOOLS = [
+  {
+    name: "bash",
+    description: "Execute a shell command. Routed through opencode's bash tool so permission prompts flow through opencode's UI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute."
+        },
+        description: {
+          type: "string",
+          description: "Short human-readable description of what the command does."
+        },
+        timeout: {
+          type: "number",
+          description: "Optional timeout in milliseconds."
+        }
+      },
+      required: ["command"]
     }
-    const ownsSessionKey = activeProcesses.get(sessionKey2) === ap;
-    if (ownsSessionKey) activeProcesses.delete(sessionKey2);
-    if (ownsSessionKey && code !== 0 && code !== null) {
-      log.info("process exited with error, clearing session", {
-        code,
-        sessionKey: sessionKey2
-      });
-      claudeSessions.delete(sessionKey2);
+  },
+  {
+    name: "write",
+    description: "Write a file. Routed through opencode's write tool so permission prompts flow through opencode's UI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: {
+          type: "string",
+          description: "The file to write. Absolute paths are preferred."
+        },
+        content: {
+          type: "string",
+          description: "The full content to write to the file."
+        }
+      },
+      required: ["filePath", "content"]
     }
-  });
-  proc.stderr?.on("data", (data) => {
-    const stderr = data.toString();
-    log.debug("stderr", { data: stderr.slice(0, 200) });
-    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
-        });
-      }
+  },
+  {
+    name: "edit",
+    description: "Replace text in an existing file. Routed through opencode's edit tool so permission prompts flow through opencode's UI.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filePath: {
+          type: "string",
+          description: "The file to edit. Absolute paths are preferred."
+        },
+        oldString: {
+          type: "string",
+          description: "The exact text to replace."
+        },
+        newString: {
+          type: "string",
+          description: "The replacement text."
+        },
+        replaceAll: {
+          type: "boolean",
+          description: "Replace all occurrences instead of just the first one."
+        }
+      },
+      required: ["filePath", "oldString", "newString"]
     }
-  });
-  return ap;
-}
-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];
-}
-function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropicApiKey) {
-  const old = activeProcesses.get(sessionKey2);
-  if (!old) return void 0;
-  activeProcesses.delete(sessionKey2);
-  old.proc.removeAllListeners("exit");
-  try {
-    old.proc.kill();
-  } catch {
-  }
-  return spawnClaudeProcess(
-    cliPath,
-    appendResumeIfNeeded(sessionKey2, cliArgs),
-    cwd,
-    sessionKey2,
-    old.proxyServer,
-    old.mcpHash,
-    old.systemPromptFile,
-    ignoreAnthropicApiKey
-  );
-}
-function buildCliArgs(opts) {
-  const {
-    sessionKey: sessionKey2,
-    skipPermissions,
-    includeSessionId = true,
-    model,
-    permissionMode,
-    mcpConfig,
-    strictMcpConfig,
-    disallowedTools,
-    appendSystemPromptFile,
-    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);
-  }
-  if (permissionMode) {
-    args.push("--permission-mode", permissionMode);
-  }
-  if (includeSessionId) {
-    const sessionId = claudeSessions.get(sessionKey2);
-    if (sessionId && !activeProcesses.has(sessionKey2)) {
-      args.push("--resume", sessionId);
+  },
+  {
+    name: "webfetch",
+    description: "Fetch content from a URL. Routed through opencode's webfetch tool so permission prompts flow through opencode's UI. Returns the page content in the requested format.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch content from. Must start with http:// or https://."
+        },
+        format: {
+          type: "string",
+          enum: ["text", "markdown", "html"],
+          description: "The format to return the content in. Defaults to markdown."
+        },
+        timeout: {
+          type: "number",
+          description: "Optional timeout in seconds (max 120)."
+        }
+      },
+      required: ["url"]
     }
-  }
-  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);
+  },
+  {
+    name: "task",
+    description: "Launch an opencode subagent to handle a complex multi-step task autonomously. Routed through opencode's task tool so subagent orchestration, permission, and lifecycle are handled by opencode. Use `subagent_type` to pick which configured subagent runs (e.g. `build`, `general`, `explore`, or any custom subagent declared in opencode.json). " + TASK_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        description: {
+          type: "string",
+          description: "A short (3-5 words) description of the task"
+        },
+        prompt: {
+          type: "string",
+          description: "The task for the agent to perform"
+        },
+        subagent_type: {
+          type: "string",
+          description: "The type of specialized agent to use for this task"
+        },
+        task_id: {
+          type: "string",
+          description: "Set this only if you mean to resume a previous task \u2014 pass the prior task_id to continue the same subagent session instead of creating a fresh one."
+        },
+        command: {
+          type: "string",
+          description: "The command that triggered this task"
+        },
+        background: {
+          type: "boolean",
+          description: "Run the task in the background when supported by opencode"
+        }
+      },
+      required: ["description", "prompt", "subagent_type"]
+    }
+  },
+  {
+    name: "question",
+    description: "Ask the operator structured questions with options and receive their answers back. Routed through opencode's native `question` tool so the prompt renders as a real TUI form (with options and a custom-answer field) instead of a plain text turn. Use this when you need a decision, clarification, or preference from the operator mid-task. " + QUESTION_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        questions: {
+          type: "array",
+          description: "Questions to ask.",
+          items: {
+            type: "object",
+            properties: {
+              question: {
+                type: "string",
+                description: "Complete question."
+              },
+              header: {
+                type: "string",
+                description: "Very short label (max 30 chars)."
+              },
+              options: {
+                type: "array",
+                description: "Available choices.",
+                items: {
+                  type: "object",
+                  properties: {
+                    label: {
+                      type: "string",
+                      description: "Display text (1-5 words, concise)."
+                    },
+                    description: {
+                      type: "string",
+                      description: "Explanation of choice."
+                    }
+                  },
+                  required: ["label", "description"]
+                }
+              },
+              multiple: {
+                type: "boolean",
+                description: "Allow selecting multiple choices. Defaults to false."
+              }
+            },
+            required: ["question", "header", "options"]
+          }
+        }
+      },
+      required: ["questions"]
+    }
+  },
+  {
+    name: "compress",
+    description: "Replace older conversation detail with a summary you write, then continue in a fresh Claude Code session. Handled inside the plugin, so it never prompts the operator. " + COMPRESS_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "Dense technical summary of the work being compressed: decisions made, files changed, commands run and their outcomes, and what is still open. This is the ONLY prior context that survives, so anything omitted is lost."
+        }
+      },
+      required: ["summary"]
     }
   }
-  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);
+];
+async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors) {
+  const calls = new EventEmitter();
+  const pending = /* @__PURE__ */ new Map();
+  const authToken = crypto2.randomBytes(32).toString("hex");
+  const expectedAuth = Buffer.from(`Bearer ${authToken}`);
+  let boundAuthority = "";
+  function authOk(req) {
+    const got = req.headers.authorization;
+    if (typeof got !== "string") return false;
+    const candidate = Buffer.from(got);
+    if (candidate.length !== expectedAuth.length) return false;
+    return crypto2.timingSafeEqual(candidate, expectedAuth);
   }
-  if (appendSystemPromptFile) {
-    args.push("--append-system-prompt-file", appendSystemPromptFile);
+  function reject(req, res, statusCode, reason) {
+    log.notice("proxy-mcp rejected a request", {
+      statusCode,
+      reason,
+      method: req.method,
+      hasAuthorization: typeof req.headers.authorization === "string"
+    });
+    res.statusCode = statusCode;
+    res.setHeader("Connection", "close");
+    res.on("finish", () => {
+      req.socket?.destroy();
+    });
+    res.end();
   }
-  if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
-    args.push("--settings", JSON.stringify({ fastMode: true }));
-  }
-  if (skipPermissions) {
-    args.push("--dangerously-skip-permissions");
-  }
-  return args;
-}
-function sessionKey(cwd, modelId) {
-  return `${cwd}::${modelId}`;
-}
-
-// src/claude-session-wrapper.ts
-import { EventEmitter as EventEmitter2 } from "events";
-import { unlink as unlink2 } from "fs/promises";
-
-// src/claude-session-bun.ts
-import * as os3 from "os";
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { execFileSync } from "child_process";
-import { randomUUID } from "crypto";
-function resolveClaude(cmd = "claude") {
-  if (path3.isAbsolute(cmd) && fs3.existsSync(cmd)) return cmd;
-  const viaBun = Bun.which(cmd);
-  if (viaBun) return viaBun;
-  const isWin = os3.platform() === "win32";
-  try {
-    const out = execFileSync(isWin ? "where" : "which", [cmd], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs3.existsSync(p));
-    if (first) return first;
-  } catch {
-  }
-  throw new Error(`Could not resolve command on PATH: ${cmd}`);
-}
-function encodeCwd(cwd) {
-  return path3.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
-}
-var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
-var delay = (ms) => new Promise((r) => setTimeout(r, ms));
-function resolveConfigDir(configDir) {
-  const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path3.join(os3.homedir(), ".claude");
-  if (value === "~") return os3.homedir();
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path3.join(os3.homedir(), value.slice(2));
-  }
-  return path3.resolve(value);
-}
-var ClaudeSession = class {
-  sessionId;
-  cwd;
-  configDir;
-  jsonlPath;
-  raw = "";
-  proc = null;
-  cursor = 0;
-  // index into transcript split('\n')
-  lastDataAt = 0;
-  exited = false;
-  exitCode = null;
-  aborted = false;
-  signal;
-  o;
-  constructor(opts = {}) {
-    this.cwd = path3.resolve(opts.cwd ?? process.cwd());
-    this.configDir = resolveConfigDir(opts.configDir);
-    this.signal = opts.signal;
-    this.sessionId = randomUUID();
-    this.jsonlPath = path3.join(
-      this.configDir,
-      "projects",
-      encodeCwd(this.cwd),
-      `${this.sessionId}.jsonl`
-    );
-    this.o = {
-      cwd: this.cwd,
-      cliPath: opts.cliPath,
-      configDir: this.configDir,
-      model: opts.model,
-      settingSources: opts.settingSources,
-      extraArgs: opts.extraArgs ?? [],
-      ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
-      cols: opts.cols ?? 200,
-      rows: opts.rows ?? 50,
-      bootMinMs: opts.bootMinMs ?? 3e3,
-      bootQuietMs: opts.bootQuietMs ?? 1500,
-      bootMaxMs: opts.bootMaxMs ?? 25e3,
-      pollMs: opts.pollMs ?? 250,
-      // Agentic turns (tool loops) routinely run for many minutes; a short
-      // cap would surface as a mid-task error result. 30 min mirrors the
-      // proxy-tool ceiling rather than a chat-reply expectation.
-      turnTimeoutMs: opts.turnTimeoutMs ?? 18e5,
-      bracketedPaste: opts.bracketedPaste ?? true,
-      submitMinMs: opts.submitMinMs ?? 200,
-      submitConfirmMs: opts.submitConfirmMs ?? 1500,
-      submitMaxRetries: opts.submitMaxRetries ?? 8,
-      debug: opts.debug ?? false
-    };
-  }
-  async start() {
-    if (this.signal?.aborted) throw new Error("aborted before start");
-    this.signal?.addEventListener(
-      "abort",
-      () => {
-        this.aborted = true;
-        this.dispose();
-      },
-      { once: true }
-    );
-    const claude = resolveClaude(this.o.cliPath ?? "claude");
-    const args = ["--session-id", this.sessionId];
-    if (this.o.model) args.push("--model", this.o.model);
-    if (this.o.settingSources !== null && this.o.settingSources !== void 0) {
-      args.push("--setting-sources", this.o.settingSources);
-    }
-    if (this.o.extraArgs && this.o.extraArgs.length) args.push(...this.o.extraArgs);
-    if (this.o.debug)
-      process.stderr.write(`[session] spawn: ${claude} ${args.join(" ")}
-`);
-    this.lastDataAt = Date.now();
-    this.proc = Bun.spawn([claude, ...args], {
-      cwd: this.cwd,
-      env: {
-        ...process.env,
-        CLAUDE_CONFIG_DIR: this.o.configDir,
-        TERM: "xterm-256color",
-        ...this.o.ignoreAnthropicApiKey ? { ANTHROPIC_API_KEY: void 0, ANTHROPIC_AUTH_TOKEN: void 0 } : {}
-      },
-      terminal: {
-        cols: this.o.cols,
-        rows: this.o.rows,
-        data: (_term, d) => {
-          this.lastDataAt = Date.now();
-          const chunk = Buffer.from(d).toString("utf8");
-          this.raw += chunk;
-          if (this.o.debug) process.stdout.write(chunk);
-        }
-      }
-    });
-    this.proc.exited.then((code) => {
-      this.exitCode = typeof code === "number" ? code : null;
-      this.exited = true;
-      this.proc = null;
-    }).catch(() => {
-      this.exited = true;
-      this.proc = null;
-    });
-    await this.waitForBoot();
-    this.cursor = this.lineCount();
-  }
-  /** Wait until the TUI has been quiet for bootQuietMs (Ink ready), bounded by
-   *  bootMinMs..bootMaxMs. */
-  async waitForBoot() {
-    const start = Date.now();
-    while (Date.now() - start < this.o.bootMaxMs) {
-      await delay(150);
-      if (this.aborted) throw new Error("aborted during boot");
-      if (this.exited) {
-        throw new Error(this.failureMessage("claude exited during boot", true));
-      }
-      const elapsed = Date.now() - start;
-      const sinceData = Date.now() - this.lastDataAt;
-      if (elapsed >= this.o.bootMinMs && sinceData >= this.o.bootQuietMs) return;
+  const server2 = createServer(async (req, res) => {
+    if (req.method !== "POST" || !req.url?.startsWith("/mcp")) {
+      reject(req, res, 404, "not a POST to /mcp");
+      return;
     }
-  }
-  /** Submit the freshly-injected prompt and confirm the turn was actually
-   *  accepted. A large bracketed paste collapses into a "[Pasted text]"
-   *  placeholder; an Enter sent while claude is still ingesting the paste is
-   *  silently dropped, so a single fixed-delay Enter races the paste and can
-   *  leave the prompt sitting unsubmitted (→ hang until turnTimeoutMs). Send
-   *  Enter, then poll for transcript growth past the cursor (the turn's records
-   *  are written on acceptance); resend Enter until accepted or the retry
-   *  budget is spent. Polling growth (not a blind delay) also stops us from
-   *  sending a stray Enter once the turn is in flight. */
-  async submitTurn() {
-    await delay(this.o.submitMinMs);
-    for (let attempt = 0; attempt < this.o.submitMaxRetries; attempt++) {
-      if (this.aborted || this.exited || !this.proc) return;
-      this.proc.terminal.write("\r");
-      const until = Date.now() + this.o.submitConfirmMs;
-      while (Date.now() < until) {
-        await delay(80);
-        if (this.aborted || this.exited) return;
-        if (this.lineCount() > this.cursor) return;
-      }
+    if (req.headers.host !== boundAuthority) {
+      reject(req, res, 403, "host header is not the bound authority");
+      return;
     }
-  }
-  readRawLines() {
-    try {
-      return fs3.readFileSync(this.jsonlPath, "utf8").split("\n");
-    } catch {
-      return [];
+    if (req.headers.origin !== void 0) {
+      reject(req, res, 403, "origin header present");
+      return;
     }
-  }
-  /** Count of complete lines (split('\n') minus the trailing/partial element). */
-  lineCount() {
-    const lines = this.readRawLines();
-    return lines.length > 0 ? lines.length - 1 : 0;
-  }
-  rawTail(max = 600) {
-    const clean = this.raw.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\s+/g, " ").trim();
-    return clean.length > max ? clean.slice(-max) : clean;
-  }
-  failureMessage(reason, includeRaw = false) {
-    const parts = [
-      `${reason} (sessionId=${this.sessionId}, jsonlPath=${this.jsonlPath}, exitCode=${this.exitCode ?? "unknown"})`
-    ];
-    if (includeRaw) {
-      const tail = this.rawTail();
-      if (tail) parts.push(`terminalTail=${JSON.stringify(tail)}`);
+    const contentType = String(req.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
+    if (contentType !== "application/json") {
+      reject(req, res, 415, "content-type is not application/json");
+      return;
     }
-    return parts.join("; ");
-  }
-  /**
-   * Inject a turn into the live session and return the assistant reply once a
-   * terminal stop_reason is observed in the transcript.
-   */
-  async ask(prompt, perTurnTimeoutMs) {
-    if (this.aborted) throw new Error("aborted");
-    if (!this.proc || this.exited)
-      throw new Error("session not started or already exited");
-    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
-    const t0 = Date.now();
-    if (this.o.bracketedPaste) {
-      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
-    } else {
-      this.proc.terminal.write(prompt);
+    if (!authOk(req)) {
+      reject(req, res, 401, "missing or invalid bearer token");
+      return;
     }
-    await this.submitTurn();
-    const collected = [];
-    let lastUsage = null;
-    let stopReason = null;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      await delay(this.o.pollMs);
-      if (this.aborted) throw new Error("aborted mid-turn");
-      const lines = this.readRawLines();
-      const lastComplete = lines.length - 1;
-      if (lastComplete <= this.cursor) {
-        if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
-        continue;
-      }
-      for (let i = this.cursor; i < lastComplete; i++) {
-        const s = lines[i];
-        if (!s || !s.trim()) continue;
-        let rec;
-        try {
-          rec = JSON.parse(s);
-        } catch {
-          continue;
-        }
-        if (rec.type === "assistant" && rec.message) {
-          for (const b of rec.message.content ?? []) {
-            if (b?.type === "text" && typeof b.text === "string")
-              collected.push(b.text);
+    let requestId = null;
+    let requestMethod = null;
+    let sse = null;
+    try {
+      const body = await readBody(req);
+      const request = JSON.parse(body);
+      requestId = request?.id ?? null;
+      requestMethod = typeof request?.method === "string" ? request.method : null;
+      if (request?.jsonrpc !== "2.0" || typeof request.method !== "string") {
+        writeJson(res, {
+          jsonrpc: "2.0",
+          id: requestId,
+          error: { code: -32600, message: "Invalid request" }
+        });
+        return;
+      }
+      log.debug("proxy-mcp request", {
+        method: request.method,
+        id: request.id
+      });
+      if (request.method === "initialize") {
+        writeJson(res, {
+          jsonrpc: "2.0",
+          id: requestId,
+          result: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: {
+              name: SERVER_NAME,
+              version: "0.1.0"
+            }
           }
-          if (rec.message.usage) lastUsage = rec.message.usage;
-          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
-            stopReason = rec.message.stop_reason;
+        });
+        return;
+      }
+      if (request.method === "notifications/initialized") {
+        res.statusCode = 204;
+        res.end();
+        return;
+      }
+      if (request.method === "tools/list") {
+        writeJson(res, {
+          jsonrpc: "2.0",
+          id: requestId,
+          result: {
+            tools: tools.map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: t.inputSchema
+            }))
           }
-        }
+        });
+        return;
       }
-      this.cursor = lastComplete;
-      if (stopReason) break;
-    }
-    if (!stopReason) {
-      throw new Error(
-        this.failureMessage(
-          `turn timed out after ${timeout}ms (no terminal assistant record; collected ${collected.length} text block(s))`
-        )
-      );
-    }
-    const u = lastUsage ?? {};
-    return {
-      text: collected.join("\n").trim(),
-      stopReason,
-      usage: lastUsage,
-      cacheReadTokens: u.cache_read_input_tokens ?? 0,
-      cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
-      ephemeral1hTokens: u.cache_creation?.ephemeral_1h_input_tokens ?? 0,
-      ephemeral5mTokens: u.cache_creation?.ephemeral_5m_input_tokens ?? 0,
-      inputTokens: u.input_tokens ?? 0,
-      outputTokens: u.output_tokens ?? 0,
-      elapsedMs: Date.now() - t0
-    };
-  }
-  /**
-   * Like ask(), but instead of collecting the reply text it re-emits each NEW
-   * raw JSONL transcript line via onLine (verbatim) until a terminal
-   * stop_reason. Returns the terminal stop_reason + the last assistant usage.
-   * Used by the opencode plugin transport shim, which feeds these raw lines
-   * into the existing stream-json line handler unchanged.
-   */
-  async tailTurn(prompt, onLine, perTurnTimeoutMs) {
-    if (this.aborted) throw new Error("aborted");
-    if (!this.proc || this.exited)
-      throw new Error("session not started or already exited");
-    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
-    if (this.o.bracketedPaste) {
-      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
-    } else {
-      this.proc.terminal.write(prompt);
-    }
-    await this.submitTurn();
-    let lastUsage = null;
-    let totalOutput = 0;
-    let stopReason = null;
-    const deadline = Date.now() + timeout;
-    while (Date.now() < deadline) {
-      await delay(this.o.pollMs);
-      if (this.aborted) throw new Error("aborted mid-turn");
-      const lines = this.readRawLines();
-      const lastComplete = lines.length - 1;
-      if (lastComplete <= this.cursor) {
-        if (this.exited) {
-          throw new Error(this.failureMessage("claude exited mid-turn", true));
+      if (request.method === "tools/call") {
+        const params = request.params ?? {};
+        const toolName = String(params.name ?? "");
+        const input = params.arguments ?? {};
+        if (!tools.some((t) => t.name === toolName)) {
+          writeJson(res, {
+            jsonrpc: "2.0",
+            id: requestId,
+            result: {
+              content: [{ type: "text", text: `Unknown proxy tool: ${toolName}` }],
+              isError: true
+            }
+          });
+          return;
         }
-        continue;
+        const interceptor = interceptors?.get(toolName);
+        if (interceptor) {
+          let intercepted;
+          try {
+            intercepted = await interceptor(input);
+          } catch (interceptorError) {
+            const message = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+            log.warn("proxy-mcp interceptor failed", { toolName, error: message });
+            intercepted = { kind: "error", message };
+          }
+          writeToolCallResult(res, requestId, intercepted);
+          return;
+        }
+        const callId = crypto2.randomUUID();
+        log.info("proxy-mcp tool call received", {
+          callId,
+          toolName,
+          hasInput: input != null,
+          sse: acceptsEventStream(req.headers.accept)
+        });
+        const channel = { closed: false };
+        if (acceptsEventStream(req.headers.accept)) {
+          sse = openEventStream(res);
+        }
+        res.once("close", () => {
+          sse?.stop();
+          if (res.writableFinished) return;
+          channel.closed = true;
+          log.notice("proxy-mcp client closed a tool call before its result", {
+            callId,
+            toolName
+          });
+        });
+        let timer = null;
+        const result = await new Promise(
+          (resolve4, reject2) => {
+            const entry = {
+              id: callId,
+              toolName,
+              input,
+              resolve: resolve4,
+              reject: reject2,
+              channel
+            };
+            pending.set(callId, entry);
+            const deadlineMs = resolveProxyCallTimeoutMs(
+              toolName,
+              input,
+              timeoutOverrides
+            );
+            timer = setTimeout(() => {
+              if (!pending.has(callId)) return;
+              pending.delete(callId);
+              log.notice("proxy-mcp tool call timed out", {
+                callId,
+                toolName,
+                deadlineMs
+              });
+              reject2(buildProxyTimeoutError(toolName, deadlineMs));
+            }, deadlineMs);
+            calls.emit("call", entry);
+          }
+        ).finally(() => {
+          if (timer) clearTimeout(timer);
+          pending.delete(callId);
+        });
+        if (channel.closed) {
+          log.notice("proxy-mcp dropping result for a closed tool call", {
+            callId,
+            toolName
+          });
+          return;
+        }
+        writeToolCallResult(res, requestId, result, sse);
+        return;
       }
-      for (let i = this.cursor; i < lastComplete; i++) {
-        const s = lines[i];
-        if (!s || !s.trim()) continue;
-        onLine(s);
-        let rec;
+      writeJson(res, {
+        jsonrpc: "2.0",
+        id: requestId,
+        error: { code: -32601, message: `Unknown method: ${request.method}` }
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const logFn = isExpectedCleanupError(errorMessage) ? log.notice : log.warn;
+      logFn("proxy-mcp error handling request", {
+        error: errorMessage
+      });
+      if (requestMethod === "tools/call") {
         try {
-          rec = JSON.parse(s);
+          writeToolCallResult(
+            res,
+            requestId,
+            { kind: "error", message: errorMessage },
+            sse
+          );
         } catch {
-          continue;
-        }
-        if (rec.type === "assistant" && rec.message) {
-          if (rec.message.usage) {
-            lastUsage = rec.message.usage;
-            totalOutput += rec.message.usage.output_tokens ?? 0;
-          }
-          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
-            stopReason = rec.message.stop_reason;
+          try {
+            res.statusCode = 500;
+            res.end();
+          } catch {
           }
         }
+        return;
       }
-      this.cursor = lastComplete;
-      if (stopReason) break;
-    }
-    let usage = lastUsage;
-    if (lastUsage) {
-      usage = { ...lastUsage, output_tokens: totalOutput };
-      if (Array.isArray(lastUsage.iterations) && lastUsage.iterations.length > 0) {
-        const iters = lastUsage.iterations.map((it) => ({ ...it }));
-        iters[iters.length - 1] = {
-          ...iters[iters.length - 1],
-          output_tokens: totalOutput
-        };
-        usage.iterations = iters;
-      }
-    }
-    if (!stopReason) {
-      throw new Error(
-        this.failureMessage(
-          `turn timed out after ${timeout}ms (no terminal assistant record)`
-        )
-      );
-    }
-    return { stopReason, usage };
-  }
-  dispose() {
-    if (this.proc) {
       try {
-        this.proc.terminal.write("");
+        writeJson(res, {
+          jsonrpc: "2.0",
+          id: requestId,
+          error: {
+            code: -32603,
+            message: error instanceof Error ? error.message : "Internal error"
+          }
+        });
       } catch {
+        try {
+          res.statusCode = 500;
+          res.end();
+        } catch {
+        }
       }
-      try {
-        this.proc.kill();
-      } catch {
-      }
-      try {
-        this.proc.terminal.close();
-      } catch {
-      }
-    }
-    this.proc = null;
-  }
-};
-
-// src/claude-session-wrapper.ts
-function decodeUserEnvelope(chunk) {
-  let parsed;
-  try {
-    parsed = JSON.parse(chunk);
-  } catch {
-    return chunk;
-  }
-  if (!parsed || parsed.type !== "user" || !parsed.message) return chunk;
-  const content = parsed.message.content;
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return chunk;
-  const parts = [];
-  let dropped = 0;
-  for (const block of content) {
-    if (block?.type === "text" && typeof block.text === "string") {
-      parts.push(block.text);
-    } else if (block?.type === "tool_result") {
-      const v = block.content;
-      const text = typeof v === "string" ? v : Array.isArray(v) ? v.map((i) => i?.type === "text" ? i.text : "").filter(Boolean).join("\n") : "";
-      parts.push(
-        `[Tool result${block.tool_use_id ? ` ${block.tool_use_id}` : ""}]
-${text}`
-      );
-    } else {
-      dropped++;
     }
-  }
-  if (dropped > 0) {
-    log.warn("interactive transport dropped non-text content blocks", {
-      dropped
+  });
+  await new Promise((resolve4, reject2) => {
+    server2.once("error", reject2);
+    server2.listen(0, "127.0.0.1", () => {
+      server2.off("error", reject2);
+      resolve4();
     });
-  }
-  return parts.join("\n\n");
-}
-function spawnInteractiveProcess(opts) {
-  const extraArgs = [];
-  if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
-    extraArgs.push(
-      "--mcp-config",
-      ...opts.mcpConfigPaths,
-      "--strict-mcp-config"
-    );
-  }
-  const flagSettings = {};
-  if (opts.permissionsAllow && opts.permissionsAllow.length > 0) {
-    flagSettings.permissions = { allow: opts.permissionsAllow };
-  }
-  if (opts.fastMode) {
-    flagSettings.fastMode = true;
-  }
-  if (Object.keys(flagSettings).length > 0) {
-    extraArgs.push("--settings", JSON.stringify(flagSettings));
-  }
-  if (opts.permissionMode === "bypassPermissions") {
-    log.warn(
-      "interactive permissionMode bypassPermissions ignored: Claude Code prompts for confirmation in the TUI"
-    );
-  } else if (opts.permissionMode) {
-    extraArgs.push("--permission-mode", opts.permissionMode);
-  }
-  if (opts.systemPromptFile) {
-    extraArgs.push("--append-system-prompt-file", opts.systemPromptFile);
-  }
-  const session = new ClaudeSession({
-    cwd: opts.cwd,
-    cliPath: opts.cliPath,
-    configDir: opts.configDir,
-    model: opts.model,
-    // Default null = normal CLAUDE.md + settings load, matching what the
-    // headless spawn does. "" (skip everything) is for fast e2e runs only.
-    settingSources: opts.settingSources === void 0 ? null : opts.settingSources,
-    extraArgs,
-    ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey
   });
-  log.info("prepared interactive claude session", {
-    cwd: opts.cwd,
-    cliPath: opts.cliPath ?? "claude",
-    configDir: session.configDir,
-    model: opts.model,
-    sessionId: session.sessionId,
-    jsonlPath: session.jsonlPath
+  const addr = server2.address();
+  if (!addr) {
+    server2.close();
+    throw new Error("Failed to bind proxy MCP server");
+  }
+  boundAuthority = `127.0.0.1:${addr.port}`;
+  const url = `http://${boundAuthority}/mcp`;
+  log.info("proxy-mcp server started", {
+    url,
+    tools: tools.map((t) => t.name)
   });
-  const lineEmitter = new EventEmitter2();
-  const errorHandlers = /* @__PURE__ */ new Set();
-  let startPromise = null;
-  const ensureStarted = () => {
-    if (!startPromise) startPromise = session.start();
-    return startPromise;
-  };
-  const emitResult = (subtype, isError, result, usage) => {
-    lineEmitter.emit(
-      "line",
-      JSON.stringify({
-        type: "result",
-        subtype,
-        is_error: isError,
-        result,
-        session_id: session.sessionId,
-        usage: usage ?? {},
-        total_cost_usd: null,
-        duration_ms: 0
-      })
-    );
-  };
-  const runTurn = (userMsg) => {
-    void (async () => {
-      try {
-        await ensureStarted();
-        const { stopReason, usage } = await session.tailTurn(userMsg, (raw) => {
-          lineEmitter.emit("line", raw);
-        });
-        const timedOut = !stopReason;
-        emitResult(
-          timedOut ? "error_during_execution" : stopReason,
-          timedOut,
-          timedOut ? "Interactive transport: the turn ended without a terminal stop_reason (turn timeout or claude exit). Output above may be incomplete." : void 0,
-          usage
-        );
-      } catch (err) {
-        const e = err instanceof Error ? err : new Error(String(err));
-        log.error("interactive turn failed", { error: e.message });
-        emitResult(
-          "error_during_execution",
-          true,
-          `Interactive transport failed: ${e.message}`
-        );
-        if (errorHandlers.size > 0) {
-          for (const h of errorHandlers) h(e);
-        } else {
-          lineEmitter.emit("close");
-        }
-      }
-    })();
-  };
-  const proc = {
-    stdin: {
-      write(chunk) {
-        const raw = typeof chunk === "string" && chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk;
-        runTurn(decodeUserEnvelope(raw));
-        return true;
-      },
-      end() {
-      }
-    },
-    stdout: null,
-    stderr: null,
-    pid: -1,
-    killed: false,
-    on(event, fn) {
-      if (event === "error") errorHandlers.add(fn);
-      return proc;
-    },
-    once() {
-      return proc;
-    },
-    off(event, fn) {
-      if (event === "error") errorHandlers.delete(fn);
-      return proc;
+  let configFilePath = null;
+  const api = {
+    url,
+    serverName: SERVER_NAME,
+    tools,
+    authToken,
+    calls,
+    configPath() {
+      if (configFilePath) return configFilePath;
+      const body = JSON.stringify(
+        {
+          mcpServers: {
+            [SERVER_NAME]: {
+              type: "http",
+              url,
+              // Claude CLI replays these headers on every request to this
+              // server, which is what lets the handler above reject anyone
+              // who did not read this 0600 file.
+              headers: { Authorization: `Bearer ${authToken}` },
+              timeout: resolveProxyClientCeilingMs(timeoutOverrides)
+            }
+          }
+        },
+        null,
+        2
+      );
+      const hash = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
+      const outPath = path4.join(
+        pluginTmpDir(),
+        `proxy-${hash}.json`
+      );
+      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      configFilePath = outPath;
+      return outPath;
     },
-    kill() {
-      try {
-        session.dispose();
-      } catch {
+    async close() {
+      for (const entry of pending.values()) {
+        entry.reject(new Error(SERVER_CLOSED_MESSAGE));
       }
-      if (opts.systemPromptFile) {
-        void unlink2(opts.systemPromptFile).catch(() => {
-        });
+      pending.clear();
+      await new Promise((resolve4) => {
+        server2.close(() => resolve4());
+      });
+      if (configFilePath) {
+        try {
+          fs3.unlinkSync(configFilePath);
+        } catch {
+        }
+        configFilePath = null;
       }
-      proc.killed = true;
-      return true;
     }
   };
-  return {
-    proc,
-    lineEmitter,
-    proxyServer: null,
-    mcpHash: void 0,
-    systemPromptFile: opts.systemPromptFile
-  };
-}
-
-// src/compression-store.ts
-var MAX_COMPRESSION_ENTRIES = 32;
-var compressions = /* @__PURE__ */ new Map();
-function storeCompressionSummary(sessionKey2, summary) {
-  compressions.set(sessionKey2, { summary, restartPending: true });
-  while (compressions.size > MAX_COMPRESSION_ENTRIES) {
-    const oldest = compressions.keys().next();
-    if (oldest.done) break;
-    compressions.delete(oldest.value);
-    log.info("compression store evicted oldest entry", { sessionKey: oldest.value });
-  }
+  return api;
 }
-function getCompressionSummary(sessionKey2) {
-  return compressions.get(sessionKey2)?.summary;
+function disallowedToolFlags(tools) {
+  const nameMap = {
+    bash: ["Bash"],
+    read: ["Read"],
+    write: ["Write"],
+    edit: ["Edit", "MultiEdit"],
+    glob: ["Glob"],
+    grep: ["Grep"],
+    webfetch: ["WebFetch"],
+    task: ["Agent"],
+    // `question` disables Claude Code's built-in `AskUserQuestion` so the
+    // structured-questions path flows through opencode's native `question`
+    // tool instead — same UI/permission/audit benefits as the other
+    // proxies. Without this, the model can call both and the two paths
+    // diverge (opencode's form vs the headless deny-and-render fallback).
+    question: ["AskUserQuestion"]
+  };
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of tools) {
+    const mapped = nameMap[t.name.toLowerCase()];
+    if (!mapped) continue;
+    for (const claudeTool of mapped) {
+      if (seen.has(claudeTool)) continue;
+      seen.add(claudeTool);
+      out.push(claudeTool);
+    }
+  }
+  return out;
 }
-function consumeCompressionRestart(sessionKey2) {
-  const state = compressions.get(sessionKey2);
-  if (!state?.restartPending) return false;
-  state.restartPending = false;
-  return true;
+function resolveDisallowedTools(options) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (name) => {
+    const trimmed = name.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    seen.add(trimmed);
+    out.push(trimmed);
+  };
+  for (const name of disallowedToolFlags(options.proxyTools ?? [])) push(name);
+  for (const name of options.extraDisallowedTools ?? []) push(String(name));
+  if (options.disableWebSearch) push("WebSearch");
+  return out;
 }
-function clearCompression(sessionKey2) {
-  compressions.delete(sessionKey2);
+function readBody(req) {
+  return new Promise((resolve4, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+function writeToolCallResult(res, requestId, result, sse = null) {
+  const text = result.kind === "error" ? result.message : result.text;
+  const isError = result.kind === "error" || result.isError === true;
+  const envelope = {
+    jsonrpc: "2.0",
+    id: requestId ?? null,
+    result: {
+      content: [{ type: "text", text }],
+      isError
+    }
+  };
+  if (sse) {
+    sse.finish(envelope);
+    return;
+  }
+  writeJson(res, envelope);
 }
+function openEventStream(res) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+  res.write(": open\n\n");
+  let timer = setInterval(() => {
+    if (res.writableEnded || res.destroyed) {
+      stop();
+      return;
+    }
+    res.write(": keepalive\n\n");
+  }, SSE_KEEPALIVE_MS);
+  timer.unref?.();
+  const stop = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  return {
+    stop,
+    finish(envelope) {
+      stop();
+      if (res.writableEnded || res.destroyed) return;
+      res.end(`event: message
+data: ${JSON.stringify(envelope)}
 
-// src/proxy-mcp.ts
-import { createServer } from "http";
-import * as fs4 from "fs";
-import * as path4 from "path";
-import * as crypto2 from "crypto";
-import { EventEmitter as EventEmitter3 } from "events";
-var SERVER_CLOSED_MESSAGE = "proxy MCP server closed";
-function isExpectedCleanupError(message) {
-  return message.includes("timed out after") && message.includes("waiting for opencode to resolve") || message.includes("rejecting as orphaned") || message.includes("was orphaned by a new user turn") || message.includes("stream was aborted") || message.includes(SERVER_CLOSED_MESSAGE);
+`);
+    }
+  };
 }
-var PROTOCOL_VERSION = "2024-11-05";
-var SERVER_NAME = "opencode_proxy";
-var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
-var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
-var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
-  task: 60 * 60 * 1e3,
-  // 60 min
-  question: 30 * 60 * 1e3
-  // 30 min
-};
-var MAX_PROXY_TIMEOUT_MS = 2 ** 31 - 1;
-function resolveProxyCallTimeoutMs(toolName, input, overrides) {
-  const key = toolName.toLowerCase();
-  let ms = PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS[key] ?? PROXY_DEFAULT_TIMEOUT_MS;
-  if (overrides) {
-    const ov = lookupCaseInsensitive(overrides, key);
-    if (typeof ov === "number" && ov > 0) ms = ov;
-  }
-  if (key === "bash") {
-    const requested = input?.timeout;
-    if (typeof requested === "number" && requested > ms) ms = requested;
-  }
-  return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
+function writeJson(res, body) {
+  if (res.destroyed || res.writableEnded) return;
+  const payload = JSON.stringify(body);
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.setHeader("Content-Length", Buffer.byteLength(payload).toString());
+  res.end(payload);
 }
-function lookupCaseInsensitive(map, key) {
-  if (Object.prototype.hasOwnProperty.call(map, key)) return map[key];
-  for (const k of Object.keys(map)) {
-    if (k.toLowerCase() === key) return map[k];
-  }
-  return void 0;
+
+// src/proxy-broker.ts
+var pendingByCallId = /* @__PURE__ */ new Map();
+var callIdsBySession = /* @__PURE__ */ new Map();
+var emitter = new EventEmitter2();
+function eventName(sessionKey2) {
+  return `pending:${sessionKey2}`;
 }
-function resolveProxyClientCeilingMs(overrides) {
-  let ms = PROXY_DEFAULT_TIMEOUT_MS;
-  for (const v of Object.values(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
-    if (v > ms) ms = v;
-  }
-  if (overrides) {
-    for (const v of Object.values(overrides)) {
-      if (typeof v === "number" && v > ms) ms = v;
-    }
+function indexAdd(sessionKey2, callId) {
+  let s = callIdsBySession.get(sessionKey2);
+  if (!s) {
+    s = /* @__PURE__ */ new Set();
+    callIdsBySession.set(sessionKey2, s);
   }
-  return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
+  s.add(callId);
 }
-function buildProxyTimeoutError(toolName, ms) {
-  const key = toolName.toLowerCase();
-  const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
-  if (key === "task") {
-    return new Error(
-      base + " (the subagent). The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
-    );
-  }
-  return new Error(base);
+function indexRemove(sessionKey2, callId) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return;
+  s.delete(callId);
+  if (s.size === 0) callIdsBySession.delete(sessionKey2);
 }
-var TASK_PROXY_NOTE = "This is the ONLY tool that dispatches opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists \u2014 invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
-var AGENT_TYPES_HEADING = "Available agent types";
-var AGENT_BLURB_LIMIT = 140;
-var QUESTION_PROXY_NOTE = "This routes structured questions through opencode's native `question` tool, which renders a TUI form with the options you provide and blocks until the operator answers. Claude Code's built-in AskUserQuestion is disabled in this environment; this proxy is the ONLY way to ask the operator for a decision or clarification. Answers come back as arrays of selected labels (set `multiple: true` to allow more than one). If the operator dismisses the form the call returns an error \u2014 treat that as 'no answer' and stop, do not guess. Question calls get a 30-minute proxy deadline by default (configurable via proxyToolTimeoutMs); for long-AFK scenarios prefer fewer, high-signal questions.";
-var COMPRESS_PROXY_NOTE = "The current turn continues normally after this call \u2014 finish what you are doing. The reset happens at the START of the next turn: the Claude Code session is discarded and a fresh one begins with your summary as its only prior context. Everything else, including tool output and files you read, is gone, so write the summary as the authoritative record. Call this once per compression, when older resolved work no longer needs full detail.";
-function extractAgentTypeList(liveDescription) {
-  const live = liveDescription?.trim();
-  if (!live) return void 0;
-  const start = live.indexOf(AGENT_TYPES_HEADING);
-  if (start === -1) return void 0;
-  const entries = [];
-  for (const raw of live.slice(start).split("\n")) {
-    const match = /^-\s*([^:]+):\s*(.+)$/.exec(raw.trim());
-    if (!match) continue;
-    const name = match[1].trim();
-    const blurb = match[2].trim();
-    entries.push(
-      `- ${name}: ${blurb.length > AGENT_BLURB_LIMIT ? `${blurb.slice(0, AGENT_BLURB_LIMIT).trimEnd()}\u2026` : blurb}`
+function onPendingProxyCall(sessionKey2, handler) {
+  const name = eventName(sessionKey2);
+  emitter.on(name, handler);
+  return () => emitter.off(name, handler);
+}
+function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
+  const previous = pendingByCallId.get(call.id);
+  if (previous) {
+    clearTimeout(previous.timer);
+    previous.reject(
+      new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
     );
+    pendingByCallId.delete(call.id);
+    indexRemove(previous.sessionKey, call.id);
   }
-  if (entries.length === 0) return void 0;
-  return `Valid subagent_type values, from opencode's live registry \u2014 anything else fails:
-${entries.join("\n")}`;
-}
-function overlayTaskProxyDescription(tools, liveDescription) {
-  const agentTypes = extractAgentTypeList(liveDescription);
-  if (!agentTypes) return tools;
-  return tools.map(
-    (t) => t.name === "task" ? { ...t, description: `${agentTypes}
-
-${t.description}` } : t
+  const deadlineMs = resolveProxyCallTimeoutMs(
+    call.toolName,
+    call.input,
+    timeoutOverrides
   );
+  const timer = setTimeout(() => {
+    const current = pendingByCallId.get(call.id);
+    if (!current) return;
+    pendingByCallId.delete(call.id);
+    indexRemove(current.sessionKey, call.id);
+    current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
+    log.notice("timed out pending proxy call", {
+      sessionKey: current.sessionKey,
+      toolCallId: call.id,
+      toolName: call.toolName,
+      deadlineMs
+    });
+  }, deadlineMs);
+  const pending = {
+    sessionKey: sessionKey2,
+    toolCallId: call.id,
+    toolName: call.toolName,
+    input: call.input,
+    channel: call.channel,
+    createdAt: Date.now(),
+    timer,
+    resolve: call.resolve,
+    reject: call.reject
+  };
+  pendingByCallId.set(call.id, pending);
+  indexAdd(sessionKey2, call.id);
+  emitter.emit(eventName(sessionKey2), pending);
+  log.info("queued pending proxy call", {
+    sessionKey: sessionKey2,
+    toolCallId: call.id,
+    toolName: call.toolName
+  });
+  return pending;
 }
-function overlayQuestionProxyDescription(tools, liveDescription) {
-  const live = liveDescription?.trim();
-  if (!live) return tools;
-  return tools.map(
-    (t) => t.name === "question" ? { ...t, description: `${live}
-
-${QUESTION_PROXY_NOTE}` } : t
-  );
+function markPendingProxyCallEmitted(toolCallId) {
+  const pending = pendingByCallId.get(toolCallId);
+  if (pending) pending.emitted = true;
 }
-function filterQuestionProxyByOpencodeSupport(tools, opencodeHasQuestion) {
-  if (opencodeHasQuestion) return tools;
-  return tools.filter((t) => t.name !== "question");
+function isPendingProxyCallChannelClosed(call) {
+  return call.channel?.closed === true;
 }
-var DEFAULT_PROXY_TOOLS = [
-  {
-    name: "bash",
-    description: "Execute a shell command. Routed through opencode's bash tool so permission prompts flow through opencode's UI.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        command: {
-          type: "string",
-          description: "The shell command to execute."
-        },
-        description: {
-          type: "string",
-          description: "Short human-readable description of what the command does."
-        },
-        timeout: {
-          type: "number",
-          description: "Optional timeout in milliseconds."
-        }
-      },
-      required: ["command"]
-    }
-  },
-  {
-    name: "write",
-    description: "Write a file. Routed through opencode's write tool so permission prompts flow through opencode's UI.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filePath: {
-          type: "string",
-          description: "The file to write. Absolute paths are preferred."
-        },
-        content: {
-          type: "string",
-          description: "The full content to write to the file."
-        }
-      },
-      required: ["filePath", "content"]
-    }
-  },
-  {
-    name: "edit",
-    description: "Replace text in an existing file. Routed through opencode's edit tool so permission prompts flow through opencode's UI.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filePath: {
-          type: "string",
-          description: "The file to edit. Absolute paths are preferred."
-        },
-        oldString: {
-          type: "string",
-          description: "The exact text to replace."
-        },
-        newString: {
-          type: "string",
-          description: "The replacement text."
-        },
-        replaceAll: {
-          type: "boolean",
-          description: "Replace all occurrences instead of just the first one."
-        }
-      },
-      required: ["filePath", "oldString", "newString"]
+function getPendingProxyCalls(sessionKey2) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s || s.size === 0) return [];
+  const out = [];
+  for (const id of s) {
+    const p = pendingByCallId.get(id);
+    if (p) out.push(p);
+  }
+  return out;
+}
+function resolvePendingProxyCallById(toolCallId, result) {
+  const pending = pendingByCallId.get(toolCallId);
+  if (!pending) return false;
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
+  clearTimeout(pending.timer);
+  pending.resolve(result);
+  log.info("resolved pending proxy call", {
+    sessionKey: pending.sessionKey,
+    toolCallId: pending.toolCallId,
+    toolName: pending.toolName
+  });
+  return true;
+}
+function rejectPendingProxyCallById(toolCallId, error) {
+  const pending = pendingByCallId.get(toolCallId);
+  if (!pending) return false;
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
+  clearTimeout(pending.timer);
+  pending.reject(error);
+  log.notice("rejected pending proxy call", {
+    sessionKey: pending.sessionKey,
+    toolCallId: pending.toolCallId,
+    toolName: pending.toolName,
+    error: error.message
+  });
+  return true;
+}
+function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return 0;
+  const ids = [...s];
+  let count = 0;
+  for (const id of ids) {
+    if (rejectPendingProxyCallById(id, error)) count++;
+  }
+  return count;
+}
+
+// src/compression-store.ts
+var MAX_COMPRESSION_ENTRIES = 32;
+var compressions = /* @__PURE__ */ new Map();
+function storeCompressionSummary(sessionKey2, summary) {
+  compressions.set(sessionKey2, { summary, restartPending: true });
+  while (compressions.size > MAX_COMPRESSION_ENTRIES) {
+    const oldest = compressions.keys().next();
+    if (oldest.done) break;
+    compressions.delete(oldest.value);
+    log.info("compression store evicted oldest entry", { sessionKey: oldest.value });
+  }
+}
+function getCompressionSummary(sessionKey2) {
+  return compressions.get(sessionKey2)?.summary;
+}
+function consumeCompressionRestart(sessionKey2) {
+  const state = compressions.get(sessionKey2);
+  if (!state?.restartPending) return false;
+  state.restartPending = false;
+  return true;
+}
+function clearCompression(sessionKey2) {
+  compressions.delete(sessionKey2);
+}
+
+// src/session-manager.ts
+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 takeUnattendedLines(ap) {
+  const lines = ap.unattendedLines ?? [];
+  const dropped = ap.unattendedDropped ?? 0;
+  ap.unattendedLines = [];
+  ap.unattendedDropped = 0;
+  return { lines, dropped };
+}
+var activeProcesses = /* @__PURE__ */ new Map();
+var claudeSessions = /* @__PURE__ */ new Map();
+var MAX_ACTIVE_PROCESSES = 16;
+var PROCESS_EXIT_TIMEOUT_MS = 1500;
+var PROCESS_FORCE_EXIT_TIMEOUT_MS = 500;
+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"
+  };
+  if (opts?.effort) {
+    env.CLAUDE_CODE_EFFORT_LEVEL = cliEffortLevel(opts.effort);
+  }
+  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";
+  }
+  return env;
+}
+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) {
+    const oldestKey = activeProcesses.keys().next().value;
+    if (!oldestKey) break;
+    log.info("evicting LRU claude process", { sessionKey: oldestKey });
+    deleteActiveProcess(oldestKey);
+  }
+}
+function getActiveProcess(key) {
+  const ap = activeProcesses.get(key);
+  if (ap) touch(key);
+  return ap;
+}
+function setActiveProcess(key, ap) {
+  activeProcesses.set(key, ap);
+}
+function detachActiveProcess(key) {
+  const ap = activeProcesses.get(key);
+  if (!ap) return void 0;
+  activeProcesses.delete(key);
+  void ap.proxyServer?.close();
+  return ap;
+}
+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((resolve4) => {
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve4(true);
+    };
+    const timer = setTimeout(() => {
+      proc.off("exit", onExit);
+      resolve4(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;
+}
+function getClaudeSessionId(key) {
+  return claudeSessions.get(key);
+}
+function setClaudeSessionId(key, sessionId) {
+  claudeSessions.set(key, sessionId);
+}
+function deleteClaudeSessionId(key) {
+  clearExitPlanModeQuestions(key);
+  const claudeSessionId = claudeSessions.get(key);
+  if (claudeSessionId) clearLedger(claudeSessionId);
+  claudeSessions.delete(key);
+}
+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."
+      );
     }
-  },
-  {
-    name: "webfetch",
-    description: "Fetch content from a URL. Routed through opencode's webfetch tool so permission prompts flow through opencode's UI. Returns the page content in the requested format.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        url: {
-          type: "string",
-          description: "The URL to fetch content from. Must start with http:// or https://."
-        },
-        format: {
-          type: "string",
-          enum: ["text", "markdown", "html"],
-          description: "The format to return the content in. Defaults to markdown."
-        },
-        timeout: {
-          type: "number",
-          description: "Optional timeout in seconds (max 120)."
-        }
-      },
-      required: ["url"]
+  }
+  for (const key of staleKeys) {
+    deleteActiveProcess(key);
+    deleteClaudeSessionId(key);
+    clearCompression(key);
+  }
+}
+function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort) {
+  evictIfNeeded();
+  log.info("spawning new claude process", {
+    cliPath,
+    cliArgs,
+    cwd,
+    sessionKey: sessionKey2,
+    effort
+  });
+  const proc = spawn(cliPath, cliArgs, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort }),
+    shell: process.platform === "win32"
+  });
+  const lineEmitter = new EventEmitter3();
+  const ap = {
+    proc,
+    lineEmitter,
+    proxyServer: proxyServer ?? null,
+    mcpHash,
+    systemPromptFile,
+    effort,
+    cliArgs: [...cliArgs],
+    unattendedLines: [],
+    unattendedDropped: 0
+  };
+  const rl = createInterface({ input: proc.stdout });
+  rl.on("line", (line) => {
+    if (dispatchSideQuestionResponse(ap, line)) return;
+    if (lineEmitter.listenerCount("line") === 0) {
+      bufferUnattendedLine(ap, line);
+      return;
     }
-  },
-  {
-    name: "task",
-    description: "Launch an opencode subagent to handle a complex multi-step task autonomously. Routed through opencode's task tool so subagent orchestration, permission, and lifecycle are handled by opencode. Use `subagent_type` to pick which configured subagent runs (e.g. `build`, `general`, `explore`, or any custom subagent declared in opencode.json). " + TASK_PROXY_NOTE,
-    inputSchema: {
-      type: "object",
-      properties: {
-        description: {
-          type: "string",
-          description: "A short (3-5 words) description of the task"
-        },
-        prompt: {
-          type: "string",
-          description: "The task for the agent to perform"
-        },
-        subagent_type: {
-          type: "string",
-          description: "The type of specialized agent to use for this task"
-        },
-        task_id: {
-          type: "string",
-          description: "Set this only if you mean to resume a previous task \u2014 pass the prior task_id to continue the same subagent session instead of creating a fresh one."
-        },
-        command: {
-          type: "string",
-          description: "The command that triggered this task"
-        },
-        background: {
-          type: "boolean",
-          description: "Run the task in the background when supported by opencode"
-        }
-      },
-      required: ["description", "prompt", "subagent_type"]
+    lineEmitter.emit("line", line);
+  });
+  rl.on("close", () => {
+    lineEmitter.emit("close");
+  });
+  activeProcesses.set(sessionKey2, ap);
+  proc.on("error", (err) => {
+    log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
+  });
+  proc.on("exit", (code, signal) => {
+    log.info("claude process exited", { code, signal, sessionKey: sessionKey2 });
+    void proxyServer?.close();
+    if (systemPromptFile) {
+      void unlink(systemPromptFile).catch(() => {
+      });
     }
-  },
-  {
-    name: "question",
-    description: "Ask the operator structured questions with options and receive their answers back. Routed through opencode's native `question` tool so the prompt renders as a real TUI form (with options and a custom-answer field) instead of a plain text turn. Use this when you need a decision, clarification, or preference from the operator mid-task. " + QUESTION_PROXY_NOTE,
-    inputSchema: {
-      type: "object",
-      properties: {
-        questions: {
-          type: "array",
-          description: "Questions to ask.",
-          items: {
-            type: "object",
-            properties: {
-              question: {
-                type: "string",
-                description: "Complete question."
-              },
-              header: {
-                type: "string",
-                description: "Very short label (max 30 chars)."
-              },
-              options: {
-                type: "array",
-                description: "Available choices.",
-                items: {
-                  type: "object",
-                  properties: {
-                    label: {
-                      type: "string",
-                      description: "Display text (1-5 words, concise)."
-                    },
-                    description: {
-                      type: "string",
-                      description: "Explanation of choice."
-                    }
-                  },
-                  required: ["label", "description"]
-                }
-              },
-              multiple: {
-                type: "boolean",
-                description: "Allow selecting multiple choices. Defaults to false."
-              }
-            },
-            required: ["question", "header", "options"]
-          }
-        }
-      },
-      required: ["questions"]
+    const ownsSessionKey = activeProcesses.get(sessionKey2) === ap;
+    if (ownsSessionKey) activeProcesses.delete(sessionKey2);
+    if (ownsSessionKey && code !== 0 && code !== null) {
+      log.info("process exited with error, clearing session", {
+        code,
+        sessionKey: sessionKey2
+      });
+      claudeSessions.delete(sessionKey2);
     }
-  },
-  {
-    name: "compress",
-    description: "Replace older conversation detail with a summary you write, then continue in a fresh Claude Code session. Handled inside the plugin, so it never prompts the operator. " + COMPRESS_PROXY_NOTE,
-    inputSchema: {
-      type: "object",
-      properties: {
-        summary: {
-          type: "string",
-          description: "Dense technical summary of the work being compressed: decisions made, files changed, commands run and their outcomes, and what is still open. This is the ONLY prior context that survives, so anything omitted is lost."
-        }
-      },
-      required: ["summary"]
+  });
+  proc.stderr?.on("data", (data) => {
+    const stderr = data.toString();
+    log.debug("stderr", { data: stderr.slice(0, 200) });
+    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;
+}
+function appendResumeIfNeeded(sessionKey2, cliArgs) {
+  if (cliArgs.includes("--resume") || cliArgs.includes("--session-id")) {
+    return cliArgs;
   }
-];
-async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors) {
-  const calls = new EventEmitter3();
-  const pending = /* @__PURE__ */ new Map();
-  const authToken = crypto2.randomBytes(32).toString("hex");
-  const expectedAuth = Buffer.from(`Bearer ${authToken}`);
-  let boundAuthority = "";
-  function authOk(req) {
-    const got = req.headers.authorization;
-    if (typeof got !== "string") return false;
-    const candidate = Buffer.from(got);
-    if (candidate.length !== expectedAuth.length) return false;
-    return crypto2.timingSafeEqual(candidate, expectedAuth);
+  const sid = claudeSessions.get(sessionKey2);
+  if (!sid) return cliArgs;
+  return [...cliArgs, "--resume", sid];
+}
+function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropicApiKey) {
+  const old = activeProcesses.get(sessionKey2);
+  if (!old) return void 0;
+  activeProcesses.delete(sessionKey2);
+  old.proc.removeAllListeners("exit");
+  try {
+    old.proc.kill();
+  } catch {
   }
-  function reject(req, res, statusCode, reason) {
-    log.notice("proxy-mcp rejected a request", {
-      statusCode,
-      reason,
-      method: req.method,
-      hasAuthorization: typeof req.headers.authorization === "string"
-    });
-    res.statusCode = statusCode;
-    res.setHeader("Connection", "close");
-    res.on("finish", () => {
-      req.socket?.destroy();
+  const replacement = spawnClaudeProcess(
+    cliPath,
+    appendResumeIfNeeded(sessionKey2, old.cliArgs ?? cliArgs),
+    cwd,
+    sessionKey2,
+    old.proxyServer,
+    old.mcpHash,
+    old.systemPromptFile,
+    ignoreAnthropicApiKey,
+    old.effort
+  );
+  replacement.pendingProxyCompletions = old.pendingProxyCompletions;
+  delete old.pendingProxyCompletions;
+  return replacement;
+}
+function buildCliArgs(opts) {
+  const {
+    sessionKey: sessionKey2,
+    skipPermissions,
+    includeSessionId = true,
+    model,
+    permissionMode,
+    mcpConfig,
+    strictMcpConfig,
+    disallowedTools,
+    appendSystemPromptFile,
+    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);
+  }
+  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);
+  }
+  if (fastMode && cliSupportsFastMode(cliVersion ?? null)) {
+    args.push("--settings", JSON.stringify({ fastMode: true }));
+  }
+  if (skipPermissions) {
+    args.push("--dangerously-skip-permissions");
+  }
+  return args;
+}
+function sessionKey(cwd, modelId) {
+  return `${cwd}::${modelId}`;
+}
+
+// src/claude-session-wrapper.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import { unlink as unlink2 } from "fs/promises";
+
+// src/claude-session-bun.ts
+import * as os3 from "os";
+import * as fs4 from "fs";
+import * as path5 from "path";
+import { execFileSync } from "child_process";
+import { randomUUID as randomUUID3 } from "crypto";
+function resolveClaude(cmd = "claude") {
+  if (path5.isAbsolute(cmd) && fs4.existsSync(cmd)) return cmd;
+  const viaBun = Bun.which(cmd);
+  if (viaBun) return viaBun;
+  const isWin = os3.platform() === "win32";
+  try {
+    const out = execFileSync(isWin ? "where" : "which", [cmd], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
     });
-    res.end();
+    const first = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).find((p) => fs4.existsSync(p));
+    if (first) return first;
+  } catch {
   }
-  const server2 = createServer(async (req, res) => {
-    if (req.method !== "POST" || !req.url?.startsWith("/mcp")) {
-      reject(req, res, 404, "not a POST to /mcp");
-      return;
-    }
-    if (req.headers.host !== boundAuthority) {
-      reject(req, res, 403, "host header is not the bound authority");
-      return;
-    }
-    if (req.headers.origin !== void 0) {
-      reject(req, res, 403, "origin header present");
-      return;
-    }
-    const contentType = String(req.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
-    if (contentType !== "application/json") {
-      reject(req, res, 415, "content-type is not application/json");
-      return;
-    }
-    if (!authOk(req)) {
-      reject(req, res, 401, "missing or invalid bearer token");
-      return;
+  throw new Error(`Could not resolve command on PATH: ${cmd}`);
+}
+function encodeCwd(cwd) {
+  return path5.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+}
+var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+function resolveConfigDir(configDir) {
+  const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
+  if (!value) return path5.join(os3.homedir(), ".claude");
+  if (value === "~") return os3.homedir();
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path5.join(os3.homedir(), value.slice(2));
+  }
+  return path5.resolve(value);
+}
+var ClaudeSession = class {
+  sessionId;
+  cwd;
+  configDir;
+  jsonlPath;
+  raw = "";
+  proc = null;
+  cursor = 0;
+  // index into transcript split('\n')
+  lastDataAt = 0;
+  exited = false;
+  exitCode = null;
+  aborted = false;
+  signal;
+  o;
+  constructor(opts = {}) {
+    this.cwd = path5.resolve(opts.cwd ?? process.cwd());
+    this.configDir = resolveConfigDir(opts.configDir);
+    this.signal = opts.signal;
+    this.sessionId = randomUUID3();
+    this.jsonlPath = path5.join(
+      this.configDir,
+      "projects",
+      encodeCwd(this.cwd),
+      `${this.sessionId}.jsonl`
+    );
+    this.o = {
+      cwd: this.cwd,
+      cliPath: opts.cliPath,
+      configDir: this.configDir,
+      model: opts.model,
+      settingSources: opts.settingSources,
+      extraArgs: opts.extraArgs ?? [],
+      ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
+      effort: opts.effort,
+      cols: opts.cols ?? 200,
+      rows: opts.rows ?? 50,
+      bootMinMs: opts.bootMinMs ?? 3e3,
+      bootQuietMs: opts.bootQuietMs ?? 1500,
+      bootMaxMs: opts.bootMaxMs ?? 25e3,
+      pollMs: opts.pollMs ?? 250,
+      // Agentic turns (tool loops) routinely run for many minutes; a short
+      // cap would surface as a mid-task error result. 30 min mirrors the
+      // proxy-tool ceiling rather than a chat-reply expectation.
+      turnTimeoutMs: opts.turnTimeoutMs ?? 18e5,
+      bracketedPaste: opts.bracketedPaste ?? true,
+      submitMinMs: opts.submitMinMs ?? 200,
+      submitConfirmMs: opts.submitConfirmMs ?? 1500,
+      submitMaxRetries: opts.submitMaxRetries ?? 8,
+      debug: opts.debug ?? false
+    };
+  }
+  async start() {
+    if (this.signal?.aborted) throw new Error("aborted before start");
+    this.signal?.addEventListener(
+      "abort",
+      () => {
+        this.aborted = true;
+        this.dispose();
+      },
+      { once: true }
+    );
+    const claude = resolveClaude(this.o.cliPath ?? "claude");
+    const args = ["--session-id", this.sessionId];
+    if (this.o.model) args.push("--model", this.o.model);
+    if (this.o.settingSources !== null && this.o.settingSources !== void 0) {
+      args.push("--setting-sources", this.o.settingSources);
     }
-    let requestId = null;
-    let requestMethod = null;
-    try {
-      const body = await readBody(req);
-      const request = JSON.parse(body);
-      requestId = request?.id ?? null;
-      requestMethod = typeof request?.method === "string" ? request.method : null;
-      if (request?.jsonrpc !== "2.0" || typeof request.method !== "string") {
-        writeJson(res, {
-          jsonrpc: "2.0",
-          id: requestId,
-          error: { code: -32600, message: "Invalid request" }
-        });
-        return;
-      }
-      log.debug("proxy-mcp request", {
-        method: request.method,
-        id: request.id
-      });
-      if (request.method === "initialize") {
-        writeJson(res, {
-          jsonrpc: "2.0",
-          id: requestId,
-          result: {
-            protocolVersion: PROTOCOL_VERSION,
-            capabilities: { tools: {} },
-            serverInfo: {
-              name: SERVER_NAME,
-              version: "0.1.0"
-            }
-          }
-        });
-        return;
-      }
-      if (request.method === "notifications/initialized") {
-        res.statusCode = 204;
-        res.end();
-        return;
-      }
-      if (request.method === "tools/list") {
-        writeJson(res, {
-          jsonrpc: "2.0",
-          id: requestId,
-          result: {
-            tools: tools.map((t) => ({
-              name: t.name,
-              description: t.description,
-              inputSchema: t.inputSchema
-            }))
-          }
-        });
-        return;
-      }
-      if (request.method === "tools/call") {
-        const params = request.params ?? {};
-        const toolName = String(params.name ?? "");
-        const input = params.arguments ?? {};
-        if (!tools.some((t) => t.name === toolName)) {
-          writeJson(res, {
-            jsonrpc: "2.0",
-            id: requestId,
-            result: {
-              content: [{ type: "text", text: `Unknown proxy tool: ${toolName}` }],
-              isError: true
-            }
-          });
-          return;
-        }
-        const interceptor = interceptors?.get(toolName);
-        if (interceptor) {
-          let intercepted;
-          try {
-            intercepted = await interceptor(input);
-          } catch (interceptorError) {
-            const message = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
-            log.warn("proxy-mcp interceptor failed", { toolName, error: message });
-            intercepted = { kind: "error", message };
-          }
-          writeToolCallResult(res, requestId, intercepted);
-          return;
+    if (this.o.extraArgs && this.o.extraArgs.length) args.push(...this.o.extraArgs);
+    if (this.o.debug)
+      process.stderr.write(`[session] spawn: ${claude} ${args.join(" ")}
+`);
+    this.lastDataAt = Date.now();
+    this.proc = Bun.spawn([claude, ...args], {
+      cwd: this.cwd,
+      env: {
+        ...process.env,
+        CLAUDE_CONFIG_DIR: this.o.configDir,
+        TERM: "xterm-256color",
+        ...this.o.ignoreAnthropicApiKey ? { ANTHROPIC_API_KEY: void 0, ANTHROPIC_AUTH_TOKEN: void 0 } : {},
+        ...this.o.effort ? { CLAUDE_CODE_EFFORT_LEVEL: this.o.effort } : {}
+      },
+      terminal: {
+        cols: this.o.cols,
+        rows: this.o.rows,
+        data: (_term, d) => {
+          this.lastDataAt = Date.now();
+          const chunk = Buffer.from(d).toString("utf8");
+          this.raw += chunk;
+          if (this.o.debug) process.stdout.write(chunk);
         }
-        const callId = crypto2.randomUUID();
-        log.info("proxy-mcp tool call received", {
-          callId,
-          toolName,
-          hasInput: input != null
-        });
-        let timer = null;
-        const result = await new Promise(
-          (resolve4, reject2) => {
-            const entry = {
-              id: callId,
-              toolName,
-              input,
-              resolve: resolve4,
-              reject: reject2
-            };
-            pending.set(callId, entry);
-            const deadlineMs = resolveProxyCallTimeoutMs(
-              toolName,
-              input,
-              timeoutOverrides
-            );
-            timer = setTimeout(() => {
-              if (!pending.has(callId)) return;
-              pending.delete(callId);
-              log.notice("proxy-mcp tool call timed out", {
-                callId,
-                toolName,
-                deadlineMs
-              });
-              reject2(buildProxyTimeoutError(toolName, deadlineMs));
-            }, deadlineMs);
-            calls.emit("call", entry);
-          }
-        ).finally(() => {
-          if (timer) clearTimeout(timer);
-          pending.delete(callId);
-        });
-        writeToolCallResult(res, requestId, result);
-        return;
       }
-      writeJson(res, {
-        jsonrpc: "2.0",
-        id: requestId,
-        error: { code: -32601, message: `Unknown method: ${request.method}` }
-      });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      const logFn = isExpectedCleanupError(errorMessage) ? log.notice : log.warn;
-      logFn("proxy-mcp error handling request", {
-        error: errorMessage
-      });
-      if (requestMethod === "tools/call") {
+    });
+    this.proc.exited.then((code) => {
+      this.exitCode = typeof code === "number" ? code : null;
+      this.exited = true;
+      this.proc = null;
+    }).catch(() => {
+      this.exited = true;
+      this.proc = null;
+    });
+    await this.waitForBoot();
+    this.cursor = this.lineCount();
+  }
+  /** Wait until the TUI has been quiet for bootQuietMs (Ink ready), bounded by
+   *  bootMinMs..bootMaxMs. */
+  async waitForBoot() {
+    const start = Date.now();
+    while (Date.now() - start < this.o.bootMaxMs) {
+      await delay(150);
+      if (this.aborted) throw new Error("aborted during boot");
+      if (this.exited) {
+        throw new Error(this.failureMessage("claude exited during boot", true));
+      }
+      const elapsed = Date.now() - start;
+      const sinceData = Date.now() - this.lastDataAt;
+      if (elapsed >= this.o.bootMinMs && sinceData >= this.o.bootQuietMs) return;
+    }
+  }
+  /** Submit the freshly-injected prompt and confirm the turn was actually
+   *  accepted. A large bracketed paste collapses into a "[Pasted text]"
+   *  placeholder; an Enter sent while claude is still ingesting the paste is
+   *  silently dropped, so a single fixed-delay Enter races the paste and can
+   *  leave the prompt sitting unsubmitted (→ hang until turnTimeoutMs). Send
+   *  Enter, then poll for transcript growth past the cursor (the turn's records
+   *  are written on acceptance); resend Enter until accepted or the retry
+   *  budget is spent. Polling growth (not a blind delay) also stops us from
+   *  sending a stray Enter once the turn is in flight. */
+  async submitTurn() {
+    await delay(this.o.submitMinMs);
+    for (let attempt = 0; attempt < this.o.submitMaxRetries; attempt++) {
+      if (this.aborted || this.exited || !this.proc) return;
+      this.proc.terminal.write("\r");
+      const until = Date.now() + this.o.submitConfirmMs;
+      while (Date.now() < until) {
+        await delay(80);
+        if (this.aborted || this.exited) return;
+        if (this.lineCount() > this.cursor) return;
+      }
+    }
+  }
+  readRawLines() {
+    try {
+      return fs4.readFileSync(this.jsonlPath, "utf8").split("\n");
+    } catch {
+      return [];
+    }
+  }
+  /** Count of complete lines (split('\n') minus the trailing/partial element). */
+  lineCount() {
+    const lines = this.readRawLines();
+    return lines.length > 0 ? lines.length - 1 : 0;
+  }
+  rawTail(max = 600) {
+    const clean = this.raw.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\s+/g, " ").trim();
+    return clean.length > max ? clean.slice(-max) : clean;
+  }
+  failureMessage(reason, includeRaw = false) {
+    const parts = [
+      `${reason} (sessionId=${this.sessionId}, jsonlPath=${this.jsonlPath}, exitCode=${this.exitCode ?? "unknown"})`
+    ];
+    if (includeRaw) {
+      const tail = this.rawTail();
+      if (tail) parts.push(`terminalTail=${JSON.stringify(tail)}`);
+    }
+    return parts.join("; ");
+  }
+  /**
+   * Inject a turn into the live session and return the assistant reply once a
+   * terminal stop_reason is observed in the transcript.
+   */
+  async ask(prompt, perTurnTimeoutMs) {
+    if (this.aborted) throw new Error("aborted");
+    if (!this.proc || this.exited)
+      throw new Error("session not started or already exited");
+    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
+    const t0 = Date.now();
+    if (this.o.bracketedPaste) {
+      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
+    } else {
+      this.proc.terminal.write(prompt);
+    }
+    await this.submitTurn();
+    const collected = [];
+    let lastUsage = null;
+    let stopReason = null;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      await delay(this.o.pollMs);
+      if (this.aborted) throw new Error("aborted mid-turn");
+      const lines = this.readRawLines();
+      const lastComplete = lines.length - 1;
+      if (lastComplete <= this.cursor) {
+        if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
+        continue;
+      }
+      for (let i = this.cursor; i < lastComplete; i++) {
+        const s = lines[i];
+        if (!s || !s.trim()) continue;
+        let rec;
         try {
-          writeJson(res, {
-            jsonrpc: "2.0",
-            id: requestId,
-            result: {
-              content: [{ type: "text", text: errorMessage }],
-              isError: true
-            }
-          });
+          rec = JSON.parse(s);
         } catch {
-          try {
-            res.statusCode = 500;
-            res.end();
-          } catch {
-          }
+          continue;
         }
-        return;
-      }
-      try {
-        writeJson(res, {
-          jsonrpc: "2.0",
-          id: requestId,
-          error: {
-            code: -32603,
-            message: error instanceof Error ? error.message : "Internal error"
+        if (rec.type === "assistant" && rec.message) {
+          for (const b of rec.message.content ?? []) {
+            if (b?.type === "text" && typeof b.text === "string")
+              collected.push(b.text);
+          }
+          if (rec.message.usage) lastUsage = rec.message.usage;
+          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
+            stopReason = rec.message.stop_reason;
           }
-        });
-      } catch {
-        try {
-          res.statusCode = 500;
-          res.end();
-        } catch {
         }
       }
+      this.cursor = lastComplete;
+      if (stopReason) break;
     }
-  });
-  await new Promise((resolve4, reject2) => {
-    server2.once("error", reject2);
-    server2.listen(0, "127.0.0.1", () => {
-      server2.off("error", reject2);
-      resolve4();
-    });
-  });
-  const addr = server2.address();
-  if (!addr) {
-    server2.close();
-    throw new Error("Failed to bind proxy MCP server");
-  }
-  boundAuthority = `127.0.0.1:${addr.port}`;
-  const url = `http://${boundAuthority}/mcp`;
-  log.info("proxy-mcp server started", {
-    url,
-    tools: tools.map((t) => t.name)
-  });
-  let configFilePath = null;
-  const api = {
-    url,
-    serverName: SERVER_NAME,
-    tools,
-    authToken,
-    calls,
-    configPath() {
-      if (configFilePath) return configFilePath;
-      const body = JSON.stringify(
-        {
-          mcpServers: {
-            [SERVER_NAME]: {
-              type: "http",
-              url,
-              // Claude CLI replays these headers on every request to this
-              // server, which is what lets the handler above reject anyone
-              // who did not read this 0600 file.
-              headers: { Authorization: `Bearer ${authToken}` },
-              timeout: resolveProxyClientCeilingMs(timeoutOverrides)
-            }
-          }
-        },
-        null,
-        2
-      );
-      const hash = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-      const outPath = path4.join(
-        pluginTmpDir(),
-        `proxy-${hash}.json`
+    if (!stopReason) {
+      throw new Error(
+        this.failureMessage(
+          `turn timed out after ${timeout}ms (no terminal assistant record; collected ${collected.length} text block(s))`
+        )
       );
-      fs4.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
-      configFilePath = outPath;
-      return outPath;
-    },
-    async close() {
-      for (const entry of pending.values()) {
-        entry.reject(new Error(SERVER_CLOSED_MESSAGE));
+    }
+    const u = lastUsage ?? {};
+    return {
+      text: collected.join("\n").trim(),
+      stopReason,
+      usage: lastUsage,
+      cacheReadTokens: u.cache_read_input_tokens ?? 0,
+      cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+      ephemeral1hTokens: u.cache_creation?.ephemeral_1h_input_tokens ?? 0,
+      ephemeral5mTokens: u.cache_creation?.ephemeral_5m_input_tokens ?? 0,
+      inputTokens: u.input_tokens ?? 0,
+      outputTokens: u.output_tokens ?? 0,
+      elapsedMs: Date.now() - t0
+    };
+  }
+  /**
+   * Like ask(), but instead of collecting the reply text it re-emits each NEW
+   * raw JSONL transcript line via onLine (verbatim) until a terminal
+   * stop_reason. Returns the terminal stop_reason + the last assistant usage.
+   * Used by the opencode plugin transport shim, which feeds these raw lines
+   * into the existing stream-json line handler unchanged.
+   */
+  async tailTurn(prompt, onLine, perTurnTimeoutMs) {
+    if (this.aborted) throw new Error("aborted");
+    if (!this.proc || this.exited)
+      throw new Error("session not started or already exited");
+    const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
+    if (this.o.bracketedPaste) {
+      this.proc.terminal.write("\x1B[200~" + prompt + "\x1B[201~");
+    } else {
+      this.proc.terminal.write(prompt);
+    }
+    await this.submitTurn();
+    let lastUsage = null;
+    let totalOutput = 0;
+    let stopReason = null;
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      await delay(this.o.pollMs);
+      if (this.aborted) throw new Error("aborted mid-turn");
+      const lines = this.readRawLines();
+      const lastComplete = lines.length - 1;
+      if (lastComplete <= this.cursor) {
+        if (this.exited) {
+          throw new Error(this.failureMessage("claude exited mid-turn", true));
+        }
+        continue;
       }
-      pending.clear();
-      await new Promise((resolve4) => {
-        server2.close(() => resolve4());
-      });
-      if (configFilePath) {
+      for (let i = this.cursor; i < lastComplete; i++) {
+        const s = lines[i];
+        if (!s || !s.trim()) continue;
+        onLine(s);
+        let rec;
         try {
-          fs4.unlinkSync(configFilePath);
+          rec = JSON.parse(s);
         } catch {
+          continue;
+        }
+        if (rec.type === "assistant" && rec.message) {
+          if (rec.message.usage) {
+            lastUsage = rec.message.usage;
+            totalOutput += rec.message.usage.output_tokens ?? 0;
+          }
+          if (rec.message.stop_reason && TERMINAL_STOP.has(rec.message.stop_reason)) {
+            stopReason = rec.message.stop_reason;
+          }
         }
-        configFilePath = null;
       }
+      this.cursor = lastComplete;
+      if (stopReason) break;
     }
-  };
-  return api;
-}
-function disallowedToolFlags(tools) {
-  const nameMap = {
-    bash: ["Bash"],
-    read: ["Read"],
-    write: ["Write"],
-    edit: ["Edit", "MultiEdit"],
-    glob: ["Glob"],
-    grep: ["Grep"],
-    webfetch: ["WebFetch"],
-    task: ["Agent"],
-    // `question` disables Claude Code's built-in `AskUserQuestion` so the
-    // structured-questions path flows through opencode's native `question`
-    // tool instead — same UI/permission/audit benefits as the other
-    // proxies. Without this, the model can call both and the two paths
-    // diverge (opencode's form vs the headless deny-and-render fallback).
-    question: ["AskUserQuestion"]
-  };
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const t of tools) {
-    const mapped = nameMap[t.name.toLowerCase()];
-    if (!mapped) continue;
-    for (const claudeTool of mapped) {
-      if (seen.has(claudeTool)) continue;
-      seen.add(claudeTool);
-      out.push(claudeTool);
+    let usage = lastUsage;
+    if (lastUsage) {
+      usage = { ...lastUsage, output_tokens: totalOutput };
+      if (Array.isArray(lastUsage.iterations) && lastUsage.iterations.length > 0) {
+        const iters = lastUsage.iterations.map((it) => ({ ...it }));
+        iters[iters.length - 1] = {
+          ...iters[iters.length - 1],
+          output_tokens: totalOutput
+        };
+        usage.iterations = iters;
+      }
+    }
+    if (!stopReason) {
+      throw new Error(
+        this.failureMessage(
+          `turn timed out after ${timeout}ms (no terminal assistant record)`
+        )
+      );
     }
+    return { stopReason, usage };
   }
-  return out;
-}
-function resolveDisallowedTools(options) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (name) => {
-    const trimmed = name.trim();
-    if (!trimmed || seen.has(trimmed)) return;
-    seen.add(trimmed);
-    out.push(trimmed);
-  };
-  for (const name of disallowedToolFlags(options.proxyTools ?? [])) push(name);
-  for (const name of options.extraDisallowedTools ?? []) push(String(name));
-  if (options.disableWebSearch) push("WebSearch");
-  return out;
-}
-function readBody(req) {
-  return new Promise((resolve4, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
-    req.on("error", reject);
-  });
-}
-function writeToolCallResult(res, requestId, result) {
-  const text = result.kind === "error" ? result.message : result.text;
-  const isError = result.kind === "error" || result.isError === true;
-  writeJson(res, {
-    jsonrpc: "2.0",
-    id: requestId ?? null,
-    result: {
-      content: [{ type: "text", text }],
-      isError
+  dispose() {
+    if (this.proc) {
+      try {
+        this.proc.terminal.write("");
+      } catch {
+      }
+      try {
+        this.proc.kill();
+      } catch {
+      }
+      try {
+        this.proc.terminal.close();
+      } catch {
+      }
     }
-  });
-}
-function writeJson(res, body) {
-  const payload = JSON.stringify(body);
-  res.statusCode = 200;
-  res.setHeader("Content-Type", "application/json");
-  res.setHeader("Content-Length", Buffer.byteLength(payload).toString());
-  res.end(payload);
-}
+    this.proc = null;
+  }
+};
 
-// src/proxy-broker.ts
-import { EventEmitter as EventEmitter4 } from "events";
-var pendingByCallId = /* @__PURE__ */ new Map();
-var callIdsBySession = /* @__PURE__ */ new Map();
-var emitter = new EventEmitter4();
-function eventName(sessionKey2) {
-  return `pending:${sessionKey2}`;
-}
-function indexAdd(sessionKey2, callId) {
-  let s = callIdsBySession.get(sessionKey2);
-  if (!s) {
-    s = /* @__PURE__ */ new Set();
-    callIdsBySession.set(sessionKey2, s);
+// src/claude-session-wrapper.ts
+function decodeUserEnvelope(chunk) {
+  let parsed;
+  try {
+    parsed = JSON.parse(chunk);
+  } catch {
+    return chunk;
   }
-  s.add(callId);
-}
-function indexRemove(sessionKey2, callId) {
-  const s = callIdsBySession.get(sessionKey2);
-  if (!s) return;
-  s.delete(callId);
-  if (s.size === 0) callIdsBySession.delete(sessionKey2);
-}
-function onPendingProxyCall(sessionKey2, handler) {
-  const name = eventName(sessionKey2);
-  emitter.on(name, handler);
-  return () => emitter.off(name, handler);
-}
-function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
-  const previous = pendingByCallId.get(call.id);
-  if (previous) {
-    clearTimeout(previous.timer);
-    previous.reject(
-      new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
-    );
-    pendingByCallId.delete(call.id);
-    indexRemove(previous.sessionKey, call.id);
+  if (!parsed || parsed.type !== "user" || !parsed.message) return chunk;
+  const content = parsed.message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return chunk;
+  const parts = [];
+  let dropped = 0;
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    } else if (block?.type === "tool_result") {
+      const v = block.content;
+      const text = typeof v === "string" ? v : Array.isArray(v) ? v.map((i) => i?.type === "text" ? i.text : "").filter(Boolean).join("\n") : "";
+      parts.push(
+        `[Tool result${block.tool_use_id ? ` ${block.tool_use_id}` : ""}]
+${text}`
+      );
+    } else {
+      dropped++;
+    }
   }
-  const deadlineMs = resolveProxyCallTimeoutMs(
-    call.toolName,
-    call.input,
-    timeoutOverrides
-  );
-  const timer = setTimeout(() => {
-    const current = pendingByCallId.get(call.id);
-    if (!current) return;
-    pendingByCallId.delete(call.id);
-    indexRemove(current.sessionKey, call.id);
-    current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
-    log.notice("timed out pending proxy call", {
-      sessionKey: current.sessionKey,
-      toolCallId: call.id,
-      toolName: call.toolName,
-      deadlineMs
+  if (dropped > 0) {
+    log.warn("interactive transport dropped non-text content blocks", {
+      dropped
     });
-  }, deadlineMs);
-  const pending = {
-    sessionKey: sessionKey2,
-    toolCallId: call.id,
-    toolName: call.toolName,
-    input: call.input,
-    createdAt: Date.now(),
-    timer,
-    resolve: call.resolve,
-    reject: call.reject
-  };
-  pendingByCallId.set(call.id, pending);
-  indexAdd(sessionKey2, call.id);
-  emitter.emit(eventName(sessionKey2), pending);
-  log.info("queued pending proxy call", {
-    sessionKey: sessionKey2,
-    toolCallId: call.id,
-    toolName: call.toolName
-  });
-  return pending;
+  }
+  return parts.join("\n\n");
 }
-function getPendingProxyCalls(sessionKey2) {
-  const s = callIdsBySession.get(sessionKey2);
-  if (!s || s.size === 0) return [];
-  const out = [];
-  for (const id of s) {
-    const p = pendingByCallId.get(id);
-    if (p) out.push(p);
+function spawnInteractiveProcess(opts) {
+  const extraArgs = [];
+  if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
+    extraArgs.push(
+      "--mcp-config",
+      ...opts.mcpConfigPaths,
+      "--strict-mcp-config"
+    );
+  }
+  const flagSettings = {};
+  if (opts.permissionsAllow && opts.permissionsAllow.length > 0) {
+    flagSettings.permissions = { allow: opts.permissionsAllow };
   }
-  return out;
-}
-function resolvePendingProxyCallById(toolCallId, result) {
-  const pending = pendingByCallId.get(toolCallId);
-  if (!pending) return false;
-  pendingByCallId.delete(toolCallId);
-  indexRemove(pending.sessionKey, toolCallId);
-  clearTimeout(pending.timer);
-  pending.resolve(result);
-  log.info("resolved pending proxy call", {
-    sessionKey: pending.sessionKey,
-    toolCallId: pending.toolCallId,
-    toolName: pending.toolName
+  if (opts.fastMode) {
+    flagSettings.fastMode = true;
+  }
+  if (Object.keys(flagSettings).length > 0) {
+    extraArgs.push("--settings", JSON.stringify(flagSettings));
+  }
+  if (opts.permissionMode === "bypassPermissions") {
+    log.warn(
+      "interactive permissionMode bypassPermissions ignored: Claude Code prompts for confirmation in the TUI"
+    );
+  } else if (opts.permissionMode) {
+    extraArgs.push("--permission-mode", opts.permissionMode);
+  }
+  if (opts.systemPromptFile) {
+    extraArgs.push("--append-system-prompt-file", opts.systemPromptFile);
+  }
+  const session = new ClaudeSession({
+    cwd: opts.cwd,
+    cliPath: opts.cliPath,
+    configDir: opts.configDir,
+    model: opts.model,
+    // Default null = normal CLAUDE.md + settings load, matching what the
+    // headless spawn does. "" (skip everything) is for fast e2e runs only.
+    settingSources: opts.settingSources === void 0 ? null : opts.settingSources,
+    extraArgs,
+    ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
+    effort: opts.effort ? cliEffortLevel(opts.effort) : void 0
   });
-  return true;
-}
-function rejectPendingProxyCallById(toolCallId, error) {
-  const pending = pendingByCallId.get(toolCallId);
-  if (!pending) return false;
-  pendingByCallId.delete(toolCallId);
-  indexRemove(pending.sessionKey, toolCallId);
-  clearTimeout(pending.timer);
-  pending.reject(error);
-  log.notice("rejected pending proxy call", {
-    sessionKey: pending.sessionKey,
-    toolCallId: pending.toolCallId,
-    toolName: pending.toolName,
-    error: error.message
+  log.info("prepared interactive claude session", {
+    cwd: opts.cwd,
+    cliPath: opts.cliPath ?? "claude",
+    configDir: session.configDir,
+    model: opts.model,
+    effort: opts.effort,
+    sessionId: session.sessionId,
+    jsonlPath: session.jsonlPath
   });
-  return true;
-}
-function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
-  const s = callIdsBySession.get(sessionKey2);
-  if (!s) return 0;
-  const ids = [...s];
-  let count = 0;
-  for (const id of ids) {
-    if (rejectPendingProxyCallById(id, error)) count++;
-  }
-  return count;
+  const lineEmitter = new EventEmitter4();
+  const errorHandlers = /* @__PURE__ */ new Set();
+  let startPromise = null;
+  const ensureStarted = () => {
+    if (!startPromise) startPromise = session.start();
+    return startPromise;
+  };
+  const emitResult = (subtype, isError, result, usage) => {
+    lineEmitter.emit(
+      "line",
+      JSON.stringify({
+        type: "result",
+        subtype,
+        is_error: isError,
+        result,
+        session_id: session.sessionId,
+        usage: usage ?? {},
+        total_cost_usd: null,
+        duration_ms: 0
+      })
+    );
+  };
+  const runTurn = (userMsg) => {
+    void (async () => {
+      try {
+        await ensureStarted();
+        const { stopReason, usage } = await session.tailTurn(userMsg, (raw) => {
+          lineEmitter.emit("line", raw);
+        });
+        const timedOut = !stopReason;
+        emitResult(
+          timedOut ? "error_during_execution" : stopReason,
+          timedOut,
+          timedOut ? "Interactive transport: the turn ended without a terminal stop_reason (turn timeout or claude exit). Output above may be incomplete." : void 0,
+          usage
+        );
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        log.error("interactive turn failed", { error: e.message });
+        emitResult(
+          "error_during_execution",
+          true,
+          `Interactive transport failed: ${e.message}`
+        );
+        if (errorHandlers.size > 0) {
+          for (const h of errorHandlers) h(e);
+        } else {
+          lineEmitter.emit("close");
+        }
+      }
+    })();
+  };
+  const proc = {
+    stdin: {
+      write(chunk) {
+        const raw = typeof chunk === "string" && chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk;
+        runTurn(decodeUserEnvelope(raw));
+        return true;
+      },
+      end() {
+      }
+    },
+    stdout: null,
+    stderr: null,
+    pid: -1,
+    killed: false,
+    on(event, fn) {
+      if (event === "error") errorHandlers.add(fn);
+      return proc;
+    },
+    once() {
+      return proc;
+    },
+    off(event, fn) {
+      if (event === "error") errorHandlers.delete(fn);
+      return proc;
+    },
+    kill() {
+      try {
+        session.dispose();
+      } catch {
+      }
+      if (opts.systemPromptFile) {
+        void unlink2(opts.systemPromptFile).catch(() => {
+        });
+      }
+      proc.killed = true;
+      return true;
+    }
+  };
+  return {
+    proc,
+    lineEmitter,
+    proxyServer: null,
+    mcpHash: void 0,
+    systemPromptFile: opts.systemPromptFile
+  };
 }
 
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { dirname as dirname3, join as join6 } from "path";
 var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
 function resolveCompactionModel(configured) {
@@ -3479,9 +3945,25 @@ function makeAutoContinueMessage() {
     }
   });
 }
-function readPromptFileIfPresent(path7) {
+function makeLateProxyResultMessage(entries) {
+  const sections = entries.map(({ call, result }) => {
+    const failed = result.kind === "error" || result.isError === true;
+    const body = result.kind === "error" ? result.message : result.text;
+    return `Your earlier \`${call.toolName}\` tool call (id ${call.toolCallId}) has ${failed ? "failed" : "completed"}, but delivery or continuation was interrupted. Treat the following as its ${failed ? "error" : "result"} and continue from there; do not re-run it.
+
+${body}`;
+  });
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [{ type: "text", text: sections.join("\n\n---\n\n") }]
+    }
+  });
+}
+function readPromptFileIfPresent(path8) {
   try {
-    const content = readFileSync3(path7, "utf8").trim();
+    const content = readFileSync3(path8, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -3584,10 +4066,10 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path7 = join6(tmpdir2(), `opencode-cc-sys-${randomUUID3()}.md`);
+  const path8 = join6(tmpdir2(), `opencode-cc-sys-${randomUUID4()}.md`);
   try {
-    writeFileSync3(path7, content, "utf8");
-    return path7;
+    writeFileSync3(path8, content, "utf8");
+    return path8;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -4164,11 +4646,26 @@ var ClaudeCodeLanguageModel = class {
     };
   }
   async doGenerate(options) {
+    if (!this.isCompactionCall(options) && this.requestScope(options) !== "no-tools" && parseSideQuestion(options.prompt)) {
+      return this.doGenerateViaStream(options);
+    }
     const warnings = [];
     const cwd = resolveSpawnCwd(this.config.cwd);
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
-    const sk = sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
+    const effectiveModelId = resolveAgentModel(
+      this.getOpencodeAgent(options.providerOptions),
+      this.modelId
+    );
+    const reasoningEffort = resolveAgentEffort(
+      this.getOpencodeAgent(options.providerOptions),
+      this.getReasoningEffort(options.providerOptions)
+    );
+    const baseKey = sessionKey(
+      cwd,
+      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options.providerOptions) ?? null])}`
+    );
+    const sk = effortSessionKey(baseKey, reasoningEffort);
     const compactionMode = this.isCompactionCall(options);
     if (scope === "tools" && (this.resolvedProxyTools() || this.config.proxyOpencodeMcpTools !== false && this.config.bridgeOpencodeMcp !== false)) {
       return this.doGenerateViaStream(options);
@@ -4220,6 +4717,7 @@ var ClaudeCodeLanguageModel = class {
         warnings
       };
     }
+    invalidateOtherEffortSessions(baseKey, reasoningEffort);
     const hasPriorConversation = options.prompt.filter((m) => m.role === "user" || m.role === "assistant").length > 1;
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
@@ -4228,8 +4726,7 @@ var ClaudeCodeLanguageModel = class {
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const includeHistoryContext = !hasExistingSession && hasPriorConversation;
-    const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = consumeExitPlanModeQuestionResult(sk, options.prompt) ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort);
+    const userMsg = consumeExitPlanModeQuestionResult(sk, options.prompt) ?? getClaudeUserMessage(options.prompt, includeHistoryContext);
     const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
       detectCliVersion(this.config.cliPath),
@@ -4243,7 +4740,7 @@ var ClaudeCodeLanguageModel = class {
       // An existing summary still carries: it is this key's prior context.
       { compressEnabled: false, compressionSummary: getCompressionSummary(sk) }
     );
-    const { model: spawnModelId, fast: fastMode } = parseModelId(this.modelId);
+    const { model: spawnModelId, fast: fastMode } = parseModelId(effectiveModelId);
     const cliArgs = buildCliArgs({
       sessionKey: sk,
       skipPermissions: this.config.skipPermissions !== false,
@@ -4260,7 +4757,8 @@ var ClaudeCodeLanguageModel = class {
     });
     log.info("doGenerate starting", {
       cwd,
-      model: this.modelId,
+      model: effectiveModelId,
+      requestedModel: this.modelId,
       textLength: userMsg.length,
       includeHistoryContext
     });
@@ -4270,7 +4768,8 @@ var ClaudeCodeLanguageModel = class {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env: claudeSpawnEnv({
-        ignoreAnthropicApiKey: this.config.ignoreAnthropicApiKey
+        ignoreAnthropicApiKey: this.config.ignoreAnthropicApiKey,
+        effort: reasoningEffort
       }),
       shell: process.platform === "win32"
     });
@@ -4546,9 +5045,20 @@ ${plan}
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
     const compactionMode = this.isCompactionCall(options);
-    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : this.modelId;
+    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : resolveAgentModel(
+      this.getOpencodeAgent(options.providerOptions),
+      this.modelId
+    );
     const { model: spawnModelId, fast: fastMode } = parseModelId(effectiveModelId);
-    const sk = compactionMode ? sessionKey(cwd, `${effectiveModelId}::compaction::${affinity}`) : sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
+    const reasoningEffort = compactionMode ? void 0 : resolveAgentEffort(
+      this.getOpencodeAgent(options.providerOptions),
+      this.getReasoningEffort(options.providerOptions)
+    );
+    const baseKey = sessionKey(
+      cwd,
+      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options.providerOptions) ?? null])}`
+    );
+    const sk = compactionMode ? sessionKey(cwd, `${effectiveModelId}::compaction::${affinity}`) : effortSessionKey(baseKey, reasoningEffort);
     const toUsage = this.toUsage.bind(this);
     const toFinishReason = this.toFinishReason.bind(this);
     const handleControlRequest = this.handleControlRequest.bind(this);
@@ -4556,6 +5066,45 @@ ${plan}
     const interactivePref = this.config.interactive ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT);
     const useInteractive = interactivePref && typeof globalThis.Bun?.Terminal === "function";
     const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
+    const aside = !compactionMode && scope !== "no-tools" ? parseSideQuestion(options.prompt) : null;
+    if (aside) {
+      const active = getActiveProcess(sk);
+      const stream2 = new ReadableStream({
+        async start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+          try {
+            if (aside.question && !active) {
+              throw new Error("/btw needs an existing Claude Code session. Send a normal message with this model first.");
+            }
+            const answer = aside.question && active ? await requestSideQuestion(active, aside.question, {
+              cliVersion: await detectCliVersion(cliPath),
+              interactive: useInteractive,
+              busy: getPendingProxyCalls(sk).length > 0 || !!active.pendingProxyCompletions?.size,
+              abortSignal: options.abortSignal
+            }) : { response: SIDE_QUESTION_USAGE, synthetic: true };
+            const id = generateId();
+            controller.enqueue({ type: "text-start", id });
+            controller.enqueue({ type: "text-delta", id, delta: answer.response });
+            controller.enqueue({ type: "text-end", id });
+            controller.enqueue({
+              type: "finish",
+              finishReason: toFinishReason("stop"),
+              usage: toUsage({}),
+              providerMetadata: { "claude-code": { path: "side-question", synthetic: answer.synthetic, usageUnavailable: true } }
+            });
+          } catch (error) {
+            controller.enqueue({ type: "error", error });
+          } finally {
+            controller.close();
+          }
+        }
+      });
+      return { stream: stream2, request: { body: { text: aside.question } } };
+    }
+    const existing = getActiveProcess(sk);
+    if (existing && isSideQuestionPending(existing)) {
+      throw new Error("Wait for /btw to finish before sending another message.");
+    }
     if (scope === "no-tools" && !compactionMode) {
       log.info("doStream no-tools title stub", {
         compactionMode,
@@ -4611,6 +5160,7 @@ ${plan}
       });
       return { stream: stream2, request: { body: { text: "" } } };
     }
+    if (!compactionMode) invalidateOtherEffortSessions(baseKey, reasoningEffort);
     const hasPriorConversation = options.prompt.filter((m) => m.role === "user" || m.role === "assistant").length > 1;
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
@@ -4620,12 +5170,11 @@ ${plan}
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
     const includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
-    const reasoningEffort = this.getReasoningEffort(options.providerOptions);
     const exitPlanModeQuestionResult = compactionMode ? null : consumeExitPlanModeQuestionResult(sk, options.prompt);
     if (exitPlanModeQuestionResult) {
       log.info("sending plan approval decision to claude", { sk });
     }
-    const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort, {
+    const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, {
       compactionMode
     });
     const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
@@ -4748,7 +5297,8 @@ ${plan}
                 mcpConfigPaths: mcp.paths,
                 permissionsAllow: allow,
                 systemPromptFile,
-                ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey
+                ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
+                effort: reasoningEffort
               });
               ap.mcpHash = mcp.bridgedHash;
               setActiveProcess(sk, ap);
@@ -4887,7 +5437,8 @@ ${plan}
                 spawnProxyServer,
                 spawnMcpHash,
                 spawnSystemPromptFile,
-                self.config.ignoreAnthropicApiKey
+                self.config.ignoreAnthropicApiKey,
+                reasoningEffort
               );
               proc = ap.proc;
               lineEmitter = ap.lineEmitter;
@@ -4917,10 +5468,13 @@ ${plan}
           let hadThinkingTextFromStream = false;
           let turnCompleted = false;
           let controllerClosed = false;
+          let unattendedTurnEnded = false;
+          let watchdogMessage = userMsg;
           let pendingProxyUnsubscribe = null;
           let resultFallbackTimer = null;
           let pendingResultCompletion = null;
           let hasReceivedContent = false;
+          let hasReceivedProgress = false;
           let visibleTextSinceContinue = "";
           let lastVisibleTextSinceContinue = "";
           let hadReasoningSinceContinue = false;
@@ -4941,7 +5495,7 @@ ${plan}
           };
           const startResultFallback = (delayMs = 6e4) => {
             clearFallbackTimer();
-            if (!hasReceivedContent || controllerClosed) return;
+            if (!hasReceivedContent && !hasReceivedProgress || controllerClosed) return;
             resultFallbackTimer = setTimeout(() => {
               if (controllerClosed) return;
               log.warn("result fallback timer fired \u2014 closing stream without result event", {
@@ -4965,7 +5519,7 @@ ${plan}
           };
           const onStartWatchdogFire = () => {
             startWatchdog = null;
-            if (controllerClosed || hasReceivedContent) return;
+            if (controllerClosed || hasReceivedContent || hasReceivedProgress) return;
             if (respawnAttempted) {
               log.error(
                 "claude process still silent after respawn; ending turn",
@@ -5028,25 +5582,46 @@ ${plan}
             lineEmitter.on("close", closeHandler);
             proc.on("error", procErrorHandler);
             try {
-              proc.stdin?.write(userMsg + "\n");
+              if (!deliverPendingCompletions(true)) proc.stdin?.write(watchdogMessage + "\n");
               log.debug("re-sent user message after respawn", {
-                textLength: userMsg.length
+                textLength: watchdogMessage.length
               });
             } catch (err) {
               log.error("failed to re-send envelope after respawn", {
                 error: err instanceof Error ? err.message : String(err)
               });
             }
-            startWatchdog = setTimeout(
-              onStartWatchdogFire,
-              START_WATCHDOG_MS
-            );
+            armStartWatchdog();
           };
           const armStartWatchdog = () => {
             clearStartWatchdog();
             if (controllerClosed) return;
             startWatchdog = setTimeout(onStartWatchdogFire, START_WATCHDOG_MS);
           };
+          const deliverPendingCompletions = (force = false) => {
+            const pending = activeProcess?.pendingProxyCompletions;
+            const entries = [...pending?.values() ?? []].filter(
+              (entry) => force || entry.recoveryRequired || isPendingProxyCallChannelClosed(entry.call)
+            );
+            if (entries.length === 0) return false;
+            endTextBlock();
+            watchdogMessage = makeLateProxyResultMessage(entries);
+            proc.stdin.write(watchdogMessage + "\n");
+            for (const { call } of entries) pending.delete(call.toolCallId);
+            log.warn("delivering proxy results after interrupted continuation", {
+              sessionKey: sk,
+              toolCallIds: entries.map(({ call }) => call.toolCallId),
+              respawn: force
+            });
+            gotPartialEvents = false;
+            hasReceivedContent = false;
+            hasReceivedProgress = false;
+            turnCompleted = false;
+            resetAutoContinueWindow();
+            clearFallbackTimer();
+            armStartWatchdog();
+            return true;
+          };
           const toolCallMap = /* @__PURE__ */ new Map();
           const skipResultForIds = /* @__PURE__ */ new Set();
           const toolCallsById = /* @__PURE__ */ new Map();
@@ -5071,6 +5646,7 @@ ${plan}
                 providerExecuted: false
               });
               skipResultForIds.add(call.toolCallId);
+              markPendingProxyCallEmitted(call.toolCallId);
             }
             controller.enqueue({
               type: "finish",
@@ -5181,6 +5757,10 @@ ${plan}
           };
           const completeResult = (msg) => {
             if (controllerClosed) return;
+            if (deliverPendingCompletions()) {
+              if (drainBuffer.length > 0) drainNow();
+              return;
+            }
             if (drainBuffer.length > 0) {
               drainNow();
               return;
@@ -5192,6 +5772,7 @@ ${plan}
                 count: pendingSiblings.length
               });
             }
+            activeProcess?.pendingProxyCompletions?.clear();
             const autoDecision = shouldAutoContinueIncompleteTurn(
               autoContinueState,
               {
@@ -5278,10 +5859,15 @@ ${plan}
             if (!line.trim()) return;
             if (controllerClosed) return;
             startResultFallback();
-            clearStartWatchdog();
             try {
               const outer = JSON.parse(line);
               const msg = outer.type === "stream_event" && outer.event ? { ...outer.event, session_id: outer.session_id } : outer;
+              const modelProgress = msg.type === "assistant" && !!msg.message?.content?.length || msg.type === "content_block_start" && msg.content_block?.type === "tool_use" || msg.type === "content_block_delta" && (msg.delta?.type === "text_delta" && !!msg.delta.text || msg.delta?.type === "thinking_delta" && !!msg.delta.thinking);
+              if (modelProgress) {
+                hasReceivedProgress = true;
+                clearStartWatchdog();
+                startResultFallback();
+              }
               if (outer.type === "stream_event") {
                 gotPartialEvents = true;
               }
@@ -5795,6 +6381,9 @@ ${plan}
                 if (msg.session_id) {
                   setClaudeSessionId(sk, msg.session_id);
                 }
+                if (deliverPendingCompletions()) {
+                  return;
+                }
                 if (!currentTextId && msg.is_error && typeof msg.result === "string" && msg.result.trim().length > 0) {
                   const errId = startTextBlock();
                   controller.enqueue({
@@ -5924,6 +6513,55 @@ ${plan}
             } catch {
             }
           };
+          if (activeProcess) {
+            const unattended = takeUnattendedLines(activeProcess);
+            if (unattended.lines.length > 0 || unattended.dropped > 0) {
+              log.notice("replaying stdout the child emitted between turns", {
+                sessionKey: sk,
+                lines: unattended.lines.length,
+                dropped: unattended.dropped
+              });
+              let partialText = false;
+              {
+                if (unattended.dropped > 0) {
+                  const id = startTextBlock();
+                  controller.enqueue({
+                    type: "text-delta",
+                    id,
+                    delta: `> _${unattended.dropped} lines of output emitted between turns were dropped._
+
+`
+                  });
+                }
+                for (const line of unattended.lines) {
+                  try {
+                    const outer = JSON.parse(line);
+                    const msg = outer.type === "stream_event" && outer.event ? outer.event : outer;
+                    let text = "";
+                    if (msg.type === "content_block_delta" && msg.delta?.type === "text_delta") {
+                      text = msg.delta.text ?? "";
+                      partialText = true;
+                    } else if (msg.type === "assistant") {
+                      if (!partialText) text = (msg.message?.content ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join("");
+                      partialText = false;
+                    } else if (msg.type === "result") {
+                      unattendedTurnEnded = true;
+                      for (const entry of activeProcess.pendingProxyCompletions?.values() ?? []) {
+                        if (isPendingProxyCallChannelClosed(entry.call)) entry.recoveryRequired = true;
+                      }
+                      if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
+                      if (msg.is_error && msg.result) text = msg.result;
+                    }
+                    if (text) controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: text });
+                  } catch {
+                  }
+                }
+              }
+              endTextBlock();
+              clearFallbackTimer();
+              hasReceivedContent = false;
+            }
+          }
           lineEmitter.on("line", lineHandler);
           lineEmitter.on("close", closeHandler);
           pendingProxyUnsubscribe = onPendingProxyCall(sk, (call) => {
@@ -5993,11 +6631,21 @@ ${plan}
           if (hasMatchedPendingResults) {
             for (const { call, result } of previousPendingProxyMatches) {
               if (result) {
+                const channelClosed = isPendingProxyCallChannelClosed(call);
                 log.info("resolving pending proxy call from tool result prompt", {
                   sessionKey: sk,
                   toolCallId: call.toolCallId,
-                  toolName: call.toolName
+                  toolName: call.toolName,
+                  channelClosed
                 });
+                const completions = activeProcess.pendingProxyCompletions ??= /* @__PURE__ */ new Map();
+                if (!completions.has(call.toolCallId)) {
+                  completions.set(call.toolCallId, {
+                    call,
+                    result,
+                    recoveryRequired: channelClosed || unattendedTurnEnded
+                  });
+                }
                 resolvePendingProxyCallById(call.toolCallId, result);
               } else {
                 log.info(
@@ -6010,6 +6658,22 @@ ${plan}
                 );
               }
             }
+            if (unattendedTurnEnded) deliverPendingCompletions();
+            const unemitted = getPendingProxyCalls(sk).filter(
+              (call) => !call.emitted
+            );
+            if (unemitted.length > 0) {
+              log.notice("draining proxy calls queued between turns", {
+                sessionKey: sk,
+                toolCallIds: unemitted.map((call) => call.toolCallId)
+              });
+              drainBuffer.push(...unemitted);
+              drainNow();
+              return;
+            }
+            if (getPendingProxyCalls(sk).length === 0) {
+              armStartWatchdog();
+            }
             return;
           }
           if (previousPendingProxyCalls.length > 0) {
@@ -6053,7 +6717,7 @@ ${plan}
 
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 var BASE_PROVIDER_ID = "claude-code";
 var DEFAULT_ACCOUNT = "default";
 var SHARED_CAPABILITY_ITEMS = [
@@ -6091,7 +6755,7 @@ function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path5.join(home, value.slice(2)) : value;
+    return home ? path6.join(home, value.slice(2)) : value;
   }
   return value;
 }
@@ -6123,8 +6787,8 @@ async function ensureSharedCapabilities(targetRoot) {
   }
 }
 async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path5.join(sourceRoot, item);
-  const target = path5.join(targetRoot, item);
+  const source = path6.join(sourceRoot, item);
+  const target = path6.join(targetRoot, item);
   let sourceStat;
   try {
     sourceStat = await lstat(source);
@@ -6135,8 +6799,8 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     const targetStat = await lstat(target);
     if (targetStat.isSymbolicLink()) {
       const current = await readlink(target);
-      const resolvedCurrent = path5.resolve(path5.dirname(target), current);
-      const resolvedSource = path5.resolve(source);
+      const resolvedCurrent = path6.resolve(path6.dirname(target), current);
+      const resolvedSource = path6.resolve(source);
       if (resolvedCurrent === resolvedSource) return;
     }
     log.warn("shared Claude capability already exists; leaving untouched", {
@@ -6151,11 +6815,11 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
   await symlink(source, target, type);
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path5.join(
+  const cacheRoot = path6.join(
     process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
     "opencode-claude-code-plugin"
   );
-  const wrapperPath = path5.join(cacheRoot, `claude-${account}`);
+  const wrapperPath = path6.join(cacheRoot, `claude-${account}`);
   const suffix = `@${account}`;
   await mkdir(cacheRoot, { recursive: true });
   const script = `#!/usr/bin/env bash
@@ -6307,15 +6971,15 @@ function cleanupOne(cacheRoot, ourDir) {
 // src/startup-diagnostics.ts
 import { execFile as execFile2 } from "child_process";
 import * as fs5 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 import { promisify as promisify2 } from "util";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = path6.dirname(fileURLToPath2(import.meta.url));
-    const raw = fs5.readFileSync(path6.join(here, "..", "package.json"), "utf8");
+    const here = path7.dirname(fileURLToPath2(import.meta.url));
+    const raw = fs5.readFileSync(path7.join(here, "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     cachedPluginVersion = typeof version === "string" ? version : "unknown";
   } catch {
@@ -6339,7 +7003,7 @@ var opencodeVersionProbe;
 function detectOpencodeVersion(execPath = process.execPath) {
   if (opencodeVersionProbe) return opencodeVersionProbe;
   opencodeVersionProbe = (async () => {
-    if (!path6.basename(execPath).toLowerCase().includes("opencode")) {
+    if (!path7.basename(execPath).toLowerCase().includes("opencode")) {
       log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
       return void 0;
     }
@@ -6445,6 +7109,13 @@ var DEFAULT_PROXY_TOOL_NAMES = [
   "WebFetch",
   "Task"
 ];
+function registerSideQuestionCommand(config) {
+  config.command ??= {};
+  config.command.btw ??= {
+    template: "/btw $ARGUMENTS",
+    description: "Ask a side question in the live Claude Code session without changing its context"
+  };
+}
 function warnIfAnthropicApiKey(ignore) {
   if (warnedAnthropicApiKey) return;
   if (!process.env.ANTHROPIC_API_KEY && !process.env.ANTHROPIC_AUTH_TOKEN) return;
@@ -6520,6 +7191,7 @@ function pluginEntrypoint() {
 function cleanProviderOptions(options = {}) {
   const result = { ...options };
   delete result.accounts;
+  delete result.defaultSubagentModel;
   return result;
 }
 function defaultModelsForProvider(providerModels, providerID = PROVIDER_ID2, modelSuffix) {
@@ -6656,6 +7328,37 @@ async function expandAccountProviders(config) {
   }
   return expandedCount > 0;
 }
+async function buildAgentRegistry(config) {
+  const options = config.provider?.[PROVIDER_ID2]?.options;
+  const configured = options?.defaultSubagentModel;
+  setDefaultSubagentModel(
+    typeof configured === "string" ? configured : void 0
+  );
+  const records = await readAgentMarkdownRecords(
+    agentDirectories(
+      process.env.HOME ?? process.env.USERPROFILE,
+      getOpencodeProjectDirectory()
+    )
+  );
+  for (const [name, agent] of Object.entries(config.agent ?? {})) {
+    const bag = agent.options ?? {};
+    const pick = (key) => {
+      const value = agent[key] ?? bag[key];
+      return typeof value === "string" ? value : void 0;
+    };
+    records[name] = {
+      mode: pick("mode") ?? records[name]?.mode,
+      model: pick("model") ?? records[name]?.model,
+      forceModel: pick("forceModel") ?? records[name]?.forceModel,
+      reasoningEffort: pick("reasoningEffort") ?? records[name]?.reasoningEffort
+    };
+  }
+  setAgentRegistry(records);
+  log.debug("agent registry built", {
+    agents: Object.keys(records).length,
+    defaultSubagentModel: getDefaultSubagentModel()
+  });
+}
 var server = async (input) => {
   cleanupStaleUnscopedInstall();
   const opencodeVersion = pickOpencodeVersion(input);
@@ -6665,7 +7368,9 @@ var server = async (input) => {
   setOpencodeProjectDirectory(pickOpencodeDirectory(input));
   return {
     config: async (config) => {
+      registerSideQuestionCommand(config);
       config.provider ??= {};
+      await buildAgentRegistry(config);
       const expanded = await expandAccountProviders(config);
       if (expanded) {
         logStartupDiagnostics(
@@ -6736,6 +7441,10 @@ export {
   configModelsForProvider,
   createClaudeCode,
   index_default as default,
-  defaultModels
+  defaultModels,
+  getAgentRegistry,
+  getDefaultSubagentModel,
+  registerSideQuestionCommand,
+  resolveAgentModel
 };
 //# sourceMappingURL=index.js.map