@khalilgharbaoui/opencode-claude-code-plugin 0.30.0 → 0.31.1

package/README.md

@@ -69,7 +69,7 @@ That package spec is the whole install. Do **not** `npm install` the package you
 
 Quit opencode fully and relaunch it: plugins are loaded once, at process start, so a reload is not enough.
 
-In the model picker you should now see a provider called **Claude Code (Default)** holding entries such as `Claude Haiku 4.5 (1×)`, `Claude Sonnet 5 (3×)` and `Claude Opus 5 (5×)`. The `(N×)` suffix is each model's list price relative to Haiku; see [Models](#models). Pick one and send a message.
+In the model picker you should now see a provider called **Claude Code (Default)** holding entries such as `Claude Haiku 4.5 (1×)`, `Claude Sonnet 5.5 (2×)` and `Claude Opus 5 (5×)`. The `(N×)` suffix is each model's list price relative to Haiku; see [Models](#models). Pick one and send a message.
 
 If the provider does not appear, if the models are there but a message fails, or if a version you just upgraded to is missing, go to [Troubleshooting](#troubleshooting). It is keyed on the first thing you see and names one check per symptom.
 
@@ -122,14 +122,15 @@ Verified live on opencode **2.0.11** with Claude Code 2.1.280: chat turns, proxi
 
 ## Models
 
-The plugin auto-registers the following, and they appear in the model picker with no extra config: Haiku 4.5, Sonnet 4.5/4.6/5, Opus 4.5/4.6/4.7/4.8/5/5.5 (plus three fast-mode Opus entries), Fable 5/5.1 and Mythos 5/5.1, each except Haiku carrying `low` / `medium` / `high` / `xhigh` / `max` reasoning variants.
+The plugin auto-registers the following, and they appear in the model picker with no extra config: Haiku 4.5, Sonnet 4.5/4.6/5/5.5, Opus 4.5/4.6/4.7/4.8/5/5.5 (plus three fast-mode Opus entries), Fable 5/5.1 and Mythos 5/5.1, each except Haiku carrying `low` / `medium` / `high` / `xhigh` / `max` reasoning variants.
 
 | ID | Display name | Context | Output | Reasoning variants | Price × |
 |---|---|---|---|---|---|
 | `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 | 3× |
+| `claude-sonnet-5` | Claude Sonnet 5 | 1M | 128,000 | low/medium/high/xhigh/max | 2× |
+| `claude-sonnet-5-5` | Claude Sonnet 5.5 | 1M | 128,000 | low/medium/high/xhigh/max | 2× |
 | `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× |
@@ -148,10 +149,12 @@ The plugin auto-registers the following, and they appear in the model picker wit
 
 Capabilities for every model: text + image input, text output, tool use, attachments. No temperature control, no PDF/audio/video, no interleaved streaming.
 
-**Price ×** is each model's per-token list price relative to Haiku, the cheapest model. It's derived exactly from Anthropic's published pricing (input and output ratios both come out the same: Haiku $1/$5 = 1×, Sonnet $3/$15 = 3×, Opus 5.5 $4/$20 = 4×, Opus $5/$25 = 5×, Opus 5.5 fast mode $8/$40 = 8×, Fable/Mythos 5 and 5.1 / Opus 5 and 4.8 fast mode $10/$50 = 10×). So **Fable/Mythos 5 and 5.1, and fast-mode Opus 5 and 4.8, all cost 2× standard Opus 5**, and fast mode is 2× the standard price on every Opus that offers it. The same multiplier is shown as a `(N×)` suffix on the display name in opencode's model picker, since opencode has no dedicated multiplier field. On a flat Max/Pro subscription it doubles as a rough guide to how fast each model drains your usage limit.
+**Price ×** is each model's per-token list price relative to Haiku, the cheapest model. It's derived exactly from Anthropic's published pricing (input and output ratios both come out the same: Haiku $1/$5 = 1×, Sonnet 5 and 5.5 $2/$10 = 2×, Sonnet 4.5/4.6 $3/$15 = 3×, Opus 5.5 $4/$20 = 4×, Opus $5/$25 = 5×, Opus 5.5 fast mode $8/$40 = 8×, Fable/Mythos 5 and 5.1 / Opus 5 and 4.8 fast mode $10/$50 = 10×). So **Fable/Mythos 5 and 5.1, and fast-mode Opus 5 and 4.8, all cost 2× standard Opus 5**, and fast mode is 2× the standard price on every Opus that offers it. The same multiplier is shown as a `(N×)` suffix on the display name in opencode's model picker, since opencode has no dedicated multiplier field. On a flat Max/Pro subscription it doubles as a rough guide to how fast each model drains your usage limit.
 
 Fable 5.1 and Mythos 5.1 keep the same $10/M input and $50/M output rates as 5.0, but cache reads cost $0.25/M instead of $1/M. Their cache-write rate remains $12.50/M.
 
+Sonnet 5 and Sonnet 5.5 are $2/M input and $10/M output, with cache writes at $2.50/M and cache reads at $0.20/M. Sonnet 5's price was announced as introductory until 2026-08-31, but Anthropic cancelled the increase to $3/$15, so $2/$10 is its standard price. Sonnet 5.5 runs on any recent Claude Code, but **2.1.284 is the first release that knows it**. An older CLI still serves it, on fallback limits (a 200k context window instead of 1M, and an estimated cost). The plugin warns once when the CLI reports that, and `claude update` fixes it.
+
 Opus 5.5 is priced below the Opus line at $4/M input and $20/M output, with cache writes at $5/M and cache reads at $0.20/M (0.05× input rather than the usual 0.1×). It needs **Claude Code 2.1.280 or newer**: the API rejects it from an older CLI with a 400 naming that floor, which shows up as a failed turn.
 
 The model ID is passed straight through to `claude --model`, so anything Claude Code accepts works. The three `-fast` IDs are the one exception, described below.
@@ -887,6 +890,8 @@ It carries the startup-diagnostics fields (plugin version, opencode version, `cl
 
 When Claude Code refused an entry in an `--mcp-config` it was handed, an **MCP config entries Claude Code skipped** section names each one with the CLI's own category and sentence. That section only appears when there is something in it. It matters because a skipped server is absent from the CLI's server list entirely rather than listed as broken, so the model silently does not have those tools; if the skipped name is `opencode_proxy` the report says so plainly, because then it is the plugin's own server and every proxied tool call in the session fails. The same thing is a warning in your terminal when it happens.
 
+A **Plugins Claude Code did not load** section works the same way for Claude plugins: one the CLI demoted at load time (for example, a dependency that is not installed) is absent from its plugin list, so its skills, commands and MCP servers are silently missing. The skill bridge is such a plugin (`opencode-skills`), and a failure there is reported as the plugin's own bug rather than your config. A plugin warning only counts when its content did not load; advisory feedback about a plugin that did load stays in the log at INFO.
+
 ```text
 /claude-code-doctor usage
 ```
@@ -909,7 +914,7 @@ One line at the end of a finished turn, from the numbers the CLI already reports
 
 - Never on a `/compact` turn (the footer would be appended to what opencode stores as the summary) and never on a turn that ended in error, where the error is the thing to read.
 - It is its own text part led by `▌ **stats:**`, and the plugin strips it again if the conversation is ever replayed into a fresh Claude Code process. The model never reads its own accounting.
-- Token counts are the turn's totals, which is what matches the cost. They are deliberately not the same numbers opencode's context gauge shows, which use the last tool-use iteration so the window is not inflated.
+- Token counts are the turn's totals, which is what matches the cost. They are deliberately not what opencode records for the message: opencode reads that as context occupancy (its context gauge and its auto-compaction), so it gets the input and cache counts of the turn's last API call, plus the whole turn's output. opencode's own cost figure for a multi-call turn therefore counts only the last call's input and cache; the CLI's real cost is this line and `providerMetadata["claude-code"].costUsd`.
 - The cost is what the CLI reported for the turn, not a billing guarantee.
 
 The same numbers are logged at INFO whatever this option is set to, and `total_cost_usd`, `duration_ms`, `duration_api_ms`, `num_turns`, `usage`, `modelUsage` and `permission_denials` always reach `providerMetadata` (denials by tool name and id only, never their inputs).
@@ -1248,7 +1253,7 @@ The plugin respects the standard Claude Code thinking env vars. If you set them
 - **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. It also resumes an answer the model was cut off mid-sentence: a `max_tokens` stop means truncation rather than completion, so the turn continues instead of ending on half a sentence, capped at 8 attempts and 10 minutes. Every other stop reason is taken at face value. Disable with `"autoContinueIncompleteTurns": false`.
 - **`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.
+- **Context usage, not turn totals.** The CLI's `result` adds up every API call in a turn, and opencode reads a message's usage as how full the context is, so a tool-heavy turn looked several times its real size and triggered auto-compaction far below the window. The plugin reports the last API call's input and cache counts plus the turn's output instead. See [Per-turn stats](#per-turn-stats) for what that does to opencode's cost figure.
 - **Lazy `cwd`.** The working directory is re-resolved at every request, so opencode's project-aware behavior works without restarting the plugin.
 - **Variants survive merge.** opencode recalculates variant lists after the plugin loads; the plugin re-injects defaults into runtime config so your variants don't disappear.
 
@@ -1573,7 +1578,7 @@ This plugin absorbs work from its forks directly, cherry-picked with the origina
 | [@galvani](https://github.com/galvani) (Jan Kozak) | Per-session working directory for `opencode serve`, so one server spawns each project's `claude` in the right place. Also found the stale `toolCallMap` re-emission three months before it was fixed here. | `9e02ce4`, `2238ed0` |
 | [@HeikoAtGitHub](https://github.com/HeikoAtGitHub) | Stopped sending `AGENTS.md` to the model twice (opencode already forwards it). Independently diagnosed the 5-minute proxy wall. | `25260a4`, `42f426d` |
 | [@bernardofortes](https://github.com/bernardofortes) (Bernardo Fortes) | `idleProcessTimeoutMs`, idle eviction of retained `claude` workers. | `a5f723a` |
-| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, `task_batch` for concurrent subagents (and the measurement that the CLI serialises MCP calls), the undici 300 s diagnosis of the proxy wall, the lifecycle release of proxied calls that made the `task` deadline unnecessary (PR #36), and Claude Opus 5.5 with its fast-mode entry (PR #43). | PR #18, `68ed142`, PR #36, PR #43 |
+| [@broskees](https://github.com/broskees) (Joseph Roberts) | Task proxy default-on (PR #18), the abort `interrupt` so Esc really stops the CLI, the skill bridge, `task_batch` for concurrent subagents (and the measurement that the CLI serialises MCP calls), the undici 300 s diagnosis of the proxy wall, the lifecycle release of proxied calls that made the `task` deadline unnecessary (PR #36), Claude Opus 5.5 with its fast-mode entry (PR #43), and the fix for turn-summed usage that made opencode auto-compact far below the window (PR #63). | PR #18, `68ed142`, PR #36, PR #43, PR #63 |
 | [@jknlsn](https://github.com/jknlsn) (Jake Nelson) | Per-tool proxy timeouts, subagent dispatch steering, the question proxy, the start watchdog respawn. | `84f3db9`, `94980a6`, `47501d0`, `ffefc24` |
 | [@CollieIsCute](https://github.com/CollieIsCute) (Collie Tsai) | The plan-mode approval bridge. | `8c5b583` |
 | [@flupkede](https://github.com/flupkede) | The compress proxy tool design and the AI-SDK v4 image-part fix. | `4ac319f`, `60a6e9a` |
@@ -1581,6 +1586,7 @@ This plugin absorbs work from its forks directly, cherry-picked with the origina
 | [@willmcginnis](https://github.com/willmcginnis) | The proxy endpoint authentication (PR #28, GHSA-3mxm-w7gf-3c5x). | PR #28 |
 | [@nic-lan](https://github.com/nic-lan) | The issue #29 diagnosis of subagent output lost across the CLI resume boundary, and the fix for unattended output replaying as one text block per delta (PR #35). | #29, PR #35 |
 | [@acastro2](https://github.com/acastro2) (Alexandre Castro) | Found and fixed CLI tool results being emitted under a different name than their call, which made opencode 2 abort every turn that used a Claude-side MCP server (PR #46). | PR #46 |
+| [@bangnh1](https://github.com/bangnh1) | Independently found and diagnosed the turn-summed usage that tripped auto-compaction after a single prompt, measured on opencode 2 (PR #62; the fix landed as PR #63). | PR #62 |
 | [@JWebCoder](https://github.com/JWebCoder) (joao moura) | Diagnosed that auto-continue never fires on current CLIs (PR #15). | PR #15 |
 
 Commit hashes are on the contributors' forks where the work was cherry-picked; `git log --author` on this repo shows the preserved authorship.

package/dist/index.d.ts

@@ -937,6 +937,8 @@ interface ClaudeStreamMessage {
             /** On a `tool_result` block: the CLI-executed tool failed. */
             is_error?: boolean;
         }>;
+        /** On an `assistant` frame: that one API call's usage, not the turn's. */
+        usage?: ClaudeStreamMessage["usage"];
     };
     apiKeySource?: string;
     permissionMode?: string;

package/dist/index.js

@@ -415,6 +415,7 @@ var DEFAULT_PROXY_TOOL_NAMES = [
   "Task"
 ];
 var PROXY_MCP_SERVER_NAME = "opencode_proxy";
+var SKILL_PLUGIN_NAME = "opencode-skills";
 
 // src/cli-events.ts
 function isRecord(value) {
@@ -595,9 +596,44 @@ function parseSystemInit(msg) {
     cliVersion: str(raw.claude_code_version),
     toolCount: Array.isArray(raw.tools) ? raw.tools.length : 0,
     mcpServers: servers,
-    mcpServerErrors: parseMcpServerErrors(msg)
+    mcpServerErrors: parseMcpServerErrors(msg),
+    pluginErrors: parsePluginDiagnostics(raw.plugin_errors),
+    pluginWarnings: parsePluginDiagnostics(raw.plugin_warnings),
+    loadedPlugins: parseLoadedPlugins(raw.plugins)
   };
 }
+function parsePluginDiagnostics(raw) {
+  if (!Array.isArray(raw)) return [];
+  const diagnostics = [];
+  for (const entry of raw) {
+    if (!isRecord(entry)) continue;
+    diagnostics.push({
+      plugin: str(entry.plugin) ?? "unknown",
+      type: str(entry.type) ?? "unknown",
+      message: str(entry.message) ?? ""
+    });
+  }
+  return diagnostics;
+}
+function parseLoadedPlugins(raw) {
+  if (!Array.isArray(raw)) return [];
+  const loaded = [];
+  for (const entry of raw) {
+    if (!isRecord(entry)) continue;
+    for (const id of [str(entry.source), str(entry.name)]) {
+      if (id && !loaded.includes(id)) loaded.push(id);
+    }
+  }
+  return loaded;
+}
+function describePluginLoadFailure(diagnostic) {
+  const detail = diagnostic.message ? ` Claude Code said: ${diagnostic.message}` : "";
+  const name = diagnostic.plugin.split("@", 1)[0];
+  if (name === SKILL_PLUGIN_NAME) {
+    return `Claude Code did not load the plugin's own skill bridge "${diagnostic.plugin}" (${diagnostic.type}), so the opencode skills it bridges are missing this session. This is a plugin bug or a corrupted scratch directory rather than your config: report it with this line.${detail}`;
+  }
+  return `Claude Code did not load plugin "${diagnostic.plugin}" (${diagnostic.type}), so its skills, commands and MCP servers are missing this session.${detail}`;
+}
 function apiKeySourceWarning(apiKeySource, ignoreAnthropicApiKey) {
   if (!apiKeySource || !API_KEY_SOURCES.has(apiKeySource)) return null;
   const base = `Claude Code authenticated with an API key (apiKeySource: ${apiKeySource}), so these turns bill as pay-as-you-go API usage instead of your subscription.`;
@@ -607,9 +643,32 @@ var warnedApiKeySources = /* @__PURE__ */ new Set();
 var warnedMcpFailures = /* @__PURE__ */ new Set();
 var warnedMcpSkips = /* @__PURE__ */ new Set();
 var lastMcpServerErrors = /* @__PURE__ */ new Map();
+var warnedPluginDiagnostics = /* @__PURE__ */ new Set();
+var lastPluginLoadFailures = /* @__PURE__ */ new Map();
 function snapshotMcpServerErrors() {
   return [...lastMcpServerErrors.values()];
 }
+function snapshotPluginLoadFailures() {
+  return [...lastPluginLoadFailures.values()];
+}
+function reportPluginDiagnostics(info) {
+  const report = (kind, diagnostic) => {
+    const loaded = kind === "warning" && info.loadedPlugins.includes(diagnostic.plugin);
+    const message = loaded ? `Claude Code has advisory feedback for plugin "${diagnostic.plugin}" (${diagnostic.type}): ${diagnostic.message}` : describePluginLoadFailure(diagnostic);
+    if (!loaded) lastPluginLoadFailures.set(diagnostic.plugin, { kind, ...diagnostic });
+    const key = `${kind}:${diagnostic.plugin}:${diagnostic.type}`;
+    const data = { plugin: diagnostic.plugin, type: diagnostic.type, kind };
+    if (warnedPluginDiagnostics.has(key)) {
+      log.debug(message, data);
+      return;
+    }
+    warnedPluginDiagnostics.add(key);
+    if (loaded) log.info(message, data);
+    else log.warn(message, data);
+  };
+  for (const diagnostic of info.pluginErrors) report("error", diagnostic);
+  for (const diagnostic of info.pluginWarnings) report("warning", diagnostic);
+}
 function reportSystemInit(msg, options = {}) {
   const info = parseSystemInit(msg);
   if (!info) return;
@@ -620,8 +679,11 @@ function reportSystemInit(msg, options = {}) {
     cliVersion: info.cliVersion ?? null,
     tools: info.toolCount,
     mcpServers: info.mcpServers,
-    mcpServerErrors: info.mcpServerErrors
+    mcpServerErrors: info.mcpServerErrors,
+    pluginErrors: info.pluginErrors,
+    pluginWarnings: info.pluginWarnings
   });
+  reportPluginDiagnostics(info);
   for (const error of info.mcpServerErrors) {
     lastMcpServerErrors.set(error.name, error);
     const key2 = `${error.name}:${error.type}`;
@@ -736,6 +798,38 @@ function formatSilentTurnNote(hadReasoning) {
 ${SILENT_TURN_MARKER} ${what}, so there is no reply above. Nothing failed and nothing is pending: send the message again, or rephrase it.
 `;
 }
+var UNRECOGNIZED_MODEL_STDERR_MARKER = "[claude-code:unrecognized_model]";
+var MODEL_CLI_FLOORS = {
+  // "Added Claude Sonnet 5.5 (`claude-sonnet-5-5`)" (CHANGELOG, 2.1.284).
+  "claude-sonnet-5-5": "2.1.284"
+};
+function parseUnrecognizedModel(stderr) {
+  const at = stderr.indexOf(UNRECOGNIZED_MODEL_STDERR_MARKER);
+  if (at === -1) return null;
+  const rest = stderr.slice(at + UNRECOGNIZED_MODEL_STDERR_MARKER.length);
+  const line = rest.split("\n", 1)[0].trim();
+  try {
+    const payload = JSON.parse(line);
+    return { model: isRecord(payload) ? str(payload.model) : void 0 };
+  } catch {
+    return { model: void 0 };
+  }
+}
+var warnedUnrecognizedModels = /* @__PURE__ */ new Set();
+function reportUnrecognizedModel(stderr) {
+  const parsed = parseUnrecognizedModel(stderr);
+  if (!parsed) return;
+  const model = parsed.model ?? "unknown";
+  const floor = parsed.model ? MODEL_CLI_FLOORS[parsed.model] : void 0;
+  const fix = floor ? `It needs Claude Code ${floor} or newer: run \`claude update\`.` : "Update Claude Code (`claude update`) to a release that knows it.";
+  const message = `Claude Code does not recognise the model "${model}". It still runs it, but on fallback limits (measured on 2.1.280: a 200k context window instead of 1M, and an estimated cost), so its own compaction may start early and turnStats' cost is approximate. ${fix}`;
+  if (warnedUnrecognizedModels.has(model)) {
+    log.debug(message, { model });
+    return;
+  }
+  warnedUnrecognizedModels.add(model);
+  log.warn(message, { model, ...floor ? { cliFloor: floor } : {} });
+}
 
 // src/plan-mode-question.ts
 var QUESTION_TOOL_NAME = "question";
@@ -3507,6 +3601,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     const stderr = data.toString();
     log.debug("stderr", { data: stderr.slice(0, 200) });
     retainStderr(ap, stderr);
+    reportUnrecognizedModel(stderr);
     if (stderr.includes("No conversation found") || stderr.includes("Session ID") && (stderr.includes("already in use") || stderr.includes("not found") || stderr.includes("invalid"))) {
       if (activeProcesses.get(sessionKey2) === ap) {
         log.warn("claude session ID error, clearing session", {
@@ -4836,6 +4931,18 @@ function formatDoctorReport(report) {
     lines.push("");
     lines.push("A skipped server is missing from the model's tools with no other sign of it.");
   }
+  if (report.pluginLoadFailures.length > 0) {
+    lines.push("");
+    lines.push("**Plugins Claude Code did not load**");
+    lines.push("");
+    lines.push("| plugin | kind | category | Claude Code said |");
+    lines.push("|---|---|---|---|");
+    for (const failure of report.pluginLoadFailures) {
+      lines.push(
+        `| ${failure.plugin} | ${failure.kind} | \`${failure.type}\` | ${failure.message || "no detail"} |`
+      );
+    }
+  }
   lines.push("");
   lines.push("**Plan usage**");
   lines.push("");
@@ -4934,6 +5041,7 @@ async function gatherDoctorReport(options) {
     pendingCalls: snapshotPendingProxyCalls(),
     proxyServers,
     mcpServerErrors: snapshotMcpServerErrors(),
+    pluginLoadFailures: snapshotPluginLoadFailures(),
     planUsage
   };
 }
@@ -4948,6 +5056,7 @@ async function buildDoctorReport(options) {
       pendingCalls: report.pendingCalls.length,
       proxyServers: report.proxyServers.map((server2) => server2.auth.status),
       mcpServerErrors: report.mcpServerErrors.length,
+      pluginLoadFailures: report.pluginLoadFailures.length,
       planUsage: report.planUsage.status
     });
     return formatDoctorReport(report);
@@ -5022,6 +5131,7 @@ function passthroughModel(id) {
 }
 var haikuCost = { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 };
 var sonnetCost = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+var sonnet5Cost = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
 var opusCost = { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 };
 var fableCost = { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 };
 var fable51Cost = { input: 10, output: 50, cacheRead: 0.25, cacheWrite: 12.5 };
@@ -5101,10 +5211,26 @@ var defaultModels = {
     reasoning: true,
     context: 1e6,
     output: 128e3,
-    cost: sonnetCost,
-    multiplier: 3,
+    cost: sonnet5Cost,
+    multiplier: 2,
     releaseDate: "2026-06-30"
   }),
+  // Sonnet 5.5 runs on any recent Claude Code, but 2.1.284 is the first
+  // release that knows it: an older CLI serves it on fallback limits (200k
+  // context, an estimated cost) and says so on stderr, which
+  // `reportUnrecognizedModel` turns into a warning. No `-fast` entry: the CLI
+  // gates fast mode on Opus names.
+  "claude-sonnet-5-5": defineModel({
+    id: "claude-sonnet-5-5",
+    name: "Claude Sonnet 5.5",
+    family: "sonnet",
+    reasoning: true,
+    context: 1e6,
+    output: 128e3,
+    cost: sonnet5Cost,
+    multiplier: 2,
+    releaseDate: "2026-09-28"
+  }),
   "claude-opus-4-5": defineModel({
     id: "claude-opus-4-5",
     name: "Claude Opus 4.5",
@@ -6028,7 +6154,6 @@ import * as fs5 from "fs";
 import * as os3 from "os";
 import * as path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var SKILL_PLUGIN_NAME = "opencode-skills";
 function bundledSkillsDir() {
   try {
     const here = fileURLToPath2(import.meta.url);
@@ -7764,6 +7889,17 @@ function toUsage(rawUsage) {
     raw: rawUsage
   };
 }
+function lastCallContextUsage(lastCallUsage, turnTotalUsage) {
+  if (!lastCallUsage || !turnTotalUsage) return turnTotalUsage;
+  const iterations = lastCallUsage.iterations;
+  const context = iterations?.length ? iterations[iterations.length - 1] : lastCallUsage;
+  return {
+    input_tokens: context.input_tokens,
+    cache_read_input_tokens: context.cache_read_input_tokens,
+    cache_creation_input_tokens: context.cache_creation_input_tokens,
+    output_tokens: turnTotalUsage.output_tokens
+  };
+}
 function toFinishReason(reason = "stop") {
   return {
     unified: reason,
@@ -7855,6 +7991,7 @@ function createTurnState(init) {
     skipResultForIds: /* @__PURE__ */ new Set(),
     toolCallsById: /* @__PURE__ */ new Map(),
     resultMeta: {},
+    lastCallUsage: void 0,
     resultFailure: void 0,
     accountLimitHit: null,
     accountBlock: null,
@@ -8264,7 +8401,8 @@ function finishWithToolCalls(state, calls) {
   state.controller.enqueue({
     type: "finish",
     finishReason: state.toFinishReason("tool-calls"),
-    usage: state.toUsage(state.resultMeta.usage),
+    // No result yet (the usual mid-turn boundary) still reports nothing.
+    usage: state.toUsage(lastCallContextUsage(state.lastCallUsage, state.resultMeta.usage)),
     providerMetadata: {
       "claude-code": state.resultMeta
     }
@@ -8295,7 +8433,7 @@ function finishWithQuestionCall(state, call) {
   state.controller.enqueue({
     type: "finish",
     finishReason: state.toFinishReason("tool-calls"),
-    usage: state.toUsage(state.resultMeta.usage),
+    usage: state.toUsage(lastCallContextUsage(state.lastCallUsage, state.resultMeta.usage)),
     providerMetadata: {
       "claude-code": state.resultMeta
     }
@@ -8743,6 +8881,10 @@ ${plan}
       if (msg.type === "assistant" && msg.message && typeof msg.message.stop_reason === "string") {
         state.lastStopReason = msg.message.stop_reason;
       }
+      const callUsage = msg.type === "assistant" ? msg.message?.usage : void 0;
+      if (callUsage && (callUsage.input_tokens ?? 0) + (callUsage.cache_read_input_tokens ?? 0) + (callUsage.cache_creation_input_tokens ?? 0) > 0) {
+        state.lastCallUsage = callUsage;
+      }
       if (msg.type === "assistant" && msg.message?.content && state.gotPartialEvents) {
         const thinkingBlocks = msg.message.content.filter(
           (b) => b.type === "thinking"
@@ -10226,7 +10368,7 @@ var ClaudeCodeLanguageModel = class {
                 controller.enqueue({
                   type: "finish",
                   finishReason: { unified: "error", raw: refusal.kind },
-                  usage: toUsage2(msg.usage),
+                  usage: toUsage2(lastCallContextUsage(state.lastCallUsage, msg.usage)),
                   providerMetadata: {
                     "claude-code": { ...state.resultMeta, path: "model-fallback" }
                   }
@@ -10274,19 +10416,23 @@ var ClaudeCodeLanguageModel = class {
               });
               state.endTextBlock();
             }
+            const usage = toUsage2(lastCallContextUsage(state.lastCallUsage, msg.usage));
             controller.enqueue({
               type: "finish",
               finishReason: state.resultFailure ? { unified: "error", raw: state.resultFailure } : toFinishReason2("stop"),
-              usage: toUsage2(msg.usage),
+              usage,
               providerMetadata: {
                 "claude-code": {
                   ...state.resultMeta,
                   ...state.resultFailure ? { resultSubtype: state.resultFailure } : {},
                   ...compactionMode ? { compactionModel: effectiveModelId } : {}
                 },
+                // opencode falls back to this when the usage has no cache
+                // write (0 is sent as none), so it must match the usage, never
+                // the turn total.
                 ...typeof msg.usage?.cache_creation_input_tokens === "number" ? {
                   anthropic: {
-                    cacheCreationInputTokens: msg.usage.cache_creation_input_tokens
+                    cacheCreationInputTokens: usage.inputTokens.cacheWrite ?? 0
                   }
                 } : {}
               }