@khalilgharbaoui/opencode-claude-code-plugin 0.27.0 → 0.27.2

package/dist/index.js

@@ -647,7 +647,9 @@ while [[ $# -gt 0 ]]; do
 done
 
 export CLAUDE_CONFIG_DIR=${shellSingleQuote(configDir)}
-exec ${shellSingleQuote(baseCliPath)} "\${args[@]}"
+# \${args[@]+...} keeps an empty array legal under \`set -u\` on bash 3.2,
+# which is the bash macOS ships and \`/usr/bin/env bash\` usually finds.
+exec ${shellSingleQuote(baseCliPath)} \${args[@]+"\${args[@]}"}
 `;
   await writeFile(wrapperPath, script, "utf8");
   await chmod(wrapperPath, 493);
@@ -6526,109 +6528,142 @@ function spawnInteractiveProcess(opts) {
   };
 }
 
-// src/claude-code-language-model.ts
+// src/prompts.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { unlink as unlink3 } from "fs/promises";
 import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname5, join as join8 } from "path";
-async function isProxyCallStillServed(callId) {
-  const pending = findPendingProxyCall(callId);
-  if (!pending || pending.emitted !== true) return false;
-  const session = describeSessionKey(pending.sessionKey).session;
-  return await fetchSessionRunState(session) === "busy";
+function readPromptFileIfPresent(path10) {
+  try {
+    const content = readFileSync5(path10, "utf8").trim();
+    return content || void 0;
+  } catch {
+    return void 0;
+  }
 }
-setProxyDeadlineGuard(({ callId }) => isProxyCallStillServed(callId));
-var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
-function resolveCompactionModel(configured) {
-  const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
-  if (env) return env;
-  const trimmed = configured?.trim();
-  if (trimmed) return trimmed;
-  return DEFAULT_COMPACTION_MODEL;
+function nearestWorkspaceAgentsPrompt(cwd) {
+  let dir = cwd;
+  while (true) {
+    const content = readPromptFileIfPresent(join8(dir, "AGENTS.md"));
+    if (content) return content;
+    const parent = dirname5(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
 }
-function resolveSessionAffinity(headers, providerOptions, providerKey) {
-  if (headers) {
-    for (const key of Object.keys(headers)) {
-      if (key.toLowerCase() === "x-session-affinity") {
-        const v = headers[key];
-        if (typeof v === "string" && v.length > 0) return v;
+var AGENTS_MAINTENANCE_HINT = `## Keeping AGENTS.md up to date
+
+When you complete a task, phase, or to-do item that is listed in AGENTS.md, update the file
+immediately after the work is done \u2014 mark it \u2705, check it off, or remove it. Do this inside
+the same turn so the next session does not repeat work that is already finished.`;
+var MULTI_STEP_TASK_HINT = `## Continuing through multi-step tasks
+
+opencode requires the user to press "continue" after each turn ends. When a
+task has multiple steps, do them all in one turn \u2014 chain tool calls rather
+than pausing for user confirmation between subtasks. End the turn only
+when the task is done, you need clarification on intent, or you hit a real
+blocker. The user can interrupt or abort at any time; turn endings should
+mark meaningful checkpoints, not every completed substep.`;
+var SUBAGENT_DISPATCH_HINT = `## opencode subagents
+
+Subagent dispatch in this environment goes through exactly two tools: \`mcp__opencode_proxy__task\` for one subagent and \`mcp__opencode_proxy__task_batch\` for two or more at once.
+
+- Two or more independent subagents in one response: make ONE \`mcp__opencode_proxy__task_batch\` call with a \`tasks\` array (each item is a normal task input). Claude Code runs MCP calls one at a time, so several \`mcp__opencode_proxy__task\` calls in the same response run serially; \`task_batch\` runs them concurrently in opencode and returns every result together, labelled in order.
+- When the user mentions \`@<agent>\` or an instruction says "call the task tool with subagent: <name>", call \`mcp__opencode_proxy__task\` with \`subagent_type: "<name>"\`.
+- If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__task\`), then call it.
+- Claude Code's built-in TaskCreate/TaskUpdate/TaskList manage a local todo list. They cannot dispatch subagents; creating a task there runs nothing. Never report a subagent as dispatched unless \`mcp__opencode_proxy__task\` returned its result.
+- Do not verify a subagent's existence by searching config files \u2014 the tool's description lists the available agent types, and invalid types fail fast with a clear error.`;
+var QUESTION_PROXY_HINT = `## Asking the operator questions
+
+Structured questions in this environment go through exactly one tool: \`mcp__opencode_proxy__question\`.
+
+- When you need to ask the operator a question with options, call \`mcp__opencode_proxy__question\` with a \`questions\` array (each item has \`question\`, \`header\`, \`options\` of \`{label, description}\`, and optional \`multiple\`).
+- If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__question\`), then call it by its FULL name.
+- Do NOT call bare \`question\` \u2014 that is not a tool. Always use the full \`mcp__opencode_proxy__question\` name when invoking it.
+- Claude Code's built-in \`AskUserQuestion\` is disabled in this environment; the proxy is the only way to ask structured questions.`;
+var CLAUDE_CLI_CONTEXT_NOTE = `## Runtime environment: Claude Code CLI
+
+You are running via the Claude Code CLI (not a direct API call). This affects context management:
+
+- The \`compress\` tool is NOT available. Do not attempt to call it.
+- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
+- Context window management is handled automatically by Claude CLI's own session history.
+- Ignore any system instructions that tell you to call \`compress\` \u2014 they are intended for direct API providers, not this environment.
+- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
+var CLAUDE_CLI_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
+
+You are running via the Claude Code CLI (not a direct API call). This affects context management:
+
+- To compress context, call \`mcp__opencode_proxy__compress\` with a \`summary\` argument. Use that exact full name.
+- The reset happens at the start of your NEXT turn: this Claude Code session is discarded and a fresh one starts with your summary as its only prior context. Keep working normally after the call.
+- Everything outside the summary is gone after the reset \u2014 tool output, files you read, and the earlier conversation are not replayed. Write the summary as the authoritative record.
+- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
+- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
+var CLAUDE_CLI_OPENCODE_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
+
+You are running via the Claude Code CLI (not a direct API call). This affects context management:
+
+- To compress context, call \`mcp__opencode_proxy__compress\`. Use that exact full name. It runs opencode's own \`compress\` tool, which is what a "MAX CONTEXT LIMIT REACHED" reminder is asking you to do.
+- It compresses opencode's stored conversation, NOT this Claude Code session. Your current session keeps the context it already has, so do not assume earlier detail is gone after the call.
+- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
+- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
+function extractSystemMessages(prompt) {
+  const out = [];
+  for (const msg of prompt) {
+    if (msg.role !== "system") continue;
+    if (typeof msg.content === "string") {
+      if (msg.content.trim()) out.push(msg.content.trim());
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part?.type === "text" && typeof part.text === "string" && part.text.trim()) {
+          out.push(part.text.trim());
+        }
       }
     }
   }
-  if (providerOptions) {
-    const bag = providerOptions[providerKey] ?? providerOptions["claude-code"];
-    const sid = bag?.opencodeSessionID;
-    if (typeof sid === "string" && sid.length > 0) return sid;
-  }
-  return "default";
+  return out;
 }
-function resolveOpencodeAgent(headers, providerOptions, providerKey) {
-  if (providerOptions) {
-    const bag = providerOptions[providerKey] ?? providerOptions["claude-code"];
-    const agent = bag?.opencodeAgent;
-    if (typeof agent === "string") return agent;
+function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystemContent = [], options = {}) {
+  const parts = [];
+  if (options.compressionSummary?.trim()) {
+    parts.push(
+      `## Summary of earlier work (context was compressed)
+
+${options.compressionSummary.trim()}`
+    );
   }
-  if (headers) {
-    for (const key of Object.keys(headers)) {
-      if (key.toLowerCase() === "x-opencode-agent") {
-        const value = headers[key];
-        if (typeof value === "string" && value.length > 0) return value;
-      }
-    }
+  parts.push(
+    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : options.opencodeCompressEnabled ? CLAUDE_CLI_OPENCODE_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
+  );
+  for (const s of extraSystemContent) {
+    if (s.trim()) parts.push(s.trim());
   }
-  return void 0;
-}
-function describeAbortReason(reason) {
-  if (reason === void 0) return "undefined";
-  if (reason instanceof Error) return `${reason.name}: ${reason.message}`;
-  if (typeof reason === "string") return reason;
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir6(), ".config");
+  const globalAgents = readPromptFileIfPresent(join8(configRoot, "opencode", "AGENTS.md"));
+  const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
+  const forwarded = extraSystemContent.join("\n\n");
+  const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
+  const pushWorkspace = !!workspaceAgents && workspaceAgents !== globalAgents && !forwarded.includes(workspaceAgents);
+  if (pushGlobal) parts.push(globalAgents);
+  if (pushWorkspace) parts.push(workspaceAgents);
+  if (pushGlobal || pushWorkspace) parts.push(AGENTS_MAINTENANCE_HINT);
+  if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
+  const content = parts.join("\n\n");
+  if (!content) return void 0;
+  const path10 = join8(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
-    return JSON.stringify(reason) ?? typeof reason;
-  } catch {
-    return typeof reason;
-  }
-}
-var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
-  "thinking_delta",
-  "text_delta",
-  "input_json_delta",
-  "signature_delta"
-]);
-function hasNewUserContent(prompt) {
-  for (let i = prompt.length - 1; i >= 0; i--) {
-    const msg = prompt[i];
-    if (msg.role === "assistant") return false;
-    if (msg.role === "tool") {
-      const content2 = msg.content;
-      if (Array.isArray(content2)) {
-        for (const part of content2) {
-          if (part?.type === "tool-result") return true;
-        }
-      }
-      continue;
-    }
-    if (msg.role !== "user") continue;
-    const content = msg.content;
-    if (typeof content === "string") {
-      if (content.trim()) return true;
-      continue;
-    }
-    if (Array.isArray(content)) {
-      for (const part of content) {
-        if (part.type === "text" && part.text && part.text.trim()) return true;
-        if (part.type === "tool-result") return true;
-        if (part.type === "image" || part.type === "file") return true;
-      }
-    }
+    writeFileSync4(path10, content, "utf8");
+    return path10;
+  } catch (err) {
+    log.warn("failed to write system prompt file", { error: String(err) });
+    return void 0;
   }
-  return false;
 }
+
+// src/auto-continue.ts
 var AUTO_CONTINUE_MAX_ATTEMPTS = 8;
 var AUTO_CONTINUE_MAX_ELAPSED_MS = 10 * 60 * 1e3;
 var AUTO_CONTINUE_NO_PROGRESS_LIMIT = 2;
-var PROXY_RESULT_BOUNDARY_GRACE_MS = 250;
-var CHILD_EXIT_STATUS_GRACE_MS = 250;
 var AUTO_CONTINUE_PROMPT = "Continue the task from where you stopped. Do not summarize; keep working until the requested task is complete, you need clarification, or you hit a real blocker.";
 function autoContinueEnabledFor(compactionMode, configured) {
   return compactionMode ? false : configured;
@@ -6639,51 +6674,6 @@ function isTruncationStopReason(stopReason) {
 function normalizeVisibleText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
-function isAskUserQuestionTool(name) {
-  if (!name) return false;
-  const n = name.toLowerCase();
-  return n === "askuserquestion" || n === "ask_user_question";
-}
-var ASK_USER_QUESTION_DENY_MESSAGE = "Your question and its options have already been presented to the operator verbatim. This is NOT a cancellation or a refusal \u2014 the operator simply has not answered yet. Stop now: end your turn without calling any more tools and without answering the question yourself. Do not say the question was cancelled, skipped, or declined, and do not guess, assume, or proceed on their behalf. Wait for the operator's reply, which arrives as the next user message.";
-function denyMessageForTool(toolName, configuredDenyMessage) {
-  if (isAskUserQuestionTool(toolName)) return ASK_USER_QUESTION_DENY_MESSAGE;
-  return configuredDenyMessage ?? `Denied by opencode-claude-code policy for tool ${toolName}`;
-}
-function formatAskUserQuestion(input) {
-  const anyInput = input;
-  const questions = Array.isArray(anyInput?.questions) ? anyInput.questions : [];
-  if (questions.length === 0) {
-    const single = anyInput?.question ?? anyInput?.text;
-    const q = typeof single === "string" && single.trim() ? single.trim() : "Question?";
-    return `
-
-**${q}**
-
-_Reply with your answer to continue._
-
-`;
-  }
-  const out = ["\n\n"];
-  const multiQ = questions.length > 1;
-  questions.forEach((q, i) => {
-    const text = typeof q?.question === "string" && q.question.trim() || typeof q?.text === "string" && q.text.trim() || "Question?";
-    const header = typeof q?.header === "string" && q.header.trim() ? q.header.trim() : "";
-    out.push(`**${multiQ ? `${i + 1}. ` : ""}${text}**`);
-    if (header) out.push(` _(${header})_`);
-    out.push("\n\n");
-    const options = Array.isArray(q?.options) ? q.options : [];
-    options.forEach((opt, j) => {
-      const label = typeof opt?.label === "string" && opt.label.trim() || typeof opt === "string" && opt.trim() || `Option ${j + 1}`;
-      const desc = typeof opt?.description === "string" && opt.description.trim() ? ` \u2014 ${opt.description.trim()}` : "";
-      out.push(`${j + 1}. **${label}**${desc}
-`);
-    });
-    out.push(
-      q?.multiSelect === true ? "\n_Select one or more \u2014 reply with the numbers or labels._\n\n" : "\n_Reply with your choice (the number or label)._\n\n"
-    );
-  });
-  return out.join("");
-}
 function looksLikeQuestion(text) {
   const normalized = normalizeVisibleText(text).toLowerCase();
   if (!normalized) return false;
@@ -6772,189 +6762,622 @@ function makeAutoContinueMessage() {
     }
   });
 }
-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") }]
-    }
+// src/ask-user-question.ts
+function isAskUserQuestionTool(name) {
+  if (!name) return false;
+  const n = name.toLowerCase();
+  return n === "askuserquestion" || n === "ask_user_question";
+}
+var ASK_USER_QUESTION_DENY_MESSAGE = "Your question and its options have already been presented to the operator verbatim. This is NOT a cancellation or a refusal \u2014 the operator simply has not answered yet. Stop now: end your turn without calling any more tools and without answering the question yourself. Do not say the question was cancelled, skipped, or declined, and do not guess, assume, or proceed on their behalf. Wait for the operator's reply, which arrives as the next user message.";
+function denyMessageForTool(toolName, configuredDenyMessage) {
+  if (isAskUserQuestionTool(toolName)) return ASK_USER_QUESTION_DENY_MESSAGE;
+  return configuredDenyMessage ?? `Denied by opencode-claude-code policy for tool ${toolName}`;
+}
+function formatAskUserQuestion(input) {
+  const anyInput = input;
+  const questions = Array.isArray(anyInput?.questions) ? anyInput.questions : [];
+  if (questions.length === 0) {
+    const single = anyInput?.question ?? anyInput?.text;
+    const q = typeof single === "string" && single.trim() ? single.trim() : "Question?";
+    return `
+
+**${q}**
+
+_Reply with your answer to continue._
+
+`;
+  }
+  const out = ["\n\n"];
+  const multiQ = questions.length > 1;
+  questions.forEach((q, i) => {
+    const text = typeof q?.question === "string" && q.question.trim() || typeof q?.text === "string" && q.text.trim() || "Question?";
+    const header = typeof q?.header === "string" && q.header.trim() ? q.header.trim() : "";
+    out.push(`**${multiQ ? `${i + 1}. ` : ""}${text}**`);
+    if (header) out.push(` _(${header})_`);
+    out.push("\n\n");
+    const options = Array.isArray(q?.options) ? q.options : [];
+    options.forEach((opt, j) => {
+      const label = typeof opt?.label === "string" && opt.label.trim() || typeof opt === "string" && opt.trim() || `Option ${j + 1}`;
+      const desc = typeof opt?.description === "string" && opt.description.trim() ? ` \u2014 ${opt.description.trim()}` : "";
+      out.push(`${j + 1}. **${label}**${desc}
+`);
+    });
+    out.push(
+      q?.multiSelect === true ? "\n_Select one or more \u2014 reply with the numbers or labels._\n\n" : "\n_Reply with your choice (the number or label)._\n\n"
+    );
   });
+  return out.join("");
 }
-function readPromptFileIfPresent(path10) {
+
+// src/fast-mode.ts
+var FAST_MODE_REASONS = {
+  sdk_opt_in_required: "the CLI did not receive the headless opt-in (--settings). This is a plugin bug, please report it",
+  extra_usage_disabled: "your account has usage credits turned off. Run /usage-credits in an interactive `claude` session to enable them",
+  free: "fast mode requires a paid subscription or purchased credits",
+  preference: "fast mode is turned off for your organization",
+  model_not_allowed: "this model is not in your organization's allowed models",
+  not_first_party: "fast mode only works against the Anthropic API directly, not Bedrock / Vertex / Foundry",
+  network_error: "the CLI could not reach Anthropic to check availability",
+  disabled_by_env: "CLAUDE_CODE_DISABLE_FAST_MODE is set in the environment",
+  pending: "the CLI is still checking availability"
+};
+var warnedFastModeReasons = /* @__PURE__ */ new Set();
+function reportFastModeState(msg, requested) {
+  const state = msg.fast_mode_state;
+  if (!state) return;
+  if (!requested) {
+    log.debug("fast mode state", { state });
+    return;
+  }
+  if (state === "on") {
+    log.info("fast mode active", { state });
+    return;
+  }
+  const reason = msg.fast_mode_disabled_reason;
+  if (state === "cooldown") {
+    log.notice(
+      "fast mode is in cooldown after a rate limit; this turn runs at standard speed and is billed at standard Opus rates, not the fast price shown in the model picker.",
+      { state, reason: reason ?? null }
+    );
+    return;
+  }
+  const key = reason ?? "unknown";
+  const explanation = reason ? FAST_MODE_REASONS[reason] : void 0;
+  const message = `fast mode was requested but is off${explanation ? `: ${explanation}` : reason ? ` (${reason})` : ""}. Turns run at standard speed and are billed at standard Opus rates, not the fast price shown in the model picker. Switch to the non-fast model id to make the picker's price accurate.`;
+  if (warnedFastModeReasons.has(key)) {
+    log.debug(message, { state, reason: reason ?? null });
+    return;
+  }
+  warnedFastModeReasons.add(key);
+  log.warn(message, { state, reason: reason ?? null });
+}
+
+// src/call-options.ts
+var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
+function resolveCompactionModel(configured) {
+  const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
+  if (env) return env;
+  const trimmed = configured?.trim();
+  if (trimmed) return trimmed;
+  return DEFAULT_COMPACTION_MODEL;
+}
+function resolveSessionAffinity(headers, providerOptions, providerKey) {
+  if (headers) {
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === "x-session-affinity") {
+        const v = headers[key];
+        if (typeof v === "string" && v.length > 0) return v;
+      }
+    }
+  }
+  if (providerOptions) {
+    const bag = providerOptions[providerKey] ?? providerOptions["claude-code"];
+    const sid = bag?.opencodeSessionID;
+    if (typeof sid === "string" && sid.length > 0) return sid;
+  }
+  return "default";
+}
+function resolveOpencodeAgent(headers, providerOptions, providerKey) {
+  if (providerOptions) {
+    const bag = providerOptions[providerKey] ?? providerOptions["claude-code"];
+    const agent = bag?.opencodeAgent;
+    if (typeof agent === "string") return agent;
+  }
+  if (headers) {
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === "x-opencode-agent") {
+        const value = headers[key];
+        if (typeof value === "string" && value.length > 0) return value;
+      }
+    }
+  }
+  return void 0;
+}
+function describeAbortReason(reason) {
+  if (reason === void 0) return "undefined";
+  if (reason instanceof Error) return `${reason.name}: ${reason.message}`;
+  if (typeof reason === "string") return reason;
   try {
-    const content = readFileSync5(path10, "utf8").trim();
-    return content || void 0;
+    return JSON.stringify(reason) ?? typeof reason;
   } catch {
-    return void 0;
+    return typeof reason;
   }
 }
-function nearestWorkspaceAgentsPrompt(cwd) {
-  let dir = cwd;
-  while (true) {
-    const content = readPromptFileIfPresent(join8(dir, "AGENTS.md"));
-    if (content) return content;
-    const parent = dirname5(dir);
-    if (parent === dir) return void 0;
-    dir = parent;
+function hasNewUserContent(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (msg.role === "assistant") return false;
+    if (msg.role === "tool") {
+      const content2 = msg.content;
+      if (Array.isArray(content2)) {
+        for (const part of content2) {
+          if (part?.type === "tool-result") return true;
+        }
+      }
+      continue;
+    }
+    if (msg.role !== "user") continue;
+    const content = msg.content;
+    if (typeof content === "string") {
+      if (content.trim()) return true;
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (part.type === "text" && part.text && part.text.trim()) return true;
+        if (part.type === "tool-result") return true;
+        if (part.type === "image" || part.type === "file") return true;
+      }
+    }
   }
+  return false;
 }
-var AGENTS_MAINTENANCE_HINT = `## Keeping AGENTS.md up to date
-
-When you complete a task, phase, or to-do item that is listed in AGENTS.md, update the file
-immediately after the work is done \u2014 mark it \u2705, check it off, or remove it. Do this inside
-the same turn so the next session does not repeat work that is already finished.`;
-var MULTI_STEP_TASK_HINT = `## Continuing through multi-step tasks
-
-opencode requires the user to press "continue" after each turn ends. When a
-task has multiple steps, do them all in one turn \u2014 chain tool calls rather
-than pausing for user confirmation between subtasks. End the turn only
-when the task is done, you need clarification on intent, or you hit a real
-blocker. The user can interrupt or abort at any time; turn endings should
-mark meaningful checkpoints, not every completed substep.`;
-var SUBAGENT_DISPATCH_HINT = `## opencode subagents
-
-Subagent dispatch in this environment goes through exactly two tools: \`mcp__opencode_proxy__task\` for one subagent and \`mcp__opencode_proxy__task_batch\` for two or more at once.
 
-- Two or more independent subagents in one response: make ONE \`mcp__opencode_proxy__task_batch\` call with a \`tasks\` array (each item is a normal task input). Claude Code runs MCP calls one at a time, so several \`mcp__opencode_proxy__task\` calls in the same response run serially; \`task_batch\` runs them concurrently in opencode and returns every result together, labelled in order.
-- When the user mentions \`@<agent>\` or an instruction says "call the task tool with subagent: <name>", call \`mcp__opencode_proxy__task\` with \`subagent_type: "<name>"\`.
-- If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__task\`), then call it.
-- Claude Code's built-in TaskCreate/TaskUpdate/TaskList manage a local todo list. They cannot dispatch subagents; creating a task there runs nothing. Never report a subagent as dispatched unless \`mcp__opencode_proxy__task\` returned its result.
-- Do not verify a subagent's existence by searching config files \u2014 the tool's description lists the available agent types, and invalid types fail fast with a clear error.`;
-var QUESTION_PROXY_HINT = `## Asking the operator questions
-
-Structured questions in this environment go through exactly one tool: \`mcp__opencode_proxy__question\`.
-
-- When you need to ask the operator a question with options, call \`mcp__opencode_proxy__question\` with a \`questions\` array (each item has \`question\`, \`header\`, \`options\` of \`{label, description}\`, and optional \`multiple\`).
-- If that tool is not in your visible tool list it is deferred \u2014 load it with ToolSearch (\`select:mcp__opencode_proxy__question\`), then call it by its FULL name.
-- Do NOT call bare \`question\` \u2014 that is not a tool. Always use the full \`mcp__opencode_proxy__question\` name when invoking it.
-- Claude Code's built-in \`AskUserQuestion\` is disabled in this environment; the proxy is the only way to ask structured questions.`;
-var CLAUDE_CLI_CONTEXT_NOTE = `## Runtime environment: Claude Code CLI
-
-You are running via the Claude Code CLI (not a direct API call). This affects context management:
-
-- The \`compress\` tool is NOT available. Do not attempt to call it.
-- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
-- Context window management is handled automatically by Claude CLI's own session history.
-- Ignore any system instructions that tell you to call \`compress\` \u2014 they are intended for direct API providers, not this environment.
-- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
-var CLAUDE_CLI_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
-
-You are running via the Claude Code CLI (not a direct API call). This affects context management:
-
-- To compress context, call \`mcp__opencode_proxy__compress\` with a \`summary\` argument. Use that exact full name.
-- The reset happens at the start of your NEXT turn: this Claude Code session is discarded and a fresh one starts with your summary as its only prior context. Keep working normally after the call.
-- Everything outside the summary is gone after the reset \u2014 tool output, files you read, and the earlier conversation are not replayed. Write the summary as the authoritative record.
-- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
-- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
-var CLAUDE_CLI_OPENCODE_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
+// src/proxy-results.ts
+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.
 
-You are running via the Claude Code CLI (not a direct API call). This affects context management:
+${body}`;
+  });
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [{ type: "text", text: sections.join("\n\n---\n\n") }]
+    }
+  });
+}
+function extractPendingProxyResult(prompt, toolCallId) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (msg.role !== "tool" || !Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part.type !== "tool-result" || part.toolCallId !== toolCallId) continue;
+      const output = part.output;
+      if (!output || typeof output !== "object") {
+        return {
+          kind: "text",
+          text: String(output ?? "")
+        };
+      }
+      if (output.type === "text") {
+        return {
+          kind: "text",
+          text: String(output.value ?? "")
+        };
+      }
+      if (output.type === "json") {
+        return {
+          kind: "text",
+          text: JSON.stringify(output.value)
+        };
+      }
+      if (output.type === "content" && Array.isArray(output.value)) {
+        const text = output.value.filter((v) => v?.type === "text" && typeof v.text === "string").map((v) => v.text).join("\n");
+        return {
+          kind: "text",
+          text
+        };
+      }
+      return {
+        kind: "text",
+        text: JSON.stringify(output)
+      };
+    }
+  }
+  return null;
+}
+function extractPendingProxyResultForCall(prompt, call) {
+  if (call.toolName !== TASK_BATCH_TOOL_NAME) {
+    return extractPendingProxyResult(prompt, call.toolCallId);
+  }
+  const tasks = taskBatchTasks(call.input);
+  if (tasks.length === 0) {
+    return { kind: "error", message: "task_batch input is not a list of task objects" };
+  }
+  const children = tasks.map((task, index) => ({
+    task,
+    result: extractPendingProxyResult(
+      prompt,
+      taskBatchChildToolCallId(call.toolCallId, index)
+    )
+  }));
+  const answered = children.filter((child) => child.result !== null).length;
+  if (answered === 0) return null;
+  if (answered < children.length) {
+    log.warn("task_batch resolving with child results missing", {
+      toolCallId: call.toolCallId,
+      answered,
+      total: children.length
+    });
+  }
+  return formatTaskBatchResults(children);
+}
 
-- To compress context, call \`mcp__opencode_proxy__compress\`. Use that exact full name. It runs opencode's own \`compress\` tool, which is what a "MAX CONTEXT LIMIT REACHED" reminder is asking you to do.
-- It compresses opencode's stored conversation, NOT this Claude Code session. Your current session keeps the context it already has, so do not assume earlier detail is gone after the call.
-- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
-- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
-function extractSystemMessages(prompt) {
-  const out = [];
-  for (const msg of prompt) {
-    if (msg.role !== "system") continue;
-    if (typeof msg.content === "string") {
-      if (msg.content.trim()) out.push(msg.content.trim());
-    } else if (Array.isArray(msg.content)) {
-      for (const part of msg.content) {
-        if (part?.type === "text" && typeof part.text === "string" && part.text.trim()) {
-          out.push(part.text.trim());
-        }
+// src/control-request.ts
+function controlRequestBehaviorForTool(config, toolName) {
+  const configured = config.controlRequestToolBehaviors;
+  if (configured && toolName) {
+    const direct = configured[toolName] ?? configured[toolName.toLowerCase()];
+    if (direct === "allow" || direct === "deny") return direct;
+    const lower = toolName.toLowerCase();
+    for (const [key, behavior] of Object.entries(configured)) {
+      if (key.toLowerCase() === lower && (behavior === "allow" || behavior === "deny")) {
+        return behavior;
       }
     }
   }
-  return out;
+  if (isAskUserQuestionTool(toolName)) return "deny";
+  return config.controlRequestBehavior ?? "allow";
+}
+function writeControlResponse(proc, requestId, response) {
+  const payload = {
+    type: "control_response",
+    response: {
+      subtype: "success",
+      request_id: requestId,
+      response
+    }
+  };
+  try {
+    proc.stdin?.write(JSON.stringify(payload) + "\n");
+  } catch (error) {
+    log.warn("failed to write control response", {
+      requestId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function handleControlRequest(config, msg, proc) {
+  if (msg.type !== "control_request") return false;
+  const requestId = msg.request_id;
+  const request = msg.request;
+  if (!requestId || !request?.subtype) return false;
+  if (request.subtype === "can_use_tool") {
+    const toolName = request.tool_name ?? "unknown";
+    const behavior = controlRequestBehaviorForTool(config, toolName);
+    if (behavior === "allow") {
+      writeControlResponse(proc, requestId, {
+        behavior: "allow",
+        updatedInput: request.input ?? {},
+        toolUseID: request.tool_use_id
+      });
+      log.info("control request auto-allowed", {
+        requestId,
+        toolName
+      });
+    } else {
+      const denyMessage = denyMessageForTool(
+        toolName,
+        config.controlRequestDenyMessage
+      );
+      writeControlResponse(proc, requestId, {
+        behavior: "deny",
+        message: denyMessage,
+        toolUseID: request.tool_use_id
+      });
+      log.info("control request auto-denied", {
+        requestId,
+        toolName
+      });
+    }
+    return true;
+  }
+  writeControlResponse(proc, requestId, {});
+  log.debug("control request acknowledged", {
+    requestId,
+    subtype: request.subtype
+  });
+  return true;
 }
-function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystemContent = [], options = {}) {
-  const parts = [];
-  if (options.compressionSummary?.trim()) {
-    parts.push(
-      `## Summary of earlier work (context was compressed)
 
-${options.compressionSummary.trim()}`
-    );
-  }
-  parts.push(
-    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : options.opencodeCompressEnabled ? CLAUDE_CLI_OPENCODE_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
+// src/spawn-planning.ts
+function effectiveMcpConfig(config, cwd, proxyConfigPath, runtimeStatus, excludeServers) {
+  const paths = Array.isArray(config.mcpConfig) ? config.mcpConfig.slice() : config.mcpConfig ? [config.mcpConfig] : [];
+  let bridgedHash = null;
+  let allEnabledServerNames = [];
+  if (config.bridgeOpencodeMcp !== false) {
+    const bridged = bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers);
+    if (bridged) {
+      if (bridged.path) paths.push(bridged.path);
+      bridgedHash = bridged.hash;
+      allEnabledServerNames = bridged.allEnabledServerNames;
+    }
+  }
+  if (proxyConfigPath) paths.push(proxyConfigPath);
+  return { paths, bridgedHash, allEnabledServerNames };
+}
+function resolvedProxyTools(config) {
+  const names = config.proxyTools;
+  if (!names || names.length === 0) return null;
+  const defsByName = new Map(
+    DEFAULT_PROXY_TOOLS.map((t) => [t.name.toLowerCase(), t])
   );
-  for (const s of extraSystemContent) {
-    if (s.trim()) parts.push(s.trim());
+  const picked = [];
+  const seen = /* @__PURE__ */ new Set();
+  const unknown = [];
+  const pick = (def) => {
+    if (seen.has(def.name)) return;
+    seen.add(def.name);
+    picked.push(def);
+  };
+  for (const n of names) {
+    const def = defsByName.get(String(n).toLowerCase());
+    if (!def) {
+      unknown.push(String(n));
+      continue;
+    }
+    pick(def);
+    if (def.name === "task") {
+      const batch = defsByName.get(TASK_BATCH_TOOL_NAME);
+      if (batch) pick(batch);
+    }
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir6(), ".config");
-  const globalAgents = readPromptFileIfPresent(join8(configRoot, "opencode", "AGENTS.md"));
-  const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
-  const forwarded = extraSystemContent.join("\n\n");
-  const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
-  const pushWorkspace = !!workspaceAgents && workspaceAgents !== globalAgents && !forwarded.includes(workspaceAgents);
-  if (pushGlobal) parts.push(globalAgents);
-  if (pushWorkspace) parts.push(workspaceAgents);
-  if (pushGlobal || pushWorkspace) parts.push(AGENTS_MAINTENANCE_HINT);
-  if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
-  const content = parts.join("\n\n");
-  if (!content) return void 0;
-  const path10 = join8(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
-  try {
-    writeFileSync4(path10, content, "utf8");
-    return path10;
-  } catch (err) {
-    log.warn("failed to write system prompt file", { error: String(err) });
-    return void 0;
+  if (unknown.length > 0) {
+    const known = [...defsByName.keys()].join(", ");
+    if (picked.length === 0) {
+      log.warn(
+        "no proxyTools entry was recognised; nothing will be proxied this turn",
+        { unknown, known }
+      );
+    } else {
+      log.warn("ignoring unknown proxyTools entries", { unknown, known });
+    }
   }
+  return picked.length > 0 ? picked : null;
 }
-var FAST_MODE_REASONS = {
-  sdk_opt_in_required: "the CLI did not receive the headless opt-in (--settings). This is a plugin bug, please report it",
-  extra_usage_disabled: "your account has usage credits turned off. Run /usage-credits in an interactive `claude` session to enable them",
-  free: "fast mode requires a paid subscription or purchased credits",
-  preference: "fast mode is turned off for your organization",
-  model_not_allowed: "this model is not in your organization's allowed models",
-  not_first_party: "fast mode only works against the Anthropic API directly, not Bedrock / Vertex / Foundry",
-  network_error: "the CLI could not reach Anthropic to check availability",
-  disabled_by_env: "CLAUDE_CODE_DISABLE_FAST_MODE is set in the environment",
-  pending: "the CLI is still checking availability"
-};
-var warnedFastModeReasons = /* @__PURE__ */ new Set();
-function reportFastModeState(msg, requested) {
-  const state = msg.fast_mode_state;
-  if (!state) return;
-  if (!requested) {
-    log.debug("fast mode state", { state });
-    return;
+function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken) {
+  if (config.proxyOpencodeMcpTools !== true) return null;
+  if (config.bridgeOpencodeMcp === false) return null;
+  if (allEnabledServerNames.length === 0) return null;
+  const resolution = resolveMcpProxyToolDefs({
+    serverNames: allEnabledServerNames,
+    tools: modelTools,
+    taken
+  });
+  if (resolution.defs.length === 0) {
+    log.warn(
+      "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn",
+      { servers: allEnabledServerNames, modelTools: modelTools?.length ?? 0 }
+    );
+    return null;
   }
-  if (state === "on") {
-    log.info("fast mode active", { state });
-    return;
+  log.debug("routing opencode MCP tools through the proxy", {
+    servers: [...resolution.coveredServers],
+    tools: resolution.defs.map((def) => def.name)
+  });
+  return resolution;
+}
+async function fetchLiveToolInfo(config, modelId) {
+  const items = await fetchOpencodeToolList(
+    config.provider,
+    modelId,
+    config.cwd
+  );
+  const question = items?.find((item) => item.id === "question");
+  return {
+    resolved: items !== void 0,
+    taskDescription: items?.find((item) => item.id === "task")?.description,
+    questionDescription: question?.description,
+    hasQuestion: !!question,
+    items
+  };
+}
+function stripContextRemindersEnabled(config) {
+  return shouldStripContextReminders({
+    enabled: config.stripContextReminders,
+    proxyTools: config.proxyTools,
+    proxyOpencodeTools: config.proxyOpencodeTools
+  });
+}
+function skillBridgeSpawn(config, failover) {
+  return {
+    configDir: failover.failedOver && failover.target ? accountConfigDirPath(failover.target) : config.configDir,
+    skipNative: config.bridgeSkipNativeSkills !== false
+  };
+}
+function createLiveToolInfoLoader(config, modelId) {
+  let pending;
+  return () => {
+    pending ??= fetchLiveToolInfo(config, modelId);
+    return pending;
+  };
+}
+async function resolvePlanModeQuestion(config, compactionMode, loadLiveToolInfo) {
+  if (compactionMode || config.planModeQuestion !== true) return false;
+  const info = await loadLiveToolInfo();
+  const active = isPlanModeQuestionActive({
+    configured: config.planModeQuestion,
+    opencodeHasQuestion: info.hasQuestion,
+    compactionMode
+  });
+  if (!active) {
+    log.info("plan-mode question gate", {
+      opencodeHasQuestion: info.hasQuestion,
+      registryResolved: info.resolved,
+      active
+    });
   }
-  const reason = msg.fast_mode_disabled_reason;
-  if (state === "cooldown") {
-    log.notice(
-      "fast mode is in cooldown after a rate limit; this turn runs at standard speed and is billed at standard Opus rates, not the fast price shown in the model picker.",
-      { state, reason: reason ?? null }
-    );
-    return;
+  return active;
+}
+async function ensureProxyServer(config, tools, sessionKeyForCalls, interceptCompress) {
+  const timeoutOverrides = config.proxyToolTimeoutMs;
+  const interceptors = /* @__PURE__ */ new Map();
+  if (interceptCompress && tools.some((t) => t.name === "compress")) {
+    interceptors.set("compress", (input) => {
+      const summary = typeof input.summary === "string" ? input.summary.trim() : "";
+      if (!summary) {
+        return {
+          kind: "error",
+          message: "compress needs a non-empty `summary`: it becomes the only prior context after the reset. Nothing was compressed."
+        };
+      }
+      storeCompressionSummary(sessionKeyForCalls, summary);
+      log.info("compress stored summary; session resets next turn", {
+        sessionKey: sessionKeyForCalls,
+        summaryLength: summary.length
+      });
+      return {
+        kind: "text",
+        text: "Summary stored. Finish this turn as normal; the next turn starts a fresh Claude Code session with this summary as its only prior context."
+      };
+    });
   }
-  const key = reason ?? "unknown";
-  const explanation = reason ? FAST_MODE_REASONS[reason] : void 0;
-  const message = `fast mode was requested but is off${explanation ? `: ${explanation}` : reason ? ` (${reason})` : ""}. Turns run at standard speed and are billed at standard Opus rates, not the fast price shown in the model picker. Switch to the non-fast model id to make the picker's price accurate.`;
-  if (warnedFastModeReasons.has(key)) {
-    log.debug(message, { state, reason: reason ?? null });
-    return;
+  const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors);
+  srv.calls.on("call", (call) => {
+    queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
+  });
+  return srv;
+}
+
+// src/title.ts
+function isTitleRequest(config, scope, options) {
+  if (scope === "no-tools") return true;
+  return config.hostApi === "v2" && resolveOpencodeAgent(
+    options?.headers,
+    options.providerOptions,
+    config.provider
+  ) === "title";
+}
+function requestScope(options) {
+  const tools = options?.tools;
+  if (Array.isArray(tools)) return "tools";
+  if (tools && typeof tools === "object") {
+    return Object.keys(tools).length > 0 ? "tools" : "no-tools";
+  }
+  return "no-tools";
+}
+function latestUserText(prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (msg.role !== "user") continue;
+    if (typeof msg.content === "string") {
+      return String(msg.content).trim();
+    }
+    if (Array.isArray(msg.content)) {
+      const text = msg.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => String(part.text).trim()).filter(Boolean).join(" ");
+      if (text) return text;
+    }
   }
-  warnedFastModeReasons.add(key);
-  log.warn(message, { state, reason: reason ?? null });
+  return "";
+}
+function synthesizeTitle(prompt) {
+  const source = latestUserText(prompt).replace(/\s+/g, " ").replace(/[^\p{L}\p{N}\s-]/gu, " ").trim();
+  if (!source) return "New Session";
+  const stop = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "the",
+    "and",
+    "or",
+    "but",
+    "to",
+    "for",
+    "of",
+    "in",
+    "on",
+    "at",
+    "with",
+    "can",
+    "could",
+    "would",
+    "should",
+    "please",
+    "hi",
+    "hello",
+    "hey",
+    "there",
+    "you",
+    "your",
+    "this",
+    "that",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "do",
+    "does",
+    "did",
+    "summarize",
+    "summary",
+    "project"
+  ]);
+  const words = source.split(" ").map((word) => word.trim()).filter(Boolean).filter((word) => !stop.has(word.toLowerCase()));
+  const picked = (words.length > 0 ? words : source.split(" ").filter(Boolean)).slice(0, 6).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return picked || "New Session";
+}
+
+// src/usage.ts
+function toUsage(rawUsage) {
+  const iter = rawUsage?.iterations;
+  const effective = iter?.length ? iter[iter.length - 1] : rawUsage;
+  const noCache = effective?.input_tokens ?? 0;
+  const cacheRead = effective?.cache_read_input_tokens ?? 0;
+  const cacheWrite = effective?.cache_creation_input_tokens ?? 0;
+  return {
+    inputTokens: {
+      total: noCache + cacheRead + cacheWrite,
+      noCache,
+      cacheRead: cacheRead || void 0,
+      cacheWrite: cacheWrite || void 0
+    },
+    outputTokens: {
+      total: effective?.output_tokens,
+      text: effective?.output_tokens,
+      reasoning: void 0
+    },
+    raw: rawUsage
+  };
+}
+function toFinishReason(reason = "stop") {
+  return {
+    unified: reason,
+    raw: reason
+  };
+}
+
+// src/claude-code-language-model.ts
+import { unlink as unlink3 } from "fs/promises";
+async function isProxyCallStillServed(callId) {
+  const pending = findPendingProxyCall(callId);
+  if (!pending || pending.emitted !== true) return false;
+  const session = describeSessionKey(pending.sessionKey).session;
+  return await fetchSessionRunState(session) === "busy";
 }
+setProxyDeadlineGuard(({ callId }) => isProxyCallStillServed(callId));
+var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
+  "thinking_delta",
+  "text_delta",
+  "input_json_delta",
+  "signature_delta"
+]);
+var PROXY_RESULT_BOUNDARY_GRACE_MS = 250;
+var CHILD_EXIT_STATUS_GRACE_MS = 250;
 var ClaudeCodeLanguageModel = class {
   specificationVersion = "v3";
   modelId;
@@ -6968,192 +7391,51 @@ var ClaudeCodeLanguageModel = class {
     return this.config.provider;
   }
   toUsage(rawUsage) {
-    const iter = rawUsage?.iterations;
-    const effective = iter?.length ? iter[iter.length - 1] : rawUsage;
-    const noCache = effective?.input_tokens ?? 0;
-    const cacheRead = effective?.cache_read_input_tokens ?? 0;
-    const cacheWrite = effective?.cache_creation_input_tokens ?? 0;
-    return {
-      inputTokens: {
-        total: noCache + cacheRead + cacheWrite,
-        noCache,
-        cacheRead: cacheRead || void 0,
-        cacheWrite: cacheWrite || void 0
-      },
-      outputTokens: {
-        total: effective?.output_tokens,
-        text: effective?.output_tokens,
-        reasoning: void 0
-      },
-      raw: rawUsage
-    };
+    return toUsage(rawUsage);
   }
   toFinishReason(reason = "stop") {
-    return {
-      unified: reason,
-      raw: reason
-    };
+    return toFinishReason(reason);
   }
   /**
    * Whether this call only names the session, which gets the synthetic stub
-   * rather than a `claude` spawn. opencode 1.x sends a title request with no
-   * tools, and that is the whole test there. opencode 2 sends its tool set
-   * along with it (measured on 2.0.11: `scope: "tools"`, agent `title`), so
-   * every new V2 session paid for a second `claude` process just to title
-   * itself; for a V2 model the request kind, carried as the `title` agent,
-   * decides instead.
+   * rather than a `claude` spawn. See `isTitleRequest` in title.ts.
    */
   isTitleRequest(scope, options) {
-    if (scope === "no-tools") return true;
-    return this.config.hostApi === "v2" && this.getOpencodeAgent(options) === "title";
+    return isTitleRequest(this.config, scope, options);
   }
   requestScope(options) {
-    const tools = options?.tools;
-    if (Array.isArray(tools)) return "tools";
-    if (tools && typeof tools === "object") {
-      return Object.keys(tools).length > 0 ? "tools" : "no-tools";
-    }
-    return "no-tools";
+    return requestScope(options);
   }
   /**
    * Build the combined `--mcp-config` list and return both the list and the
-   * hash of the bridged opencode MCP block (or null when bridging is off /
-   * yields nothing). The hash is used to detect mid-session config changes
-   * and respawn the underlying claude process.
-   *
-   * `runtimeStatus` is a snapshot of opencode's `client.mcp.status()`. When
-   * provided it overlays opencode's UI-toggled state on top of disk config
-   * so `/mcps` toggles propagate without a config file write.
+   * hash of the bridged opencode MCP block. See `effectiveMcpConfig` in
+   * spawn-planning.ts.
    */
   effectiveMcpConfig(cwd, proxyConfigPath, runtimeStatus, excludeServers) {
-    const paths = Array.isArray(this.config.mcpConfig) ? this.config.mcpConfig.slice() : this.config.mcpConfig ? [this.config.mcpConfig] : [];
-    let bridgedHash = null;
-    let allEnabledServerNames = [];
-    if (this.config.bridgeOpencodeMcp !== false) {
-      const bridged = bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers);
-      if (bridged) {
-        if (bridged.path) paths.push(bridged.path);
-        bridgedHash = bridged.hash;
-        allEnabledServerNames = bridged.allEnabledServerNames;
-      }
-    }
-    if (proxyConfigPath) paths.push(proxyConfigPath);
-    return { paths, bridgedHash, allEnabledServerNames };
+    return effectiveMcpConfig(
+      this.config,
+      cwd,
+      proxyConfigPath,
+      runtimeStatus,
+      excludeServers
+    );
   }
   /** Resolve ProxyToolDef[] for the configured proxyTools names. */
   resolvedProxyTools() {
-    const names = this.config.proxyTools;
-    if (!names || names.length === 0) return null;
-    const defsByName = new Map(
-      DEFAULT_PROXY_TOOLS.map((t) => [t.name.toLowerCase(), t])
-    );
-    const picked = [];
-    const seen = /* @__PURE__ */ new Set();
-    const unknown = [];
-    const pick = (def) => {
-      if (seen.has(def.name)) return;
-      seen.add(def.name);
-      picked.push(def);
-    };
-    for (const n of names) {
-      const def = defsByName.get(String(n).toLowerCase());
-      if (!def) {
-        unknown.push(String(n));
-        continue;
-      }
-      pick(def);
-      if (def.name === "task") {
-        const batch = defsByName.get(TASK_BATCH_TOOL_NAME);
-        if (batch) pick(batch);
-      }
-    }
-    if (unknown.length > 0) {
-      const known = [...defsByName.keys()].join(", ");
-      if (picked.length === 0) {
-        log.warn(
-          "no proxyTools entry was recognised; nothing will be proxied this turn",
-          { unknown, known }
-        );
-      } else {
-        log.warn("ignoring unknown proxyTools entries", { unknown, known });
-      }
-    }
-    return picked.length > 0 ? picked : null;
+    return resolvedProxyTools(this.config);
   }
-  /**
-   * Resolve ProxyToolDef[] for opencode's MCP-backed tools so they go
-   * through the in-process proxy instead of being bridged into Claude CLI's
-   * `--mcp-config`. Routing through the proxy keeps a single execution site
-   * (opencode), so the call is permission-prompted and rendered as an
-   * opencode tool call.
-   *
-   * Opt-in (`proxyOpencodeMcpTools: true`) and off by default. It used to
-   * default to true while finding nothing, because it discovered tools via
-   * `client.tool.list()`, which enumerates opencode's `ToolRegistry` and not
-   * the MCP tools merged into the model's tool set afterwards. Discovery now
-   * reads that merged set, the `tools` array opencode passes `doStream`, so
-   * the option does what it says. Turning it on by default at the same time
-   * would have silently moved every existing user's MCP traffic off the
-   * working direct bridge, so the default went to false instead: today's
-   * behaviour is preserved exactly and crossing over is the operator's call.
-   *
-   * Returns null when the feature is off or nothing matched, which leaves
-   * every server on the direct bridge.
-   */
+  /** Resolve ProxyToolDef[] for opencode's MCP-backed tools. */
   resolvedProxyMcpTools(allEnabledServerNames, modelTools, taken) {
-    if (this.config.proxyOpencodeMcpTools !== true) return null;
-    if (this.config.bridgeOpencodeMcp === false) return null;
-    if (allEnabledServerNames.length === 0) return null;
-    const resolution = resolveMcpProxyToolDefs({
-      serverNames: allEnabledServerNames,
-      tools: modelTools,
+    return resolvedProxyMcpTools(
+      this.config,
+      allEnabledServerNames,
+      modelTools,
       taken
-    });
-    if (resolution.defs.length === 0) {
-      log.warn(
-        "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn",
-        { servers: allEnabledServerNames, modelTools: modelTools?.length ?? 0 }
-      );
-      return null;
-    }
-    log.debug("routing opencode MCP tools through the proxy", {
-      servers: [...resolution.coveredServers],
-      tools: resolution.defs.map((def) => def.name)
-    });
-    return resolution;
+    );
   }
-  /**
-   * Live tool info derived from a single `client.tool.list()` fetch:
-   *
-   * - `taskDescription`: opencode's `task` tool description exactly as the
-   *   registry renders it for native models, including the "Available
-   *   agent types" list. Overlaid onto the static `task` proxy def so
-   *   Claude sees the same subagent catalog native models see, instead
-   *   of hunting through config files.
-   * - `questionDescription` / `hasQuestion`: opencode's `question` tool
-   *   description and whether the registry has the entry at all. Older
-   *   builds lack it, in which case a `mcp__opencode_proxy__question`
-   *   call resolves to `⚙ invalid`; the version gate drops the def.
-   *
-   * Returns undefined/false when the SDK client is unavailable (direct
-   * AI-SDK use, tests) so the static defs stand. `resolved` distinguishes
-   * "the registry answered and has no `question` entry" from "nobody
-   * answered": only the former is a real version-gate signal.
-   */
+  /** One `client.tool.list()` fetch, shaped for this turn's gates. */
   async fetchLiveToolInfo() {
-    const items = await fetchOpencodeToolList(
-      this.config.provider,
-      this.modelId,
-      this.config.cwd
-    );
-    const question = items?.find((item) => item.id === "question");
-    return {
-      resolved: items !== void 0,
-      taskDescription: items?.find((item) => item.id === "task")?.description,
-      questionDescription: question?.description,
-      hasQuestion: !!question,
-      items
-    };
+    return fetchLiveToolInfo(this.config, this.modelId);
   }
   /**
    * Whether dcp-style context reminders should be stripped from this turn's
@@ -7161,31 +7443,19 @@ var ClaudeCodeLanguageModel = class {
    * spawn block resolves anything: `userMsg` is built well ahead of it.
    */
   stripContextRemindersEnabled() {
-    return shouldStripContextReminders({
-      enabled: this.config.stripContextReminders,
-      proxyTools: this.config.proxyTools,
-      proxyOpencodeTools: this.config.proxyOpencodeTools
-    });
+    return stripContextRemindersEnabled(this.config);
   }
   /**
    * Arguments the skill bridge needs beyond `cwd` / `cliPath`: which
    * `CLAUDE_CONFIG_DIR` this spawn reads its native skills from, and whether
-   * to drop the ones it already loads. A failover moves the spawn to another
-   * account, and therefore to that account's config dir.
+   * to drop the ones it already loads.
    */
   skillBridgeSpawn(failover) {
-    return {
-      configDir: failover.failedOver && failover.target ? accountConfigDirPath(failover.target) : this.config.configDir,
-      skipNative: this.config.bridgeSkipNativeSkills !== false
-    };
+    return skillBridgeSpawn(this.config, failover);
   }
   /** Share one lazy registry request within a turn without making it stale. */
   createLiveToolInfoLoader() {
-    let pending;
-    return () => {
-      pending ??= this.fetchLiveToolInfo();
-      return pending;
-    };
+    return createLiveToolInfoLoader(this.config, this.modelId);
   }
   /**
    * Whether the ExitPlanMode approval bridge is live for this turn: the
@@ -7194,129 +7464,19 @@ var ClaudeCodeLanguageModel = class {
    * `⚙ invalid` and wedge the turn, so the plugin keeps the text path.
    */
   async resolvePlanModeQuestion(compactionMode, loadLiveToolInfo = () => this.fetchLiveToolInfo()) {
-    if (compactionMode || this.config.planModeQuestion !== true) return false;
-    const info = await loadLiveToolInfo();
-    const active = isPlanModeQuestionActive({
-      configured: this.config.planModeQuestion,
-      opencodeHasQuestion: info.hasQuestion,
-      compactionMode
-    });
-    if (!active) {
-      log.info("plan-mode question gate", {
-        opencodeHasQuestion: info.hasQuestion,
-        registryResolved: info.resolved,
-        active
-      });
-    }
-    return active;
+    return resolvePlanModeQuestion(this.config, compactionMode, loadLiveToolInfo);
   }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
    */
   async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress) {
-    const timeoutOverrides = this.config.proxyToolTimeoutMs;
-    const interceptors = /* @__PURE__ */ new Map();
-    if (interceptCompress && tools.some((t) => t.name === "compress")) {
-      interceptors.set("compress", (input) => {
-        const summary = typeof input.summary === "string" ? input.summary.trim() : "";
-        if (!summary) {
-          return {
-            kind: "error",
-            message: "compress needs a non-empty `summary`: it becomes the only prior context after the reset. Nothing was compressed."
-          };
-        }
-        storeCompressionSummary(sessionKeyForCalls, summary);
-        log.info("compress stored summary; session resets next turn", {
-          sessionKey: sessionKeyForCalls,
-          summaryLength: summary.length
-        });
-        return {
-          kind: "text",
-          text: "Summary stored. Finish this turn as normal; the next turn starts a fresh Claude Code session with this summary as its only prior context."
-        };
-      });
-    }
-    const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors);
-    srv.calls.on("call", (call) => {
-      queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
-    });
-    return srv;
-  }
-  extractPendingProxyResult(prompt, toolCallId) {
-    for (let i = prompt.length - 1; i >= 0; i--) {
-      const msg = prompt[i];
-      if (msg.role !== "tool" || !Array.isArray(msg.content)) continue;
-      for (const part of msg.content) {
-        if (part.type !== "tool-result" || part.toolCallId !== toolCallId) continue;
-        const output = part.output;
-        if (!output || typeof output !== "object") {
-          return {
-            kind: "text",
-            text: String(output ?? "")
-          };
-        }
-        if (output.type === "text") {
-          return {
-            kind: "text",
-            text: String(output.value ?? "")
-          };
-        }
-        if (output.type === "json") {
-          return {
-            kind: "text",
-            text: JSON.stringify(output.value)
-          };
-        }
-        if (output.type === "content" && Array.isArray(output.value)) {
-          const text = output.value.filter((v) => v?.type === "text" && typeof v.text === "string").map((v) => v.text).join("\n");
-          return {
-            kind: "text",
-            text
-          };
-        }
-        return {
-          kind: "text",
-          text: JSON.stringify(output)
-        };
-      }
-    }
-    return null;
-  }
-  /**
-   * The result opencode produced for a pending proxy call, if the prompt
-   * carries it. For `task_batch` that means every child's result gathered
-   * back onto the parent: opencode runs the children in one step and hands
-   * all their results to the next call together, so a partial set is not
-   * expected. If it ever happens the batch still resolves, with the gap
-   * named in the text, because leaving the parent pending would send this
-   * turn down the fresh-envelope path and reject the call as orphaned.
-   */
-  extractPendingProxyResultForCall(prompt, call) {
-    if (call.toolName !== TASK_BATCH_TOOL_NAME) {
-      return this.extractPendingProxyResult(prompt, call.toolCallId);
-    }
-    const tasks = taskBatchTasks(call.input);
-    if (tasks.length === 0) {
-      return { kind: "error", message: "task_batch input is not a list of task objects" };
-    }
-    const children = tasks.map((task, index) => ({
-      task,
-      result: this.extractPendingProxyResult(
-        prompt,
-        taskBatchChildToolCallId(call.toolCallId, index)
-      )
-    }));
-    const answered = children.filter((child) => child.result !== null).length;
-    if (answered === 0) return null;
-    if (answered < children.length) {
-      log.warn("task_batch resolving with child results missing", {
-        toolCallId: call.toolCallId,
-        answered,
-        total: children.length
-      });
-    }
-    return formatTaskBatchResults(children);
+    return ensureProxyServer(
+      this.config,
+      tools,
+      sessionKeyForCalls,
+      interceptCompress
+    );
   }
   /**
    * Resolve the session affinity token for this LLM call. Delegates to the
@@ -7337,83 +7497,17 @@ var ClaudeCodeLanguageModel = class {
     );
   }
   controlRequestBehaviorForTool(toolName) {
-    const configured = this.config.controlRequestToolBehaviors;
-    if (configured && toolName) {
-      const direct = configured[toolName] ?? configured[toolName.toLowerCase()];
-      if (direct === "allow" || direct === "deny") return direct;
-      const lower = toolName.toLowerCase();
-      for (const [key, behavior] of Object.entries(configured)) {
-        if (key.toLowerCase() === lower && (behavior === "allow" || behavior === "deny")) {
-          return behavior;
-        }
-      }
-    }
-    if (isAskUserQuestionTool(toolName)) return "deny";
-    return this.config.controlRequestBehavior ?? "allow";
+    return controlRequestBehaviorForTool(this.config, toolName);
   }
   writeControlResponse(proc, requestId, response) {
-    const payload = {
-      type: "control_response",
-      response: {
-        subtype: "success",
-        request_id: requestId,
-        response
-      }
-    };
-    try {
-      proc.stdin?.write(JSON.stringify(payload) + "\n");
-    } catch (error) {
-      log.warn("failed to write control response", {
-        requestId,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
+    writeControlResponse(proc, requestId, response);
   }
   /**
    * Handle Claude stream-json control requests (`can_use_tool`, etc.) and
    * respond via stdin with a matching `control_response`.
    */
   handleControlRequest(msg, proc) {
-    if (msg.type !== "control_request") return false;
-    const requestId = msg.request_id;
-    const request = msg.request;
-    if (!requestId || !request?.subtype) return false;
-    if (request.subtype === "can_use_tool") {
-      const toolName = request.tool_name ?? "unknown";
-      const behavior = this.controlRequestBehaviorForTool(toolName);
-      if (behavior === "allow") {
-        this.writeControlResponse(proc, requestId, {
-          behavior: "allow",
-          updatedInput: request.input ?? {},
-          toolUseID: request.tool_use_id
-        });
-        log.info("control request auto-allowed", {
-          requestId,
-          toolName
-        });
-      } else {
-        const denyMessage = denyMessageForTool(
-          toolName,
-          this.config.controlRequestDenyMessage
-        );
-        this.writeControlResponse(proc, requestId, {
-          behavior: "deny",
-          message: denyMessage,
-          toolUseID: request.tool_use_id
-        });
-        log.info("control request auto-denied", {
-          requestId,
-          toolName
-        });
-      }
-      return true;
-    }
-    this.writeControlResponse(proc, requestId, {});
-    log.debug("control request acknowledged", {
-      requestId,
-      subtype: request.subtype
-    });
-    return true;
+    return handleControlRequest(this.config, msg, proc);
   }
   getReasoningEffort(providerOptions) {
     if (!providerOptions) return void 0;
@@ -7457,64 +7551,10 @@ var ClaudeCodeLanguageModel = class {
     };
   }
   latestUserText(prompt) {
-    for (let i = prompt.length - 1; i >= 0; i--) {
-      const msg = prompt[i];
-      if (msg.role !== "user") continue;
-      if (typeof msg.content === "string") {
-        return String(msg.content).trim();
-      }
-      if (Array.isArray(msg.content)) {
-        const text = msg.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => String(part.text).trim()).filter(Boolean).join(" ");
-        if (text) return text;
-      }
-    }
-    return "";
+    return latestUserText(prompt);
   }
   synthesizeTitle(prompt) {
-    const source = this.latestUserText(prompt).replace(/\s+/g, " ").replace(/[^\p{L}\p{N}\s-]/gu, " ").trim();
-    if (!source) return "New Session";
-    const stop = /* @__PURE__ */ new Set([
-      "a",
-      "an",
-      "the",
-      "and",
-      "or",
-      "but",
-      "to",
-      "for",
-      "of",
-      "in",
-      "on",
-      "at",
-      "with",
-      "can",
-      "could",
-      "would",
-      "should",
-      "please",
-      "hi",
-      "hello",
-      "hey",
-      "there",
-      "you",
-      "your",
-      "this",
-      "that",
-      "is",
-      "are",
-      "was",
-      "were",
-      "be",
-      "do",
-      "does",
-      "did",
-      "summarize",
-      "summary",
-      "project"
-    ]);
-    const words = source.split(" ").map((word) => word.trim()).filter(Boolean).filter((word) => !stop.has(word.toLowerCase()));
-    const picked = (words.length > 0 ? words : source.split(" ").filter(Boolean)).slice(0, 6).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-    return picked || "New Session";
+    return synthesizeTitle(prompt);
   }
   async doGenerateViaStream(options) {
     const result = await this.doStream(options);
@@ -8049,9 +8089,9 @@ ${plan}
       `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options) ?? 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);
+    const toUsage2 = this.toUsage.bind(this);
+    const toFinishReason2 = this.toFinishReason.bind(this);
+    const handleControlRequest2 = this.handleControlRequest.bind(this);
     const flagOn = (v) => v !== void 0 && !["", "0", "false", "no", "off"].includes(v.trim().toLowerCase());
     const interactivePref = this.config.interactive ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT);
     const useInteractive = interactivePref && typeof globalThis.Bun?.Terminal === "function";
@@ -8086,8 +8126,8 @@ ${plan}
             controller.enqueue({ type: "text-end", id });
             controller.enqueue({
               type: "finish",
-              finishReason: toFinishReason("stop"),
-              usage: toUsage({ input_tokens: 0, output_tokens: 0 }),
+              finishReason: toFinishReason2("stop"),
+              usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
               providerMetadata: {
                 "claude-code": { path: "doctor", synthetic: true, usageUnavailable: true }
               }
@@ -8134,8 +8174,8 @@ ${plan}
             controller.enqueue({ type: "text-end", id });
             controller.enqueue({
               type: "finish",
-              finishReason: toFinishReason("stop"),
-              usage: toUsage({}),
+              finishReason: toFinishReason2("stop"),
+              usage: toUsage2({}),
               providerMetadata: { "claude-code": { path: "side-question", synthetic: answer.synthetic, usageUnavailable: true } }
             });
           } catch (error) {
@@ -8167,8 +8207,8 @@ ${plan}
           controller.enqueue({ type: "text-end", id: textId });
           controller.enqueue({
             type: "finish",
-            finishReason: toFinishReason("stop"),
-            usage: toUsage({ input_tokens: 0, output_tokens: 0 }),
+            finishReason: toFinishReason2("stop"),
+            usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
             providerMetadata: {
               "claude-code": {
                 synthetic: true,
@@ -8191,8 +8231,8 @@ ${plan}
           controller.enqueue({ type: "stream-start", warnings });
           controller.enqueue({
             type: "finish",
-            finishReason: toFinishReason("stop"),
-            usage: toUsage({ input_tokens: 0, output_tokens: 0 }),
+            finishReason: toFinishReason2("stop"),
+            usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
             providerMetadata: {
               "claude-code": { synthetic: true, path: "no-new-user-content" }
             }
@@ -8236,7 +8276,7 @@ ${plan}
           controller.enqueue({
             type: "finish",
             finishReason: { unified: "error", raw: "account_limit" },
-            usage: toUsage({ input_tokens: 0, output_tokens: 0 }),
+            usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
             providerMetadata: {
               "claude-code": {
                 path: "account-failover-stop",
@@ -8309,7 +8349,7 @@ ${plan}
     const self = this;
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
       call,
-      result: this.extractPendingProxyResultForCall(options.prompt, call)
+      result: extractPendingProxyResultForCall(options.prompt, call)
     }));
     const hasMatchedPendingResults = previousPendingProxyMatches.some(
       (m) => m.result !== null
@@ -8885,8 +8925,8 @@ ${plan}
             }
             controller.enqueue({
               type: "finish",
-              finishReason: toFinishReason("tool-calls"),
-              usage: toUsage(resultMeta.usage),
+              finishReason: toFinishReason2("tool-calls"),
+              usage: toUsage2(resultMeta.usage),
               providerMetadata: {
                 "claude-code": resultMeta
               }
@@ -8916,8 +8956,8 @@ ${plan}
             });
             controller.enqueue({
               type: "finish",
-              finishReason: toFinishReason("tool-calls"),
-              usage: toUsage(resultMeta.usage),
+              finishReason: toFinishReason2("tool-calls"),
+              usage: toUsage2(resultMeta.usage),
               providerMetadata: {
                 "claude-code": resultMeta
               }
@@ -9089,8 +9129,8 @@ ${plan}
             }
             controller.enqueue({
               type: "finish",
-              finishReason: resultFailure ? { unified: "error", raw: resultFailure } : toFinishReason("stop"),
-              usage: toUsage(msg.usage),
+              finishReason: resultFailure ? { unified: "error", raw: resultFailure } : toFinishReason2("stop"),
+              usage: toUsage2(msg.usage),
               providerMetadata: {
                 "claude-code": {
                   ...resultMeta,
@@ -9134,7 +9174,7 @@ ${plan}
               if (outer.type === "stream_event") {
                 gotPartialEvents = true;
               }
-              if (handleControlRequest(msg, proc)) {
+              if (handleControlRequest2(msg, proc)) {
                 return;
               }
               log.debug("stream message", {
@@ -9838,8 +9878,8 @@ ${plan}
               }
               controller.enqueue({
                 type: "finish",
-                finishReason: toFinishReason(crashed ? "error" : "stop"),
-                usage: toUsage(),
+                finishReason: toFinishReason2(crashed ? "error" : "stop"),
+                usage: toUsage2(),
                 providerMetadata: {
                   "claude-code": {
                     ...resultMeta,