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

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.
 
@@ -183,6 +183,7 @@ The account model IDs are internally suffixed, for example `claude-sonnet-4-6@wo
 | `permissionMode` | `acceptEdits` \| `auto` \| `bypassPermissions` \| `default` \| `dontAsk` \| `plan` | – | Forwarded to `claude --permission-mode`. |
 | `proxyTools` | string[] | `["Bash", "Edit", "Write", "WebFetch", "Task"]` | Claude built-in tools to route through opencode's executor + permission UI. See [Selective tool proxy](#selective-tool-proxy). |
 | `proxyToolTimeoutMs` | `Record<string, number>` | – | Per-tool proxy call deadline in ms, keyed by proxy tool name (`bash`, `task`, …). Defaults: 10 min flat, `task` → 60 min. For `bash`, the call's own `input.timeout` is honoured on top (`max(resolved, input.timeout)`). See [Selective tool proxy](#selective-tool-proxy). |
+| `planModeQuestion` | boolean | `false` | Route `ExitPlanMode` approval through opencode's native `question` tool instead of a text "(yes/no)" prompt. Off because opencode's question form is currently broken upstream. See [Plan mode](#plan-mode). |
 | `controlRequestBehavior` | `allow` \| `deny` | `allow` | Default response when `skipPermissions: false` and Claude sends a `can_use_tool` control request. |
 | `controlRequestToolBehaviors` | `Record<string, "allow" \| "deny">` | – | Per-tool override for `can_use_tool`. Example: `{ "Bash": "deny", "Read": "allow" }`. |
 | `controlRequestDenyMessage` | string | built-in message | Message returned to Claude on a deny. |
@@ -271,6 +272,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 +297,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 +305,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).
@@ -407,11 +451,52 @@ Each chat keeps a long-lived `claude` subprocess so the model retains its native
 
 Set `permissionMode: "plan"` to forward `--permission-mode plan` to Claude. The plugin handles `ExitPlanMode` specially — instead of forwarding it as a tool call, it converts it to a confirmation prompt that flows through opencode normally.
 
+By default that prompt is text: the plan is rendered as markdown, followed by `**Do you want to proceed with this plan?** (yes/no)`, and you answer in your next message.
+
+### Approval as a real form (`planModeQuestion`, opt-in)
+
+Set `planModeQuestion: true` to route the approval through opencode's native `question` tool instead:
+
+```json
+"options": {
+  "permissionMode": "plan",
+  "planModeQuestion": true
+}
+```
+
+The plan is still rendered, but the turn then ends on `tool-calls` and opencode runs its own `question` tool, so approval is a form rather than prose. Your answer is fed back to the CLI as the `tool_result` for the original `ExitPlanMode` call, which is what actually unlocks plan mode on the Claude side. A "yes" typed as ordinary text never does that. Anything other than picking `yes` (including custom text) comes back as rejection feedback the model is told to act on.
+
+> **Leave this off for now.** It depends on the same opencode `question` form that is [broken upstream](#with-question-in-proxytools-currently-blocked-upstream--leave-it-off): with it on, a plan approval hangs until you interrupt the turn. On opencode builds with no `question` registry entry at all the plugin silently keeps the text path (look for `plan-mode question gate` in the log). Re-test when [anomalyco/opencode#36603](https://github.com/anomalyco/opencode/pull/36603) merges.
+
+Approval bridge contributed by [@CollieIsCute](https://github.com/CollieIsCute).
+
 ---
 
 ## 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 +568,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 +701,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

@@ -162,6 +162,14 @@ interface ClaudeCodeConfig {
     controlRequestDenyMessage?: string;
     proxyTools?: string[];
     proxyToolTimeoutMs?: Record<string, number>;
+    /**
+     * Route `ExitPlanMode` through opencode's native `question` tool so plan
+     * approval is a real form instead of a "(yes/no)" line the operator has to
+     * answer in prose. Off by default: opencode's question form is currently
+     * broken upstream, so enabling this trades a working text prompt for a
+     * silent hang. See the plan-mode gotcha in AGENTS.md.
+     */
+    planModeQuestion?: boolean;
     webSearch?: WebSearchRouting;
     hotReloadMcp?: boolean;
     proxyOpencodeMcpTools?: boolean;
@@ -258,16 +266,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
@@ -286,6 +300,23 @@ interface ClaudeCodeProviderSettings {
      * long build the caller explicitly asked to run is never undercut.
      */
     proxyToolTimeoutMs?: Record<string, number>;
+    /**
+     * Route Claude's `ExitPlanMode` through opencode's native `question` tool.
+     *
+     * Off (default): the plan is rendered as markdown followed by
+     * `**Do you want to proceed with this plan?** (yes/no)` and the operator
+     * answers in prose. On: the plan is rendered, the turn ends on
+     * `tool-calls`, and opencode runs its own `question` tool so approval is a
+     * real form; the answer is fed back to the CLI as the `tool_result` for
+     * the original `ExitPlanMode` call, which is what unlocks plan mode.
+     *
+     * Two reasons it is opt-in. opencode's `question` form does not currently
+     * render (upstream anomalyco/opencode#36604), so an enabled bridge hangs
+     * the turn until the operator interrupts; and older opencode builds have
+     * no `question` registry entry at all, in which case the plugin silently
+     * keeps the text path. See the plan-mode gotcha in AGENTS.md.
+     */
+    planModeQuestion?: boolean;
     /**
      * Strip `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` from the environment of
      * every spawned `claude` process. When an API key is present, Claude Code
@@ -506,16 +537,33 @@ 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. `resolved` distinguishes
+     * "the registry answered and has no `question` entry" from "nobody
+     * answered": only the former is a real version-gate signal.
+     */
+    private fetchLiveToolInfo;
+    /** Share one lazy registry request within a turn without making it stale. */
+    private createLiveToolInfoLoader;
+    /**
+     * 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.
      */
-    private fetchLiveTaskDescription;
+    private resolvePlanModeQuestion;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.