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

package/README.md

@@ -70,17 +70,17 @@ The plugin auto-registers the following. They appear in the model picker without
 
 | ID | Display name | Context | Output | Reasoning variants | Price × |
 |---|---|---|---|---|---|
-| `claude-haiku-4-5` | Claude Haiku 4.5 | 200k | 8,192 | – | 1× |
-| `claude-sonnet-4-5` | Claude Sonnet 4.5 | 1M | 16,384 | low/medium/high/xhigh/max | 3× |
-| `claude-sonnet-4-6` | Claude Sonnet 4.6 | 1M | 16,384 | low/medium/high/xhigh/max | 3× |
+| `claude-haiku-4-5` | Claude Haiku 4.5 | 200k | 64,000 | – | 1× |
+| `claude-sonnet-4-5` | Claude Sonnet 4.5 | 200k | 64,000 | low/medium/high/xhigh/max | 3× |
+| `claude-sonnet-4-6` | Claude Sonnet 4.6 | 1M | 128,000 | low/medium/high/xhigh/max | 3× |
 | `claude-sonnet-5` | Claude Sonnet 5 | 1M | 128,000 | low/medium/high/xhigh/max | 2×* |
-| `claude-opus-4-5` | Claude Opus 4.5 | 1M | 16,384 | low/medium/high/xhigh/max | 5× |
-| `claude-opus-4-6` | Claude Opus 4.6 | 1M | 16,384 | low/medium/high/xhigh/max | 5× |
-| `claude-opus-4-7` | Claude Opus 4.7 | 1M | 16,384 | low/medium/high/xhigh/max | 5× |
-| `claude-opus-4-8` | Claude Opus 4.8 | 1M | 16,384 | low/medium/high/xhigh/max | 5× |
+| `claude-opus-4-5` | Claude Opus 4.5 | 200k | 64,000 | low/medium/high/xhigh/max | 5× |
+| `claude-opus-4-6` | Claude Opus 4.6 | 1M | 128,000 | low/medium/high/xhigh/max | 5× |
+| `claude-opus-4-7` | Claude Opus 4.7 | 1M | 128,000 | low/medium/high/xhigh/max | 5× |
+| `claude-opus-4-8` | Claude Opus 4.8 | 1M | 128,000 | low/medium/high/xhigh/max | 5× |
 | `claude-opus-5` | Claude Opus 5 | 1M | 128,000 | low/medium/high/xhigh/max | 5× |
-| `claude-fable-5` | Claude Fable 5 | 1M | 16,384 | low/medium/high/xhigh/max | 10× |
-| `claude-mythos-5` | Claude Mythos 5 | 1M | 16,384 | low/medium/high/xhigh/max | 10× |
+| `claude-fable-5` | Claude Fable 5 | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
+| `claude-mythos-5` | Claude Mythos 5 | 1M | 128,000 | low/medium/high/xhigh/max | 10× |
 
 `claude-mythos-5` is Mythos-class like Fable 5 but without safety classifiers, and is **limited availability via [Project Glasswing](https://anthropic.com/glasswing)**. It's registered unconditionally; if your Claude account lacks access, `claude --model claude-mythos-5` just errors. Use `claude-fable-5` (generally available) otherwise.
 
@@ -271,6 +271,7 @@ By default, the plugin proxies `Bash`, `Edit`, `Write`, `WebFetch`, and `Task`.
 | `"Write"` | `Write` | `mcp__opencode_proxy__write` |
 | `"WebFetch"` | `WebFetch` | `mcp__opencode_proxy__webfetch` |
 | `"Task"` | `Agent` | `mcp__opencode_proxy__task` |
+| `"Question"` | `AskUserQuestion` | `mcp__opencode_proxy__question` |
 
 ### OpenCode-native subagents
 
@@ -295,7 +296,7 @@ recovery step for harnesses that defer MCP tool schemas. Both apply per Claude
 process at spawn, and provider options are read once at opencode startup, so
 `proxyTools` changes need a full opencode restart.
 
-Only those five values are actually proxied; anything else you put in `proxyTools` is ignored. Proxying `Edit` also disables `MultiEdit` — opencode has no batched-edit equivalent, so Claude is forced to fan out into single `Edit` calls that each flow through the permission UI.
+Only those six values are actually proxied; anything else you put in `proxyTools` is ignored. Proxying `Edit` also disables `MultiEdit` — opencode has no batched-edit equivalent, so Claude is forced to fan out into single `Edit` calls that each flow through the permission UI. The `"Question"` proxy is version-gated on opencode's built-in `question` tool: on builds that lack the registry entry the def is silently dropped (a forwarded call would otherwise render as `⚙ invalid`), so add it only on opencode versions that ship the `question` tool.
 
 Without `"Task"` in `proxyTools`, Claude's built-in `Agent` tool stays enabled and Claude orchestrates subagents internally with no opencode child-session visibility. To opt out of all proxying, including Task, use an explicit empty list:
 
@@ -303,6 +304,48 @@ Without `"Task"` in `proxyTools`, Claude's built-in `Agent` tool stays enabled a
 "options": { "proxyTools": [] }
 ```
 
+### Subagent todos
+
+When Claude works through a multi-step task it emits `TaskCreate` / `TaskUpdate` calls. The plugin translates those into opencode's full-list `todowrite` so the todo panel populates. Inside a **subagent** that translation is blocked unless you say otherwise: opencode's task tool injects `todowrite: false` into the tools dict for any subagent without an explicit rule, so the plugin's synthetic emissions surface as `⚙ invalid todowrite` rows instead of todos. The built-in `general` subagent denies it by default.
+
+Grant it per subagent definition in `opencode.json`:
+
+```json
+{
+  "agent": {
+    "multistep": {
+      "description": "Multi-step worker whose progress should be visible as todos",
+      "mode": "subagent",
+      "model": "claude-code-default/claude-opus-5",
+      "permission": {
+        "todowrite": "allow",
+        "todoread": "allow",
+        "task": "deny"
+      }
+    }
+  }
+}
+```
+
+Notes on that example:
+
+- `todowrite: "allow"` is the load-bearing line. Without it you get `⚙ invalid` rows, not a broken run.
+- `todoread` is worth allowing too so the subagent can re-read its own list across turns.
+- `task: "deny"` is explicit rather than implied. Leave it denied unless this subagent should itself delegate, in which case set `"allow"` and raise the top-level `subagent_depth` (opencode defaults it to `1`, so a child cannot spawn a grandchild).
+- Provider and agent config are read at startup, so restart opencode fully after editing.
+
+The todos render in the **subagent's own session view**, not the parent's panel. Navigate to it in the TUI with `session.child.next` (and back with `session.parent`); run `opencode --print-logs` or check the keybindings if those actions are unbound in your setup.
+
+To confirm the data actually landed rather than trusting the UI:
+
+```bash
+sqlite3 ~/.local/share/opencode/opencode.db \
+  "select id, parent_id from session order by rowid desc limit 5;"
+# then, with the child session id:
+sqlite3 ~/.local/share/opencode/opencode.db \
+  "select tool, state from part where session_id='<child-id>' and tool='todowrite';"
+```
+
 ### What you get with proxying on
 
 - opencode's **permission prompts** for every Bash/Edit/Write/WebFetch call (the default `claude --dangerously-skip-permissions` is NOT applied to proxied tools).
@@ -411,7 +454,29 @@ Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The
 
 ## AskUserQuestion
 
-opencode has no native structured ask-question executor to proxy through (unlike `Bash`/`Task`), so the plugin handles `AskUserQuestion` specially:
+opencode ships a built-in `question` tool (`packages/opencode/src/tool/question.ts`) that renders a real TUI form with options and a custom-answer field — near-identical to Claude Code's `AskUserQuestion` (`multiSelect` → `multiple`). The plugin can route `AskUserQuestion` through it so the prompt becomes an actual form instead of plain text. Two modes:
+
+### With `"Question"` in `proxyTools` (currently blocked upstream — leave it off)
+
+> **Known upstream breakage (opencode 1.15.x through at least 1.18.5).** opencode's `question` TUI form does not render, so the tool blocks until you interrupt the turn. This is not specific to this plugin: native providers hit it identically, and a `--pure` headless server drives the same question end to end successfully (`question.asked` → `GET /question` → `POST /question/{id}/reply` → tool completes), which isolates the fault to the TUI. Tracked upstream as [anomalyco/opencode#36604](https://github.com/anomalyco/opencode/issues/36604) with fix [PR #36603](https://github.com/anomalyco/opencode/pull/36603) (unmerged). Until that lands, enabling `"Question"` trades the working fallback below for a hang. The instructions here describe the intended behavior for when it is fixed.
+
+Add `"Question"` to `proxyTools` and grant `permission.question: allow` to the calling agent. Claude's built-in `AskUserQuestion` is disabled via `--disallowedTools`, and the plugin exposes `mcp__opencode_proxy__question` in its place. The model calls the proxy, opencode renders the form, and the operator's answers come back as arrays of selected labels. On builds that lack the `question` registry entry the def is silently dropped at spawn (version gate), and the deny/markdown fallback below applies instead.
+
+`proxyTools` replaces the default list rather than adding to it, so repeat the defaults you still want:
+
+```json
+"options": {
+  "proxyTools": ["Bash", "Edit", "Write", "WebFetch", "Task", "Question"]
+}
+```
+
+To turn it back off, drop `"Question"` from the list. It is **not** in the default list, so no configuration means the deny/markdown fallback below stays in force.
+
+The same spawn-time caveat as `"Task"` applies: provider options are read once at opencode startup, so restart opencode fully after adding it. Question calls get a 30-minute proxy deadline (raise it with `proxyToolTimeoutMs` if you expect to be AFK longer; an expired call comes back as an error, not an answer).
+
+### Without the proxy (default fallback)
+
+When `"Question"` is not in `proxyTools` (or the opencode version lacks the `question` tool), the plugin handles `AskUserQuestion` as follows:
 
 1. **It renders the full question.** The tool's payload — every question, header, option label, and option description — is emitted as readable markdown into the assistant stream so the user actually sees the choices (same approach as `ExitPlanMode`).
 2. **It is never auto-allowed at the CLI gate.** Allowing it would let the headless Claude CLI resolve its own question (no TTY → fabricated/empty answer) and proceed on a guess. `controlRequestBehaviorForTool` hard-denies `AskUserQuestion` and returns a message telling the model to **stop and wait for the operator's answer** — end the turn, call no further tools, and never self-answer. (Before v0.7.0 this message also offered an "if the run is non-interactive, proceed with a reasonable guess" fallback. The model could not reliably tell interactive opencode from a headless run and routinely took it, so questions appeared to be skipped — [issue #8](https://github.com/khalilgharbaoui/opencode-claude-code-plugin/issues/8). For genuinely unattended runs, use the `controlRequestToolBehaviors` override below instead.)
@@ -483,7 +548,7 @@ The plugin respects the standard Claude Code thinking env vars. If you set them
 
 - **Empty text blocks are dropped.** Claude sometimes opens a `content_block_start` for text but never sends a delta. The plugin no longer emits the empty block (which was triggering Anthropic 400s like `cache_control cannot be set for empty text blocks`).
 - **Smart incomplete-turn continuation.** By default, the plugin keeps the current opencode stream open and feeds Claude CLI a small internal continuation message when Claude emits a `result` after reasoning/tool activity without a useful visible answer. It still stops normally on final-looking answers, questions, blockers, errors, aborts, or internal safety-budget exhaustion. Disable with `"autoContinueIncompleteTurns": false`.
-- **`AskUserQuestion`** from the CLI is converted into plain text content rather than forwarded as a tool call.
+- **`AskUserQuestion`** from the CLI is converted into plain text content rather than forwarded as a tool call — unless `"Question"` is in `proxyTools`, in which case it is routed through opencode's native `question` tool (see [AskUserQuestion](#askuserquestion)).
 - **Wire-inactivity watchdog.** Once the CLI has produced any content, the stream closes gracefully if stdout goes silent for 60 seconds without a `result` message arriving. Resets on every line received, so long mid-turn pauses (Sonnet between text-end and the next tool_use, for example) are tolerated. On a user-initiated abort, the watchdog shortens to 5 seconds.
 - **Per-iteration usage.** When the CLI internally retries with tools, the plugin only counts the last iteration's usage so opencode's context accounting stays accurate.
 - **Lazy `cwd`.** The working directory is re-resolved at every request, so opencode's project-aware behavior works without restarting the plugin.
@@ -616,8 +681,8 @@ Workaround for autonomous compression: trigger it manually with `/dcp compress`
 - No streaming of tool inputs as they're being constructed (Anthropic's `input_json_delta`); the plugin emits them once complete.
 - Raw chain-of-thought is not available. Claude 4 family models ship summarized thinking only. See [Extended thinking](#extended-thinking) for the full picture.
 - Recommended Claude Code CLI: **2.1.142+**. Older CLIs work for everything else but skip the `--thinking-display` flag, so Claude Opus 4.7 turns may render empty Thinking rows. If something breaks after a Claude Code update, the CLI version is the first thing to check.
-- **Foreground Task calls have a 30-minute proxy timeout.** The same timeout is written into Claude's generated HTTP MCP configuration so long-running opencode subagents are not cut off by Claude's 60-second default. For independent longer work, use `background: true` after enabling opencode's experimental background-subagent flag.
-- **Subagent todos require explicit permission.** opencode's task tool gates `todowrite` per subagent: without a `permission: { todowrite: "allow" }` rule on the subagent definition, opencode injects `todowrite: false` into the tools dict and the plugin's synthetic `todowrite` emissions surface as `⚙ invalid todowrite` rows. The built-in `general` subagent denies `todowrite` by default; use a custom subagent for parallel work that needs todo visibility. Subagent todos render inline in the **subagent's** session view (navigate with the TUI's `session.child.next` / `session.parent` commands), not in the parent session's panel.
+- **Foreground Task calls have a 60-minute proxy deadline** (configurable via [`proxyToolTimeoutMs`](#per-tool-proxy-timeouts)). A ceiling covering the longest configured deadline is written into Claude's generated HTTP MCP configuration so long-running opencode subagents are not cut off by Claude's 60-second default. For independent longer work, use `background: true` after enabling opencode's experimental background-subagent flag.
+- **Subagent todos require explicit permission.** See [Subagent todos](#subagent-todos) for the rule and a working config.
 
 ---
 

package/dist/index.d.ts

@@ -258,16 +258,22 @@ interface ClaudeCodeProviderSettings {
      *     opencode's tool executor (with its native permission UI) and returns
      *     the result.
      *
-     * Supported: `bash`, `write`, `edit`, `webfetch`, `task`. Leave empty or unset to disable proxying.
-     *
-     * `task` proxies Claude CLI's `Agent` (subagent dispatch) tool through
-     * opencode's `task` tool, so subagent calls run under opencode's
-     * configured subagent set (build/general/custom) with opencode's
-     * permission and lifecycle handling, instead of Claude CLI's
-     * internal-only general-purpose / Explore / Plan options. The calling
-     * agent must have `permission.task: allow` for the target subagent
-     * (see opencode's agent docs).
-     */
+      * Supported: `bash`, `write`, `edit`, `webfetch`, `task`, `question`. Leave empty or unset to disable proxying.
+      *
+      * `task` proxies Claude CLI's `Agent` (subagent dispatch) tool through
+      * opencode's `task` tool, so subagent calls run under opencode's
+      * configured subagent set (build/general/custom) with opencode's
+      * permission and lifecycle handling, instead of Claude CLI's
+      * internal-only general-purpose / Explore / Plan options. The calling
+      * agent must have `permission.task: allow` for the target subagent
+      * (see opencode's agent docs).
+      *
+      * `question` proxies Claude CLI's `AskUserQuestion` through opencode's
+      * native `question` tool (TUI form with options + custom answer). The
+      * calling agent must have `permission.question: allow`. Version-gated:
+      * silently dropped on opencode builds that lack the `question` registry
+      * entry, in which case the deny/markdown fallback applies.
+      */
     proxyTools?: string[];
     /**
      * Per-tool proxy call timeouts in milliseconds, keyed by the proxy tool
@@ -506,16 +512,22 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      */
     private resolvedProxyMcpTools;
     /**
-     * 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.
      */
-    private fetchLiveTaskDescription;
+    private fetchLiveToolInfo;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.

package/dist/index.js

@@ -2071,8 +2071,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 +2122,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 +2151,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 +2287,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 +2454,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 +2589,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 +2986,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 +3169,33 @@ 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.
    */
-  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 {
+      taskDescription: items?.find((item) => item.id === "task")?.description,
+      questionDescription: question?.description,
+      hasQuestion: !!question
+    };
   }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
@@ -3987,26 +4069,52 @@ ${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 self.fetchLiveToolInfo() : {
+                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 +4129,8 @@ ${plan}
                 self.config.multiStepContinuation !== false,
                 [
                   ...extractSystemMessages(options.prompt),
-                  ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : []
+                  ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
+                  ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
                 ]
               );
               cliArgs = buildCliArgs({
@@ -5238,21 +5347,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 +5369,7 @@ var defaultModels = {
     family: "sonnet",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: sonnetCost,
     multiplier: 3,
     releaseDate: "2025-06-19"
@@ -5281,11 +5390,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 +5402,7 @@ var defaultModels = {
     family: "opus",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: opusCost,
     multiplier: 5,
     releaseDate: "2025-06-19"
@@ -5304,7 +5413,7 @@ var defaultModels = {
     family: "opus",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: opusCost,
     multiplier: 5,
     releaseDate: "2025-07-16"
@@ -5315,7 +5424,7 @@ var defaultModels = {
     family: "opus",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: opusCost,
     multiplier: 5,
     releaseDate: "2026-05-28"
@@ -5337,7 +5446,7 @@ var defaultModels = {
     family: "fable",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: fableCost,
     multiplier: 10,
     releaseDate: "2026-06-09"
@@ -5352,7 +5461,7 @@ var defaultModels = {
     family: "mythos",
     reasoning: true,
     context: 1e6,
-    output: 16384,
+    output: 128e3,
     cost: fableCost,
     multiplier: 10,
     releaseDate: "2026-06-09"