@khalilgharbaoui/opencode-claude-code-plugin 0.11.2 → 0.12.1

package/dist/index.js

@@ -393,7 +393,7 @@ var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
   "image/webp"
 ]);
 function toImageBlock(part) {
-  const raw = part.data ?? part.url ?? part.source?.data;
+  const raw = part.image ?? part.data ?? part.url ?? part.source?.data;
   if (!raw) {
     log.warn("file part without data, skipping");
     return null;
@@ -728,6 +728,161 @@ Now continuing with the current message:
   });
 }
 
+// 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.";
+var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
+var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
+var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
+var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
+var KEY_SEPARATOR = "\0";
+function isPlanModeQuestionActive(input) {
+  if (input.compactionMode) return false;
+  if (input.configured !== true) return false;
+  return input.opencodeHasQuestion;
+}
+var pendingQuestions = /* @__PURE__ */ new Map();
+function pendingKey(sessionKey2, questionToolCallId) {
+  return `${sessionKey2}${KEY_SEPARATOR}${questionToolCallId}`;
+}
+function clearExitPlanModeQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
+  for (const key of pendingQuestions.keys()) {
+    if (key.startsWith(prefix)) pendingQuestions.delete(key);
+  }
+}
+function createExitPlanModeQuestionCall(sessionKey2, exitPlanModeToolUseId, plan, questionToolCallId = `exit_plan_question_${exitPlanModeToolUseId}`) {
+  pendingQuestions.set(pendingKey(sessionKey2, questionToolCallId), exitPlanModeToolUseId);
+  return {
+    toolCallId: questionToolCallId,
+    toolName: QUESTION_TOOL_NAME,
+    input: {
+      questions: [
+        {
+          header: "Plan approval",
+          question: PLAN_MODE_APPROVAL_QUESTION,
+          options: [
+            { label: "yes", description: "" },
+            { label: "no", description: "" }
+          ],
+          multiple: false,
+          custom: true
+        }
+      ]
+    },
+    text: plan ? `
+
+${plan}
+` : "\n\n"
+  };
+}
+function buildToolResultMessage(input) {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        input.approved ? {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: APPROVED_EXIT_PLAN_MODE_MESSAGE
+        } : {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: `${REJECTED_EXIT_PLAN_MODE_PREFIX}
+${input.feedback || "no"}`,
+          is_error: true
+        }
+      ]
+    }
+  });
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapToolOutput(part) {
+  const output = part?.output ?? part?.result;
+  if (typeof output === "string") return tryParseJson(output);
+  if (!output || typeof output !== "object") return output;
+  switch (output.type) {
+    case "json":
+    case "error-json":
+      return output.value;
+    case "text":
+    case "error-text":
+      return tryParseJson(String(output.value ?? ""));
+    case "execution-denied":
+      return {
+        denied: true,
+        reason: String(output.reason ?? "question rejected")
+      };
+    case "content":
+      return Array.isArray(output.value) ? output.value.map((item) => {
+        if (item?.type === "text") return item.text;
+        return JSON.stringify(item);
+      }).join("\n") : output.value;
+    default:
+      return output;
+  }
+}
+function unwrapOpencodeQuestionResult(value) {
+  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
+    return value.slice(
+      OPENCODE_QUESTION_RESULT_PREFIX.length,
+      -OPENCODE_QUESTION_RESULT_SUFFIX.length
+    );
+  }
+  return value;
+}
+function collectAnswerStrings(value) {
+  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
+  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
+  if (!value || typeof value !== "object") return [];
+  const obj = value;
+  if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
+  for (const key of ["answers", "answer", "selected", "selection", "value"]) {
+    if (key in obj) return collectAnswerStrings(obj[key]);
+  }
+  return [];
+}
+function classifyQuestionResult(part) {
+  const output = unwrapToolOutput(part);
+  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
+    return { approved: true, feedback: "" };
+  }
+  return {
+    approved: false,
+    feedback: answers.length > 0 ? answers.join("\n") : "no"
+  };
+}
+function consumeExitPlanModeQuestionResult(sessionKey2, prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type !== "tool-result" || typeof part.toolCallId !== "string") {
+        continue;
+      }
+      const key = pendingKey(sessionKey2, part.toolCallId);
+      const exitPlanModeToolUseId = pendingQuestions.get(key);
+      if (!exitPlanModeToolUseId) continue;
+      pendingQuestions.delete(key);
+      const result = classifyQuestionResult(part);
+      return buildToolResultMessage({
+        toolUseId: exitPlanModeToolUseId,
+        approved: result.approved,
+        feedback: result.feedback
+      });
+    }
+  }
+  return null;
+}
+
 // src/mcp-bridge.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -1341,6 +1496,7 @@ 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);
@@ -2071,8 +2227,10 @@ 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
+  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) {
@@ -2120,6 +2278,7 @@ function buildProxyTimeoutError(toolName, ms) {
 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.";
 function extractAgentTypeList(liveDescription) {
   const live = liveDescription?.trim();
   if (!live) return void 0;
@@ -2148,6 +2307,19 @@ function overlayTaskProxyDescription(tools, liveDescription) {
 ${t.description}` } : t
   );
 }
+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 filterQuestionProxyByOpencodeSupport(tools, opencodeHasQuestion) {
+  if (opencodeHasQuestion) return tools;
+  return tools.filter((t) => t.name !== "question");
+}
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -2271,6 +2443,56 @@ var DEFAULT_PROXY_TOOLS = [
       },
       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"]
+    }
   }
 ];
 async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides) {
@@ -2388,23 +2610,14 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           if (timer) clearTimeout(timer);
           pending.delete(callId);
         });
-        if (result.kind === "error") {
-          writeJson(res, {
-            jsonrpc: "2.0",
-            id: requestId,
-            result: {
-              content: [{ type: "text", text: result.message }],
-              isError: true
-            }
-          });
-          return;
-        }
+        const text = result.kind === "error" ? result.message : result.text;
+        const isError = result.kind === "error" || result.isError === true;
         writeJson(res, {
           jsonrpc: "2.0",
           id: requestId,
           result: {
-            content: [{ type: "text", text: result.text }],
-            isError: result.isError === true
+            content: [{ type: "text", text }],
+            isError
           }
         });
         return;
@@ -2532,7 +2745,13 @@ function disallowedToolFlags(tools) {
     glob: ["Glob"],
     grep: ["Grep"],
     webfetch: ["WebFetch"],
-    task: ["Agent"]
+    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();
@@ -2923,6 +3142,14 @@ Subagent dispatch in this environment goes through exactly one tool: \`mcp__open
 - 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:
@@ -3098,22 +3325,67 @@ var ClaudeCodeLanguageModel = class {
     return out.length > 0 ? out : null;
   }
   /**
-   * Live description of opencode's `task` tool for the current
-   * provider/model, exactly as opencode's registry renders it for native
-   * models — including the "Available agent types" list (built from the
-   * default agent's permissions). Overlaid onto the static `task` proxy
-   * def so Claude sees the same subagent catalog native opencode models
-   * see, instead of hunting through config files. Returns undefined when
-   * the SDK client is unavailable (direct AI-SDK use, tests) so the
-   * static def stands.
+   * 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.
    */
-  async fetchLiveTaskDescription() {
+  async fetchLiveToolInfo() {
     const items = await fetchOpencodeToolList(
       this.config.provider,
       this.modelId,
       this.config.cwd
     );
-    return items?.find((item) => item.id === "task")?.description || void 0;
+    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
+    };
+  }
+  /** Share one lazy registry request within a turn without making it stale. */
+  createLiveToolInfoLoader() {
+    let pending;
+    return () => {
+      pending ??= this.fetchLiveToolInfo();
+      return pending;
+    };
+  }
+  /**
+   * Whether the ExitPlanMode approval bridge is live for this turn: the
+   * operator opted in AND opencode's registry actually has the `question`
+   * tool. Without the registry entry the emitted tool-call would render as
+   * `⚙ 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;
   }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
@@ -3487,14 +3759,11 @@ var ClaudeCodeLanguageModel = class {
     const hasExistingSession = !!getClaudeSessionId(sk);
     const includeHistoryContext = !hasExistingSession && hasPriorConversation;
     const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = getClaudeUserMessage(
-      options.prompt,
-      includeHistoryContext,
-      reasoningEffort
-    );
-    const [runtimeStatus, cliVersion] = await Promise.all([
+    const userMsg = consumeExitPlanModeQuestionResult(sk, options.prompt) ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort);
+    const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
-      detectCliVersion(this.config.cliPath)
+      detectCliVersion(this.config.cliPath),
+      this.resolvePlanModeQuestion(compactionMode)
     ]);
     const systemPromptFile = buildAppendedSystemPrompt(
       cwd,
@@ -3583,6 +3852,20 @@ var ClaudeCodeLanguageModel = class {
                 if (block.name === "ExitPlanMode") {
                   const parsedInput = block.input ?? {};
                   const plan = parsedInput?.plan || "";
+                  if (planModeQuestionActive) {
+                    const questionCall = createExitPlanModeQuestionCall(
+                      sk,
+                      block.id,
+                      plan
+                    );
+                    responseText += questionCall.text;
+                    toolCalls.push({
+                      id: questionCall.toolCallId,
+                      name: questionCall.toolName,
+                      args: questionCall.input
+                    });
+                    continue;
+                  }
                   responseText += `
 
 ${plan}
@@ -3633,7 +3916,19 @@ ${plan}
                   error: String(err)
                 });
               }
-              toolCalls.push({ id: tc.id, name: tc.name, args });
+              if (tc.name === "ExitPlanMode" && planModeQuestionActive) {
+                const parsedInput = args;
+                const plan = parsedInput?.plan || "";
+                const questionCall = createExitPlanModeQuestionCall(sk, tc.id, plan);
+                responseText += questionCall.text;
+                toolCalls.push({
+                  id: questionCall.toolCallId,
+                  name: questionCall.toolName,
+                  args: questionCall.input
+                });
+              } else {
+                toolCalls.push({ id: tc.id, name: tc.name, args });
+              }
               toolCallStreams.delete(msg.index);
             }
           }
@@ -3706,6 +4001,16 @@ ${plan}
       });
     }
     for (const tc of result.toolCalls) {
+      if (tc.name === QUESTION_TOOL_NAME) {
+        content.push({
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          input: JSON.stringify(tc.args),
+          providerExecuted: false
+        });
+        continue;
+      }
       const {
         name: mappedName,
         input: mappedInput,
@@ -3728,11 +4033,13 @@ ${plan}
     const usage = this.toUsage(result.usage);
     return {
       content,
-      // Claude CLI's `result` message signals a fully-completed turn —
-      // tools have already been executed internally and final assistant
-      // text has been produced. Always report "stop" so opencode doesn't
-      // loop expecting to run tools itself.
-      finishReason: this.toFinishReason("stop"),
+      // Claude CLI's `result` message normally signals a fully-completed turn:
+      // tools have already been executed internally and final assistant text
+      // has been produced. ExitPlanMode is the exception: we surface it as
+      // opencode's native question tool so the outer loop must run that tool.
+      finishReason: this.toFinishReason(
+        result.toolCalls.some((tc) => tc.name === QUESTION_TOOL_NAME) ? "tool-calls" : "stop"
+      ),
       usage,
       request: { body: { text: userMsg } },
       response: {
@@ -3836,13 +4143,19 @@ ${plan}
     const hasActiveProcess = !!getActiveProcess(sk);
     const includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
     const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = getClaudeUserMessage(
-      options.prompt,
-      includeHistoryContext,
-      reasoningEffort,
-      { compactionMode }
-    );
+    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, {
+      compactionMode
+    });
     const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
+    const loadLiveToolInfo = this.createLiveToolInfoLoader();
+    const planModeQuestionActive = await this.resolvePlanModeQuestion(
+      compactionMode,
+      loadLiveToolInfo
+    );
     const self = this;
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
@@ -3987,26 +4300,53 @@ ${plan}
               );
               const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
               const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
+              const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
+              const liveToolInfo = taskProxyEnabled || questionProxyEnabled ? await loadLiveToolInfo() : {
+                resolved: false,
+                taskDescription: void 0,
+                questionDescription: void 0,
+                hasQuestion: false
+              };
               let enrichedProxy = resolvedProxy;
-              if (resolvedProxy && taskProxyEnabled) {
-                const liveTaskDescription = await self.fetchLiveTaskDescription();
+              if (enrichedProxy && taskProxyEnabled) {
                 enrichedProxy = overlayTaskProxyDescription(
-                  resolvedProxy,
-                  liveTaskDescription
+                  enrichedProxy,
+                  liveToolInfo.taskDescription
                 );
                 log.info("task proxy description overlay", {
-                  applied: Boolean(liveTaskDescription),
-                  liveDescriptionLength: liveTaskDescription?.length ?? 0,
+                  applied: Boolean(liveToolInfo.taskDescription),
+                  liveDescriptionLength: liveToolInfo.taskDescription?.length ?? 0,
                   listsAgentTypes: Boolean(
-                    liveTaskDescription?.includes("Available agent types")
+                    liveToolInfo.taskDescription?.includes(
+                      "Available agent types"
+                    )
                   )
                 });
               }
-              const combinedProxyTools = enrichedProxy || proxyMcpTools ? [...enrichedProxy ?? [], ...proxyMcpTools ?? []] : null;
+              if (enrichedProxy && questionProxyEnabled) {
+                enrichedProxy = overlayQuestionProxyDescription(
+                  enrichedProxy,
+                  liveToolInfo.hasQuestion ? liveToolInfo.questionDescription : void 0
+                );
+                enrichedProxy = filterQuestionProxyByOpencodeSupport(
+                  enrichedProxy,
+                  liveToolInfo.hasQuestion
+                );
+                log.info("question proxy version gate", {
+                  opencodeHasQuestion: liveToolInfo.hasQuestion,
+                  kept: liveToolInfo.hasQuestion
+                });
+              }
+              const combinedList = [
+                ...enrichedProxy ?? [],
+                ...proxyMcpTools ?? []
+              ];
+              const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
               if (!proxyServer && combinedProxyTools) {
                 proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
               }
-              const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
+              const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
+              const proxyDisallowed = enrichedProxy ? disallowedToolFlags(enrichedProxy) : [];
               const extraDisallowed = [];
               if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
               const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
@@ -4021,7 +4361,8 @@ ${plan}
                 self.config.multiStepContinuation !== false,
                 [
                   ...extractSystemMessages(options.prompt),
-                  ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : []
+                  ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
+                  ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
                 ]
               );
               cliArgs = buildCliArgs({
@@ -4253,6 +4594,37 @@ ${plan}
             } catch {
             }
           };
+          const finishWithExitPlanQuestion = (call) => {
+            if (controllerClosed) return;
+            endTextBlock();
+            controller.enqueue({
+              type: "tool-input-start",
+              id: call.toolCallId,
+              toolName: call.toolName,
+              providerExecuted: false
+            });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: call.toolCallId,
+              toolName: call.toolName,
+              input: JSON.stringify(call.input),
+              providerExecuted: false
+            });
+            controller.enqueue({
+              type: "finish",
+              finishReason: toFinishReason("tool-calls"),
+              usage: toUsage(resultMeta.usage),
+              providerMetadata: {
+                "claude-code": resultMeta
+              }
+            });
+            controllerClosed = true;
+            cleanupTurn();
+            try {
+              controller.close();
+            } catch {
+            }
+          };
           const drainNow = () => {
             if (drainTimer) {
               clearTimeout(drainTimer);
@@ -4578,6 +4950,21 @@ ${plan}
                     endTextBlock();
                   } else if (tc.name === "ExitPlanMode") {
                     const plan = parsedInput?.plan || "";
+                    if (planModeQuestionActive) {
+                      const questionCall = createExitPlanModeQuestionCall(
+                        sk,
+                        tc.id,
+                        plan
+                      );
+                      const planId2 = startTextBlock();
+                      controller.enqueue({
+                        type: "text-delta",
+                        id: planId2,
+                        delta: questionCall.text
+                      });
+                      finishWithExitPlanQuestion(questionCall);
+                      return;
+                    }
                     const planId = startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
@@ -4744,6 +5131,21 @@ ${plan}
                       endTextBlock();
                     } else if (block.name === "ExitPlanMode") {
                       const plan = parsedInput?.plan || "";
+                      if (planModeQuestionActive) {
+                        const questionCall = createExitPlanModeQuestionCall(
+                          sk,
+                          block.id,
+                          plan
+                        );
+                        const planId2 = startTextBlock();
+                        controller.enqueue({
+                          type: "text-delta",
+                          id: planId2,
+                          delta: questionCall.text
+                        });
+                        finishWithExitPlanQuestion(questionCall);
+                        return;
+                      }
                       const planId = startTextBlock();
                       controller.enqueue({
                         type: "text-delta",
@@ -5238,21 +5640,21 @@ var defaultModels = {
     family: "haiku",
     reasoning: false,
     context: 2e5,
-    output: 8192,
+    output: 64e3,
     cost: haikuCost,
     multiplier: 1,
-    releaseDate: "2024-10-22"
+    releaseDate: "2025-10-01"
   }),
   "claude-sonnet-4-5": defineModel({
     id: "claude-sonnet-4-5",
     name: "Claude Sonnet 4.5",
     family: "sonnet",
     reasoning: true,
-    context: 1e6,
-    output: 16384,
+    context: 2e5,
+    output: 64e3,
     cost: sonnetCost,
     multiplier: 3,
-    releaseDate: "2025-04-14"
+    releaseDate: "2025-09-29"
   }),
   "claude-sonnet-4-6": defineModel({
     id: "claude-sonnet-4-6",
@@ -5260,7 +5662,7 @@ var defaultModels = {
     family: "sonnet",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: sonnetCost,
     multiplier: 3,
     releaseDate: "2025-06-19"
@@ -5281,11 +5683,11 @@ var defaultModels = {
     name: "Claude Opus 4.5",
     family: "opus",
     reasoning: true,
-    context: 1e6,
-    output: 16384,
+    context: 2e5,
+    output: 64e3,
     cost: opusCost,
     multiplier: 5,
-    releaseDate: "2025-04-14"
+    releaseDate: "2025-11-01"
   }),
   "claude-opus-4-6": defineModel({
     id: "claude-opus-4-6",
@@ -5293,7 +5695,7 @@ var defaultModels = {
     family: "opus",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: opusCost,
     multiplier: 5,
     releaseDate: "2025-06-19"
@@ -5304,7 +5706,7 @@ var defaultModels = {
     family: "opus",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: opusCost,
     multiplier: 5,
     releaseDate: "2025-07-16"
@@ -5315,7 +5717,7 @@ var defaultModels = {
     family: "opus",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: opusCost,
     multiplier: 5,
     releaseDate: "2026-05-28"
@@ -5337,7 +5739,7 @@ var defaultModels = {
     family: "fable",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: fableCost,
     multiplier: 10,
     releaseDate: "2026-06-09"
@@ -5352,7 +5754,7 @@ var defaultModels = {
     family: "mythos",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: fableCost,
     multiplier: 10,
     releaseDate: "2026-06-09"
@@ -5709,6 +6111,7 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
     proxyTools: stringList(firstOption(providers, "proxyTools")),
     mcpServers,
     interactiveTransport: firstOption(providers, "interactive") === true || process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT === "1",
+    planModeQuestion: firstOption(providers, "planModeQuestion") === true,
     anthropicApiKeyInEnv: Boolean(
       process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
     )
@@ -5797,6 +6200,7 @@ function createClaudeCode(settings = {}) {
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
+      planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,