@khalilgharbaoui/opencode-claude-code-plugin 0.29.2 → 0.31.0

package/dist/index.js

@@ -405,6 +405,17 @@ function titleizeAccount(account) {
   return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 
+// src/types.ts
+var READ_ONLY_PERMISSION_MODE = "read-only";
+var DEFAULT_PROXY_TOOL_NAMES = [
+  "Bash",
+  "Edit",
+  "Write",
+  "WebFetch",
+  "Task"
+];
+var PROXY_MCP_SERVER_NAME = "opencode_proxy";
+
 // src/cli-events.ts
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -529,6 +540,35 @@ function reportRateLimitEvent(msg) {
   log[report.level](report.message, data);
   return report.transcript;
 }
+var MCP_SERVER_ERROR_TYPES = {
+  unknown_type: "its `type` is not one Claude Code knows",
+  url_missing_type: "it has a `url` but no `type`",
+  invalid_config: "its configuration did not validate",
+  reserved_name: "its name is reserved"
+};
+function parseMcpServerErrors(msg) {
+  const raw = msg.mcp_server_errors;
+  if (!Array.isArray(raw)) return [];
+  const errors = [];
+  for (const entry of raw) {
+    if (!isRecord(entry)) continue;
+    errors.push({
+      name: str(entry.name) ?? "unknown",
+      type: str(entry.type) ?? "unknown",
+      message: str(entry.message) ?? ""
+    });
+  }
+  return errors;
+}
+function describeMcpServerError(error) {
+  const why = MCP_SERVER_ERROR_TYPES[error.type];
+  const reason = why ? ` because ${why}` : "";
+  const detail = error.message ? ` Claude Code said: ${error.message}` : "";
+  if (error.name === PROXY_MCP_SERVER_NAME) {
+    return `Claude Code skipped the plugin's own MCP server "${error.name}" (${error.type})${reason}, so every proxied tool call this session will fail. This is a plugin bug or a corrupted scratch config rather than something in your own MCP settings: report it with this line.${detail}`;
+  }
+  return `Claude Code skipped MCP server "${error.name}" (${error.type})${reason}, so its tools are not available to the model this session. Fix the entry in your MCP config.${detail}`;
+}
 var API_KEY_SOURCES = /* @__PURE__ */ new Set([
   "ANTHROPIC_API_KEY",
   "apiKeyHelper",
@@ -554,7 +594,8 @@ function parseSystemInit(msg) {
     model: str(raw.model),
     cliVersion: str(raw.claude_code_version),
     toolCount: Array.isArray(raw.tools) ? raw.tools.length : 0,
-    mcpServers: servers
+    mcpServers: servers,
+    mcpServerErrors: parseMcpServerErrors(msg)
   };
 }
 function apiKeySourceWarning(apiKeySource, ignoreAnthropicApiKey) {
@@ -564,6 +605,11 @@ function apiKeySourceWarning(apiKeySource, ignoreAnthropicApiKey) {
 }
 var warnedApiKeySources = /* @__PURE__ */ new Set();
 var warnedMcpFailures = /* @__PURE__ */ new Set();
+var warnedMcpSkips = /* @__PURE__ */ new Set();
+var lastMcpServerErrors = /* @__PURE__ */ new Map();
+function snapshotMcpServerErrors() {
+  return [...lastMcpServerErrors.values()];
+}
 function reportSystemInit(msg, options = {}) {
   const info = parseSystemInit(msg);
   if (!info) return;
@@ -573,8 +619,20 @@ function reportSystemInit(msg, options = {}) {
     model: info.model ?? null,
     cliVersion: info.cliVersion ?? null,
     tools: info.toolCount,
-    mcpServers: info.mcpServers
+    mcpServers: info.mcpServers,
+    mcpServerErrors: info.mcpServerErrors
   });
+  for (const error of info.mcpServerErrors) {
+    lastMcpServerErrors.set(error.name, error);
+    const key2 = `${error.name}:${error.type}`;
+    const message = describeMcpServerError(error);
+    if (warnedMcpSkips.has(key2)) {
+      log.debug(message, { server: error.name, type: error.type });
+      continue;
+    }
+    warnedMcpSkips.add(key2);
+    log.warn(message, { server: error.name, type: error.type });
+  }
   for (const server2 of info.mcpServers) {
     if (server2.status === "connected") continue;
     const key2 = `${server2.name}:${server2.status}`;
@@ -678,6 +736,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";
@@ -1421,7 +1511,7 @@ function isExpectedCleanupError(message) {
   return message.includes("timed out after") && message.includes("waiting for opencode to resolve") || message.includes("rejecting as orphaned") || message.includes("was orphaned by a new user turn") || message.includes("stream was aborted") || message.includes(SERVER_CLOSED_MESSAGE);
 }
 var PROTOCOL_VERSION = "2024-11-05";
-var SERVER_NAME = "opencode_proxy";
+var SERVER_NAME = PROXY_MCP_SERVER_NAME;
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
 var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var PROXY_NO_DEADLINE_MS = 0;
@@ -2707,16 +2797,6 @@ function clearCompression(sessionKey2) {
   compressions.delete(sessionKey2);
 }
 
-// src/types.ts
-var READ_ONLY_PERMISSION_MODE = "read-only";
-var DEFAULT_PROXY_TOOL_NAMES = [
-  "Bash",
-  "Edit",
-  "Write",
-  "WebFetch",
-  "Task"
-];
-
 // src/permission-presets.ts
 var READ_ONLY_DISALLOWED_CLI_TOOLS = [
   "Bash",
@@ -3083,6 +3163,9 @@ function claudeSpawnEnv(opts) {
   if (opts?.effort) {
     env.CLAUDE_CODE_EFFORT_LEVEL = cliEffortLevel(opts.effort);
   }
+  if (opts?.promptCacheTtl) {
+    env.CLAUDE_CODE_PROMPT_CACHE_TTL = opts.promptCacheTtl;
+  }
   if (opts?.ignoreAnthropicApiKey) {
     delete env.ANTHROPIC_API_KEY;
     delete env.ANTHROPIC_AUTH_TOKEN;
@@ -3368,19 +3451,20 @@ function invalidateOtherEffortSessions(baseKey, effort) {
     clearCompression(key);
   }
 }
-function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort) {
+function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort, promptCacheTtl) {
   evictIfNeeded();
   log.info("spawning new claude process", {
     cliPath,
     cliArgs,
     cwd,
     sessionKey: sessionKey2,
-    effort
+    effort,
+    promptCacheTtl
   });
   const proc = spawn(cliPath, cliArgs, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort }),
+    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort, promptCacheTtl }),
     shell: process.platform === "win32"
   });
   const lineEmitter = new EventEmitter3();
@@ -3391,6 +3475,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     mcpHash,
     systemPromptFile,
     effort,
+    promptCacheTtl,
     startedAt: Date.now(),
     cliPath,
     cliArgs: [...cliArgs],
@@ -3454,6 +3539,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", {
@@ -3497,7 +3583,8 @@ function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropi
     old.mcpHash,
     old.systemPromptFile,
     ignoreAnthropicApiKey,
-    old.effort
+    old.effort,
+    old.promptCacheTtl
   );
   replacement.pendingProxyCompletions = old.pendingProxyCompletions;
   delete old.pendingProxyCompletions;
@@ -3912,8 +3999,90 @@ async function handleBtwCommand(client, input, options = {}) {
   }
 }
 
-// src/startup-diagnostics.ts
+// src/plan-usage.ts
 import { execFile as execFile2 } from "child_process";
+var PLAN_USAGE_ARGUMENTS = /* @__PURE__ */ new Set(["usage", "cost", "stats", "limits"]);
+function wantsPlanUsage(argument) {
+  return PLAN_USAGE_ARGUMENTS.has(argument.trim().toLowerCase());
+}
+var PLAN_USAGE_MAX_CHARS = 4e3;
+function truncate(text) {
+  return text.length <= PLAN_USAGE_MAX_CHARS ? text : `${text.slice(0, PLAN_USAGE_MAX_CHARS)}
+[truncated]`;
+}
+function parsePlanUsage(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { status: "failed", error: "the CLI printed nothing" };
+  const candidates = trimmed.split("\n").reverse();
+  for (const line of candidates) {
+    const start = line.indexOf("{");
+    if (start === -1) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line.slice(start));
+    } catch {
+      continue;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+    const record = parsed;
+    if (record.type !== void 0 && record.type !== "result") continue;
+    const text = typeof record.result === "string" ? record.result.trim() : "";
+    if (record.is_error === true) {
+      return { status: "failed", error: text || "the CLI reported an error" };
+    }
+    if (!text) continue;
+    return {
+      status: "ok",
+      text: truncate(text),
+      costUsd: typeof record.total_cost_usd === "number" ? record.total_cost_usd : 0,
+      numTurns: typeof record.num_turns === "number" ? record.num_turns : 0
+    };
+  }
+  return { status: "failed", error: "no result object in the CLI's reply" };
+}
+function runCli(cliPath, args, timeoutMs, env) {
+  return new Promise((resolve6, reject) => {
+    execFile2(
+      cliPath,
+      args,
+      // `killSignal` so a CLI wedged on a hook is actually gone, and a generous
+      // buffer because the reply is prose of unbounded length.
+      { timeout: timeoutMs, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024, env },
+      (error, stdout) => {
+        if (stdout && stdout.trim()) return resolve6(stdout);
+        if (error) return reject(error);
+        resolve6(stdout ?? "");
+      }
+    );
+  });
+}
+async function fetchPlanUsage(cliPath, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 2e4;
+  const run = options.runImpl ?? runCli;
+  try {
+    const env = claudeSpawnEnv({ ignoreAnthropicApiKey: options.ignoreAnthropicApiKey });
+    const stdout = await run(
+      cliPath,
+      ["-p", "/cost", "--output-format", "json"],
+      timeoutMs,
+      env
+    );
+    const usage = parsePlanUsage(stdout);
+    if (usage.status === "ok") {
+      log.info("read claude plan usage", { costUsd: usage.costUsd, numTurns: usage.numTurns });
+    } else if (usage.status === "failed") {
+      log.debug("could not read claude plan usage", { error: usage.error });
+    }
+    return usage;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.debug("could not read claude plan usage", { error: message });
+    return { status: "failed", error: message };
+  }
+}
+
+// src/startup-diagnostics.ts
+import { execFile as execFile3 } from "child_process";
 import * as fs4 from "fs";
 import * as path5 from "path";
 import { promisify as promisify2 } from "util";
@@ -4448,7 +4617,7 @@ function pickOpencodeVersion(input) {
   if (typeof direct === "string" && direct.length > 0) return direct;
   return void 0;
 }
-var execFileAsync2 = promisify2(execFile2);
+var execFileAsync2 = promisify2(execFile3);
 var opencodeVersionProbe;
 function detectOpencodeVersion(execPath = process.execPath) {
   if (opencodeVersionProbe) return opencodeVersionProbe;
@@ -4558,7 +4727,7 @@ function logStartupDiagnostics(providers, opencodeVersion) {
 
 // src/doctor.ts
 var DOCTOR_COMMAND = "claude-code-doctor";
-var DOCTOR_COMMAND_DESCRIPTION = "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls";
+var DOCTOR_COMMAND_DESCRIPTION = "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls. Add `usage` for plan windows";
 var DOCTOR_MARKER = "\u258C **claude-code doctor**";
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -4688,6 +4857,36 @@ function formatDoctorReport(report) {
       lines.push(`| ${server2.url} | ${describeAuth(server2.auth)} |`);
     }
   }
+  if (report.mcpServerErrors.length > 0) {
+    lines.push("");
+    lines.push("**MCP config entries Claude Code skipped**");
+    lines.push("");
+    lines.push("| server | category | Claude Code said |");
+    lines.push("|---|---|---|");
+    for (const error of report.mcpServerErrors) {
+      lines.push(`| ${error.name} | \`${error.type}\` | ${error.message || "no detail"} |`);
+    }
+    lines.push("");
+    lines.push("A skipped server is missing from the model's tools with no other sign of it.");
+  }
+  lines.push("");
+  lines.push("**Plan usage**");
+  lines.push("");
+  switch (report.planUsage.status) {
+    case "ok":
+      lines.push("```text");
+      lines.push(report.planUsage.text);
+      lines.push("```");
+      break;
+    case "failed":
+      lines.push(`Could not read it from the CLI: ${report.planUsage.error}`);
+      break;
+    case "not-requested":
+      lines.push(
+        "Not checked. Run `/claude-code-doctor usage` for the account's plan windows and reset times, straight from the CLI. It costs no tokens, but it does start a `claude` process, so it runs your `SessionStart` hooks and takes a few seconds."
+      );
+      break;
+  }
   const stderr = report.processes.filter((proc) => proc.lastStderr);
   if (stderr.length > 0) {
     lines.push("");
@@ -4747,6 +4946,9 @@ async function gatherDoctorReport(options) {
       auth: await checkProxyAuth(proc.proxyUrl, options.fetchImpl ?? fetch)
     });
   }
+  const planUsage = wantsPlanUsage(options.argument ?? "") ? await (options.planUsageImpl ?? fetchPlanUsage)(cliPath, {
+    ignoreAnthropicApiKey: options.ignoreAnthropicApiKey
+  }) : { status: "not-requested" };
   return {
     plugin: base.plugin,
     opencode: base.opencode,
@@ -4763,7 +4965,9 @@ async function gatherDoctorReport(options) {
     anthropicApiKeyInEnv: base.anthropicApiKeyInEnv,
     processes,
     pendingCalls: snapshotPendingProxyCalls(),
-    proxyServers
+    proxyServers,
+    mcpServerErrors: snapshotMcpServerErrors(),
+    planUsage
   };
 }
 async function buildDoctorReport(options) {
@@ -4775,7 +4979,9 @@ async function buildDoctorReport(options) {
       cwd: report.cwd,
       processes: report.processes.length,
       pendingCalls: report.pendingCalls.length,
-      proxyServers: report.proxyServers.map((server2) => server2.auth.status)
+      proxyServers: report.proxyServers.map((server2) => server2.auth.status),
+      mcpServerErrors: report.mcpServerErrors.length,
+      planUsage: report.planUsage.status
     });
     return formatDoctorReport(report);
   } catch (error) {
@@ -4849,6 +5055,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 };
@@ -4928,10 +5135,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",
@@ -5108,6 +5331,7 @@ function parseModelId(modelId) {
 
 // src/agent-models.ts
 var AGENT_DIR_NAMES = ["agents", "agent"];
+var PROMPT_CACHE_TTLS = ["5m", "1h"];
 var REASONING_EFFORTS = [
   "minimal",
   "low",
@@ -5118,6 +5342,7 @@ var REASONING_EFFORTS = [
 ];
 var registry = {};
 var defaultSubagentModel;
+var defaultSubagentCacheTtl;
 var providerFallbackModels = [];
 function setAgentRegistry(records) {
   registry = records;
@@ -5131,6 +5356,9 @@ function setDefaultSubagentModel(model) {
 function getDefaultSubagentModel() {
   return defaultSubagentModel;
 }
+function setDefaultSubagentCacheTtl(ttl) {
+  defaultSubagentCacheTtl = ttl?.trim() || void 0;
+}
 function setProviderFallbackModels(models) {
   providerFallbackModels = models ?? [];
 }
@@ -5195,6 +5423,25 @@ function resolveAgentEffort(agent, inherited, overrides) {
   }
   return declared;
 }
+function resolveAgentCacheTtl(agent, overrides) {
+  if (!agent) return void 0;
+  const record = (overrides?.records ?? registry)[agent];
+  if (!record) return void 0;
+  const fallback = overrides ? overrides.defaultSubagentCacheTtl : defaultSubagentCacheTtl;
+  const declared = record.cacheTtl?.trim();
+  const wanted = declared || (record.mode === "subagent" ? fallback?.trim() : void 0);
+  if (!wanted) return void 0;
+  if (!PROMPT_CACHE_TTLS.includes(wanted)) {
+    log.warn("agent prompt cache ttl refused: unknown value", {
+      agent,
+      wanted,
+      allowed: PROMPT_CACHE_TTLS.join(", ")
+    });
+    return void 0;
+  }
+  log.debug("agent prompt cache ttl", { agent, ttl: wanted });
+  return wanted;
+}
 function parseAgentFrontmatter(text) {
   const record = {};
   if (!text.startsWith("---")) return record;
@@ -5226,6 +5473,7 @@ function parseAgentFrontmatter(text) {
     else if (key === "model") record.model = value;
     else if (key === "forceModel") record.forceModel = value;
     else if (key === "reasoningEffort") record.reasoningEffort = value;
+    else if (key === "cacheTtl") record.cacheTtl = value;
   }
   return record;
 }
@@ -7566,6 +7814,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,
@@ -7657,6 +7916,7 @@ function createTurnState(init) {
     skipResultForIds: /* @__PURE__ */ new Set(),
     toolCallsById: /* @__PURE__ */ new Map(),
     resultMeta: {},
+    lastCallUsage: void 0,
     resultFailure: void 0,
     accountLimitHit: null,
     accountBlock: null,
@@ -8066,7 +8326,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
     }
@@ -8097,7 +8358,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
     }
@@ -8545,6 +8806,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"
@@ -9354,9 +9619,15 @@ var ClaudeCodeLanguageModel = class {
       this.getOpencodeAgent(options),
       this.getReasoningEffort(options.providerOptions)
     );
+    const promptCacheTtl = compactionMode ? void 0 : resolveAgentCacheTtl(this.getOpencodeAgent(options));
+    const context = [
+      this.config.provider,
+      this.getOpencodeAgent(options) ?? null
+    ];
+    if (promptCacheTtl) context.push(promptCacheTtl);
     const baseKey = sessionKey(
       cwd,
-      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options) ?? null])}`
+      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify(context)}`
     );
     const sk = compactionMode ? sessionKey(cwd, `${effectiveModelId}::compaction::${affinity}`) : effortSessionKey(baseKey, reasoningEffort);
     const toUsage2 = this.toUsage.bind(this);
@@ -9384,7 +9655,11 @@ var ClaudeCodeLanguageModel = class {
       const doctorOptions = {
         cliPath,
         interactive: !!useInteractive,
-        turnStats: this.config.turnStats === true
+        turnStats: this.config.turnStats === true,
+        ignoreAnthropicApiKey: this.config.ignoreAnthropicApiKey === true,
+        // `/claude-code-doctor usage` opts into the CLI's own plan-usage
+        // report; anything else here is ignored, as it always has been.
+        argument: doctor.rest
       };
       const stream2 = new ReadableStream({
         async start(controller) {
@@ -9944,7 +10219,8 @@ var ClaudeCodeLanguageModel = class {
                 spawnMcpHash,
                 spawnSystemPromptFile,
                 self.config.ignoreAnthropicApiKey,
-                reasoningEffort
+                reasoningEffort,
+                promptCacheTtl
               );
               state.proc = ap.proc;
               state.lineEmitter = ap.lineEmitter;
@@ -10017,7 +10293,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" }
                   }
@@ -10065,19 +10341,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
                   }
                 } : {}
               }
@@ -11352,6 +11632,10 @@ async function buildAgentRegistry(config) {
   setDefaultSubagentModel(
     typeof configured === "string" ? configured : void 0
   );
+  const configuredTtl = options?.defaultSubagentCacheTtl;
+  setDefaultSubagentCacheTtl(
+    typeof configuredTtl === "string" ? configuredTtl : void 0
+  );
   setProviderFallbackModels(parseFallbackModelList(options?.fallbackModels));
   const records = await readAgentMarkdownRecords(
     agentDirectories(
@@ -11373,6 +11657,7 @@ async function buildAgentRegistry(config) {
       model: pick("model") ?? records[name]?.model,
       forceModel: pick("forceModel") ?? records[name]?.forceModel,
       reasoningEffort: pick("reasoningEffort") ?? records[name]?.reasoningEffort,
+      cacheTtl: pick("cacheTtl") ?? records[name]?.cacheTtl,
       fallbackModels: declaredChain.length ? declaredChain : records[name]?.fallbackModels
     };
   }