@khalilgharbaoui/opencode-claude-code-plugin 0.22.1 → 0.24.0

package/dist/index.js

@@ -127,6 +127,7 @@ var log = {
 // src/todo-ledger.ts
 var ledgers = /* @__PURE__ */ new Map();
 var PENDING_CREATE_TTL_MS = 6e4;
+var MAX_LEDGER_SESSIONS = 64;
 var TASK_CREATED_PATTERN = /Task\s*#?\s*(\d+)\s+created/i;
 var VALID_STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed"]);
 function getOrCreate(sessionId) {
@@ -134,9 +135,18 @@ function getOrCreate(sessionId) {
   if (!ledger) {
     ledger = { todos: /* @__PURE__ */ new Map(), pendingCreates: /* @__PURE__ */ new Map() };
     ledgers.set(sessionId, ledger);
+    capLedgers();
   }
   return ledger;
 }
+function capLedgers() {
+  while (ledgers.size > MAX_LEDGER_SESSIONS) {
+    const oldest = ledgers.keys().next();
+    if (oldest.done) break;
+    ledgers.delete(oldest.value);
+    log.info("todo ledger evicted oldest session", { sessionId: oldest.value });
+  }
+}
 function prunePending(ledger) {
   const cutoff = Date.now() - PENDING_CREATE_TTL_MS;
   for (const [id, pending] of ledger.pendingCreates) {
@@ -349,31 +359,825 @@ function mapTool(name, input, opts) {
     if (!input) return { name: "bash", executed: false };
     const output = input?.content || input?.output || JSON.stringify(input);
     return {
-      name: "bash",
-      input: {
-        command: `printf '%s\\n' ${singleQuoteForShell(`TASK OUTPUT: ${String(output)}`)}`,
-        description: "Displaying task output"
-      },
-      executed: false
+      name: "bash",
+      input: {
+        command: `printf '%s\\n' ${singleQuoteForShell(`TASK OUTPUT: ${String(output)}`)}`,
+        description: "Displaying task output"
+      },
+      executed: false
+    };
+  }
+  if (name.startsWith("mcp__")) {
+    const parts = name.slice(5).split("__");
+    if (parts.length >= 2) {
+      const serverName = parts[0];
+      const toolName = parts.slice(1).join("_");
+      const openCodeName = `${serverName}_${toolName}`;
+      log.debug("mapping MCP tool", { original: name, mapped: openCodeName });
+      return { name: openCodeName, input, executed: true };
+    }
+  }
+  if (OPENCODE_HANDLED_TOOLS.has(name)) {
+    const mappedInput = mapToolInput(name, input);
+    const openCodeName = name.toLowerCase();
+    log.debug("mapping CLI-executed tool", { name, openCodeName });
+    return { name: openCodeName, input: mappedInput, executed: true };
+  }
+  return { name, input, executed: true };
+}
+
+// src/accounts.ts
+import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
+import path from "path";
+var BASE_PROVIDER_ID = "claude-code";
+var DEFAULT_ACCOUNT = "default";
+var SHARED_CAPABILITY_ITEMS = [
+  "CLAUDE.md",
+  "settings.json",
+  "skills",
+  "agents",
+  "commands",
+  "plugins"
+];
+function normalizeAccountName(account) {
+  return account.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveAccounts(value) {
+  if (!Array.isArray(value)) return null;
+  const accounts = value.map((account) => normalizeAccountName(String(account))).filter(Boolean);
+  return Array.from(/* @__PURE__ */ new Set([DEFAULT_ACCOUNT, ...accounts]));
+}
+function accountProviderId(account) {
+  return `${BASE_PROVIDER_ID}-${normalizeAccountName(account)}`;
+}
+function accountDisplayName(account) {
+  return `Claude Code (${titleizeAccount(account)})`;
+}
+function accountModelSuffix(account) {
+  const normalized = normalizeAccountName(account);
+  return normalized === DEFAULT_ACCOUNT ? void 0 : normalized;
+}
+function accountConfigDir(account) {
+  const normalized = normalizeAccountName(account);
+  if (!normalized || normalized === DEFAULT_ACCOUNT) return void 0;
+  return `~/.claude-${normalized}`;
+}
+function expandHome(value) {
+  const home = process.env.HOME ?? process.env.USERPROFILE;
+  if (value === "~") return home ?? value;
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return home ? path.join(home, value.slice(2)) : value;
+  }
+  return value;
+}
+async function ensureAccountRuntime(account, baseCliPath) {
+  const configDir = accountConfigDir(account);
+  if (!configDir) return { cliPath: baseCliPath };
+  const expandedConfigDir = expandHome(configDir);
+  await mkdir(expandedConfigDir, { recursive: true });
+  try {
+    await ensureSharedCapabilities(expandedConfigDir);
+  } catch (err) {
+    log.warn("failed to symlink shared capabilities; continuing anyway", {
+      account,
+      configDir: expandedConfigDir,
+      error: String(err)
+    });
+  }
+  const cliPath = await writeAccountWrapper(
+    normalizeAccountName(account),
+    baseCliPath,
+    expandedConfigDir
+  );
+  return { cliPath, configDir: expandedConfigDir };
+}
+async function ensureSharedCapabilities(targetRoot) {
+  const sourceRoot = expandHome("~/.claude");
+  for (const item of SHARED_CAPABILITY_ITEMS) {
+    await ensureSharedCapabilityItem(sourceRoot, targetRoot, item);
+  }
+}
+async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
+  const source = path.join(sourceRoot, item);
+  const target = path.join(targetRoot, item);
+  let sourceStat;
+  try {
+    sourceStat = await lstat(source);
+  } catch {
+    return;
+  }
+  try {
+    const targetStat = await lstat(target);
+    if (targetStat.isSymbolicLink()) {
+      const current = await readlink(target);
+      const resolvedCurrent = path.resolve(path.dirname(target), current);
+      const resolvedSource = path.resolve(source);
+      if (resolvedCurrent === resolvedSource) return;
+    }
+    log.warn("shared Claude capability already exists; leaving untouched", {
+      item,
+      target,
+      source
+    });
+    return;
+  } catch {
+  }
+  const type = sourceStat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
+  await symlink(source, target, type);
+}
+async function writeAccountWrapper(account, baseCliPath, configDir) {
+  const cacheRoot = path.join(
+    process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
+    "opencode-claude-code-plugin"
+  );
+  const wrapperPath = path.join(cacheRoot, `claude-${account}`);
+  const suffix = `@${account}`;
+  await mkdir(cacheRoot, { recursive: true });
+  const script = `#!/usr/bin/env bash
+set -euo pipefail
+
+args=()
+while [[ $# -gt 0 ]]; do
+  if [[ "$1" == "--model" && $# -ge 2 ]]; then
+    model="$2"
+    if [[ "$model" == *${shellDoubleQuote(suffix)} ]]; then
+      model="\${model%${shellDoubleQuote(suffix)}}"
+    fi
+    args+=("$1" "$model")
+    shift 2
+  else
+    args+=("$1")
+    shift
+  fi
+done
+
+export CLAUDE_CONFIG_DIR=${shellSingleQuote(configDir)}
+exec ${shellSingleQuote(baseCliPath)} "\${args[@]}"
+`;
+  await writeFile(wrapperPath, script, "utf8");
+  await chmod(wrapperPath, 493);
+  return wrapperPath;
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function shellDoubleQuote(value) {
+  return value.replace(/[$`"\\]/g, "\\$&");
+}
+function titleizeAccount(account) {
+  return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+
+// src/cli-events.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+var RATE_LIMIT_MARKER = "\u258C **rate limit:**";
+var RATE_LIMIT_ACTION = "Enable extra usage or add credits on the account, wait for the window to reset, switch account, org or plan, or authenticate with an API key.";
+var OVERAGE_DISABLED_REASONS = {
+  overage_not_provisioned: "extra usage is not set up on this account",
+  org_level_disabled: "extra usage is disabled for your organization",
+  org_level_disabled_until: "extra usage is disabled for your organization for now",
+  out_of_credits: "the account's usage credits are spent",
+  seat_tier_level_disabled: "your seat tier does not allow extra usage",
+  member_level_disabled: "extra usage is disabled for your member account",
+  seat_tier_zero_credit_limit: "your seat tier has a zero credit limit",
+  group_zero_credit_limit: "your group has a zero credit limit",
+  member_zero_credit_limit: "your member account has a zero credit limit",
+  org_service_level_disabled: "your organization's service level does not include extra usage",
+  no_limits_configured: "no usage limits are configured for this account",
+  fetch_error: "the CLI could not read the account's usage limits"
+};
+var RATE_LIMIT_WINDOWS = {
+  five_hour: "the 5-hour window",
+  seven_day: "the 7-day window",
+  seven_day_opus: "the 7-day Opus window",
+  seven_day_sonnet: "the 7-day Sonnet window",
+  seven_day_overage_included: "the 7-day extra-usage window",
+  overage: "extra usage"
+};
+function parseRateLimitEvent(msg) {
+  if (msg.type !== "rate_limit_event") return null;
+  const info = msg.rate_limit_info;
+  if (!isRecord(info)) return null;
+  return {
+    status: str(info.status),
+    rateLimitType: str(info.rateLimitType),
+    resetsAt: num(info.resetsAt),
+    utilization: num(info.utilization),
+    isUsingOverage: info.isUsingOverage === true,
+    overageStatus: str(info.overageStatus),
+    overageResetsAt: num(info.overageResetsAt),
+    overageDisabledReason: str(info.overageDisabledReason)
+  };
+}
+function resetsAtToMs(resetsAt) {
+  if (resetsAt === void 0 || !Number.isFinite(resetsAt)) return void 0;
+  return resetsAt < 1e12 ? resetsAt * 1e3 : resetsAt;
+}
+function formatResetsAt(resetsAt) {
+  const ms = resetsAtToMs(resetsAt);
+  if (ms === void 0) return void 0;
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+}
+function rateLimitKey(info) {
+  return [
+    info.status ?? "?",
+    info.rateLimitType ?? "?",
+    info.overageStatus ?? "?",
+    info.overageDisabledReason ?? "?"
+  ].join("|");
+}
+function isRateLimitRejected(info) {
+  return info.status === "rejected" || info.overageStatus === "rejected";
+}
+function describeRateLimit(info) {
+  if (!info.status && !info.overageStatus) return null;
+  const window = info.rateLimitType ? RATE_LIMIT_WINDOWS[info.rateLimitType] ?? info.rateLimitType : void 0;
+  const resets = formatResetsAt(info.resetsAt);
+  const overageResets = formatResetsAt(info.overageResetsAt);
+  const key = rateLimitKey(info);
+  if (isRateLimitRejected(info)) {
+    const parts = [];
+    parts.push(
+      info.status === "rejected" ? `Claude Code rejected this request: you are out of usage${window ? ` in ${window}` : ""}.` : "Claude Code rejected this request: paid extra usage is not available on this account."
+    );
+    const reason = info.overageDisabledReason ? OVERAGE_DISABLED_REASONS[info.overageDisabledReason] ?? info.overageDisabledReason : void 0;
+    if (reason) parts.push(`Extra usage is unavailable because ${reason}.`);
+    const resetAt = resets ?? overageResets;
+    if (resetAt) parts.push(`Resets at ${resetAt}.`);
+    parts.push(RATE_LIMIT_ACTION);
+    const message = parts.join(" ");
+    return { key, level: "warn", message, transcript: `
+${RATE_LIMIT_MARKER} ${message}
+` };
+  }
+  if (info.status === "allowed_warning" || info.overageStatus === "allowed_warning") {
+    const used = info.utilization === void 0 ? "" : ` (${Math.round(info.utilization * 100)}% used)`;
+    return {
+      key,
+      level: "notice",
+      message: `Approaching the usage limit${window ? ` for ${window}` : ""}${used}${resets ? `, resets at ${resets}` : ""}.`,
+      transcript: null
+    };
+  }
+  return {
+    key,
+    level: "info",
+    message: `usage limits updated${window ? ` for ${window}` : ""}`,
+    transcript: null
+  };
+}
+var reportedRateLimits = /* @__PURE__ */ new Set();
+function reportRateLimitEvent(msg) {
+  const info = parseRateLimitEvent(msg);
+  if (!info) return null;
+  const report = describeRateLimit(info);
+  if (!report) return null;
+  const data = { ...info };
+  if (reportedRateLimits.has(report.key)) {
+    log.debug(report.message, data);
+    return null;
+  }
+  reportedRateLimits.add(report.key);
+  log[report.level](report.message, data);
+  return report.transcript;
+}
+var API_KEY_SOURCES = /* @__PURE__ */ new Set([
+  "ANTHROPIC_API_KEY",
+  "apiKeyHelper",
+  "/login managed key",
+  "user",
+  "project",
+  "org",
+  "temporary"
+]);
+function parseSystemInit(msg) {
+  if (msg.type !== "system" || msg.subtype !== "init") return null;
+  const raw = msg;
+  const servers = [];
+  if (Array.isArray(raw.mcp_servers)) {
+    for (const entry of raw.mcp_servers) {
+      if (!isRecord(entry)) continue;
+      servers.push({ name: str(entry.name) ?? "unknown", status: str(entry.status) ?? "unknown" });
+    }
+  }
+  return {
+    apiKeySource: str(raw.apiKeySource),
+    permissionMode: str(raw.permissionMode),
+    model: str(raw.model),
+    cliVersion: str(raw.claude_code_version),
+    toolCount: Array.isArray(raw.tools) ? raw.tools.length : 0,
+    mcpServers: servers
+  };
+}
+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's Agent SDK credit.`;
+  return ignoreAnthropicApiKey ? `${base} \`ignoreAnthropicApiKey\` is already on, so the key is not coming from the environment: check the CLI's own settings (\`claude config\`) or an \`apiKeyHelper\`.` : `${base} Set the provider option \`ignoreAnthropicApiKey: true\` to strip the key from spawns and fall back to the stored subscription auth.`;
+}
+var warnedApiKeySources = /* @__PURE__ */ new Set();
+var warnedMcpFailures = /* @__PURE__ */ new Set();
+function reportSystemInit(msg, options = {}) {
+  const info = parseSystemInit(msg);
+  if (!info) return;
+  log.info("claude session init", {
+    apiKeySource: info.apiKeySource ?? null,
+    permissionMode: info.permissionMode ?? null,
+    model: info.model ?? null,
+    cliVersion: info.cliVersion ?? null,
+    tools: info.toolCount,
+    mcpServers: info.mcpServers
+  });
+  for (const server2 of info.mcpServers) {
+    if (server2.status === "connected") continue;
+    const key2 = `${server2.name}:${server2.status}`;
+    const message = `MCP server "${server2.name}" is ${server2.status} in Claude Code; its tools are not available to the model this session.`;
+    if (warnedMcpFailures.has(key2)) {
+      log.debug(message, { server: server2.name, status: server2.status });
+      continue;
+    }
+    warnedMcpFailures.add(key2);
+    log.warn(message, { server: server2.name, status: server2.status });
+  }
+  const apiKeyMessage = apiKeySourceWarning(info.apiKeySource, options.ignoreAnthropicApiKey);
+  if (!apiKeyMessage) return;
+  const key = `${info.apiKeySource}:${options.ignoreAnthropicApiKey ? "ignored" : "passed"}`;
+  if (warnedApiKeySources.has(key)) {
+    log.debug(apiKeyMessage, { apiKeySource: info.apiKeySource });
+    return;
+  }
+  warnedApiKeySources.add(key);
+  log.warn(apiKeyMessage, { apiKeySource: info.apiKeySource });
+}
+var COMPACT_BOUNDARY_MARKER = "\u258C **context compacted:**";
+function parseCompactBoundary(msg) {
+  if (msg.type !== "system" || msg.subtype !== "compact_boundary") return null;
+  const raw = msg;
+  const meta = isRecord(raw.compact_metadata) ? raw.compact_metadata : isRecord(raw.compactMetadata) ? raw.compactMetadata : void 0;
+  return {
+    trigger: str(meta?.trigger) ?? "unknown",
+    preTokens: num(meta?.pre_tokens) ?? num(meta?.preTokens),
+    postTokens: num(meta?.post_tokens) ?? num(meta?.postTokens)
+  };
+}
+function formatCompactBoundaryNote(boundary) {
+  const how = boundary.trigger === "auto" ? "on its own" : `on a ${boundary.trigger} request`;
+  const sizes = boundary.preTokens !== void 0 && boundary.postTokens !== void 0 ? ` (${boundary.preTokens.toLocaleString("en-US")} tokens to ${boundary.postTokens.toLocaleString("en-US")})` : "";
+  return `
+${COMPACT_BOUNDARY_MARKER} Claude Code compacted its own context ${how}${sizes}. Earlier detail in this conversation is now a summary.
+`;
+}
+function reportCompactBoundary(msg) {
+  const boundary = parseCompactBoundary(msg);
+  if (!boundary) return null;
+  log.notice("claude code compacted its own context", {
+    trigger: boundary.trigger,
+    preTokens: boundary.preTokens ?? null,
+    postTokens: boundary.postTokens ?? null
+  });
+  return formatCompactBoundaryNote(boundary);
+}
+var RESULT_ERROR_MARKER = "\u258C **claude code error:**";
+var RESULT_SUBTYPES = {
+  error_max_turns: "it hit its internal turn limit before finishing",
+  error_during_execution: "it failed while running the turn",
+  error_max_budget_usd: "it hit the configured spend limit for the turn",
+  error_max_structured_output_retries: "it could not produce valid structured output"
+};
+function describeResultFailure(msg) {
+  if (msg.type !== "result") return null;
+  const subtype = msg.subtype;
+  if (!subtype || subtype === "success") return null;
+  const explanation = RESULT_SUBTYPES[subtype];
+  return explanation ? `Claude Code ended the turn with \`${subtype}\`: ${explanation}.` : `Claude Code ended the turn with \`${subtype}\`.`;
+}
+function formatResultFailureNote(message) {
+  return `
+${RESULT_ERROR_MARKER} ${message}
+`;
+}
+var STREAM_TIMEOUT_MARKER = "\u258C **stream timeout:**";
+function formatStreamTimeoutNote(silenceMs) {
+  const seconds = Math.max(1, Math.round(silenceMs / 1e3));
+  return `
+${STREAM_TIMEOUT_MARKER} The Claude Code CLI produced output and then went silent for ${seconds}s without finishing the turn, so it was closed without a result. The answer above may be incomplete.
+`;
+}
+
+// src/plan-mode-question.ts
+var QUESTION_TOOL_NAME = "question";
+var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
+var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
+var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
+var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
+var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
+var KEY_SEPARATOR = "\0";
+function isPlanModeQuestionActive(input) {
+  if (input.compactionMode) return false;
+  if (input.configured !== true) return false;
+  return input.opencodeHasQuestion;
+}
+var pendingQuestions = /* @__PURE__ */ new Map();
+function pendingKey(sessionKey2, questionToolCallId) {
+  return `${sessionKey2}${KEY_SEPARATOR}${questionToolCallId}`;
+}
+function clearExitPlanModeQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
+  for (const key of pendingQuestions.keys()) {
+    if (key.startsWith(prefix)) pendingQuestions.delete(key);
+  }
+}
+function hasExitPlanModeQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
+  return [...pendingQuestions.keys()].some((key) => key.startsWith(prefix));
+}
+function createExitPlanModeQuestionCall(sessionKey2, exitPlanModeToolUseId, plan, questionToolCallId = `exit_plan_question_${exitPlanModeToolUseId}`) {
+  pendingQuestions.set(pendingKey(sessionKey2, questionToolCallId), exitPlanModeToolUseId);
+  return {
+    toolCallId: questionToolCallId,
+    toolName: QUESTION_TOOL_NAME,
+    input: {
+      questions: [
+        {
+          header: "Plan approval",
+          question: PLAN_MODE_APPROVAL_QUESTION,
+          options: [
+            { label: "yes", description: "" },
+            { label: "no", description: "" }
+          ],
+          multiple: false,
+          custom: true
+        }
+      ]
+    },
+    text: plan ? `
+
+${plan}
+` : "\n\n"
+  };
+}
+function buildToolResultMessage(input) {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        input.approved ? {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: APPROVED_EXIT_PLAN_MODE_MESSAGE
+        } : {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: `${REJECTED_EXIT_PLAN_MODE_PREFIX}
+${input.feedback || "no"}`,
+          is_error: true
+        }
+      ]
+    }
+  });
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapToolOutput(part) {
+  const output = part?.output ?? part?.result;
+  if (typeof output === "string") return tryParseJson(output);
+  if (!output || typeof output !== "object") return output;
+  switch (output.type) {
+    case "json":
+    case "error-json":
+      return output.value;
+    case "text":
+    case "error-text":
+      return tryParseJson(String(output.value ?? ""));
+    case "execution-denied":
+      return {
+        denied: true,
+        reason: String(output.reason ?? "question rejected")
+      };
+    case "content":
+      return Array.isArray(output.value) ? output.value.map((item) => {
+        if (item?.type === "text") return item.text;
+        return JSON.stringify(item);
+      }).join("\n") : output.value;
+    default:
+      return output;
+  }
+}
+function unwrapOpencodeQuestionResult(value) {
+  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
+    return value.slice(
+      OPENCODE_QUESTION_RESULT_PREFIX.length,
+      -OPENCODE_QUESTION_RESULT_SUFFIX.length
+    );
+  }
+  return value;
+}
+function collectAnswerStrings(value) {
+  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
+  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
+  if (!value || typeof value !== "object") return [];
+  const obj = value;
+  if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
+  for (const key of ["answers", "answer", "selected", "selection", "value"]) {
+    if (key in obj) return collectAnswerStrings(obj[key]);
+  }
+  return [];
+}
+function classifyQuestionResult(part) {
+  const output = unwrapToolOutput(part);
+  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
+    return { approved: true, feedback: "" };
+  }
+  return {
+    approved: false,
+    feedback: answers.length > 0 ? answers.join("\n") : "no"
+  };
+}
+function consumeExitPlanModeQuestionResult(sessionKey2, prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type !== "tool-result" || typeof part.toolCallId !== "string") {
+        continue;
+      }
+      const key = pendingKey(sessionKey2, part.toolCallId);
+      const exitPlanModeToolUseId = pendingQuestions.get(key);
+      if (!exitPlanModeToolUseId) continue;
+      pendingQuestions.delete(key);
+      const result = classifyQuestionResult(part);
+      return buildToolResultMessage({
+        toolUseId: exitPlanModeToolUseId,
+        approved: result.approved,
+        feedback: result.feedback
+      });
+    }
+  }
+  return null;
+}
+
+// src/account-failover.ts
+var FAILOVER_MARKER = "\u258C **account failover:**";
+var ACCOUNT_FAILOVER_TOOL_CALL_PREFIX = "account_failover_";
+var KEY_SEPARATOR2 = "\0";
+var STOP_ANSWER = "stop";
+var ACCOUNT_LIMIT_PATTERNS = [
+  /third-party apps now draw from your extra usage/i,
+  /you[’'`]?ve hit your individual spend limit/i
+];
+function isAccountLimitError(input) {
+  if (input.rateLimit && isRateLimitRejected(input.rateLimit)) return true;
+  const text = input.resultText;
+  if (typeof text !== "string" || text.length === 0) return false;
+  return ACCOUNT_LIMIT_PATTERNS.some((pattern) => pattern.test(text));
+}
+var accountOverrides = /* @__PURE__ */ new Map();
+function setAccountOverride(source, target, until, now = Date.now()) {
+  const from = normalizeAccountName(source || DEFAULT_ACCOUNT);
+  const to = normalizeAccountName(target);
+  if (!to || to === from) return;
+  if (until !== void 0 && until <= now) {
+    log.notice("ignoring a failover reset time that is not in the future", {
+      source: from,
+      target: to,
+      until
+    });
+    until = void 0;
+  }
+  accountOverrides.set(from, { target: to, until });
+  log.warn(
+    `Claude account "${from}" is out of usage; this and every other session on it now runs on "${to}"${until ? ` until ${new Date(until).toISOString()}` : " until opencode restarts"}.`,
+    { source: from, target: to, until: until ?? null }
+  );
+}
+function resolveAccountOverride(source, now = Date.now()) {
+  const from = normalizeAccountName(source || DEFAULT_ACCOUNT);
+  const entry = accountOverrides.get(from);
+  if (!entry) return void 0;
+  if (entry.until !== void 0 && entry.until <= now) {
+    accountOverrides.delete(from);
+    log.notice(
+      `Claude account "${from}" should have usage again; switching back from "${entry.target}".`,
+      { source: from, target: entry.target, until: entry.until }
+    );
+    return void 0;
+  }
+  return entry.target;
+}
+function stripAccountSuffix(modelId) {
+  const at = modelId.indexOf("@");
+  return at === -1 ? modelId : modelId.slice(0, at);
+}
+async function resolveFailoverSpawn(input) {
+  const unchanged = {
+    cliPath: input.cliPath,
+    modelId: input.modelId,
+    failedOver: false
+  };
+  const source = normalizeAccountName(input.account || DEFAULT_ACCOUNT);
+  const target = resolveAccountOverride(source, input.now);
+  if (!target) return unchanged;
+  try {
+    const cliPath = target === DEFAULT_ACCOUNT ? input.baseCliPath : (await ensureAccountRuntime(target, input.baseCliPath)).cliPath;
+    return {
+      cliPath,
+      modelId: stripAccountSuffix(input.modelId),
+      target,
+      failedOver: true
+    };
+  } catch (err) {
+    log.error("failed to prepare the failover account runtime; staying put", {
+      source,
+      target,
+      error: String(err)
+    });
+    return unchanged;
+  }
+}
+function isAccountFailoverQuestionActive(input) {
+  if (input.compactionMode) return false;
+  if (input.interactive) return false;
+  if (input.childSession) return false;
+  if (input.configured === "off") return false;
+  if (input.candidates.length === 0) return false;
+  return input.opencodeHasQuestion;
+}
+function failoverCandidates(accounts, source) {
+  const from = normalizeAccountName(source || DEFAULT_ACCOUNT);
+  const out = [];
+  for (const raw of accounts ?? []) {
+    const name = normalizeAccountName(String(raw));
+    if (!name || name === from || out.includes(name)) continue;
+    out.push(name);
+  }
+  return out;
+}
+var pendingQuestions2 = /* @__PURE__ */ new Map();
+function pendingKey2(sessionKey2, toolCallId) {
+  return `${sessionKey2}${KEY_SEPARATOR2}${toolCallId}`;
+}
+function clearAccountFailoverQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR2}`;
+  for (const key of pendingQuestions2.keys()) {
+    if (key.startsWith(prefix)) pendingQuestions2.delete(key);
+  }
+}
+function describeReset(resetsAt) {
+  return formatResetsAt(resetsAt);
+}
+function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${ACCOUNT_FAILOVER_TOOL_CALL_PREFIX}${Math.random().toString(36).slice(2, 10)}`) {
+  const source = normalizeAccountName(input.sourceAccount || DEFAULT_ACCOUNT);
+  const candidates = input.candidates.map((c) => normalizeAccountName(c));
+  const resets = describeReset(input.resetsAt);
+  const until = resets ?? "opencode restarts";
+  pendingQuestions2.set(pendingKey2(sessionKey2, toolCallId), {
+    sourceAccount: source,
+    candidates: [...candidates],
+    resetsAt: input.resetsAt
+  });
+  const question = [
+    `The Claude account "${source}" is out of usage`,
+    input.window ? ` in ${input.window}` : "",
+    resets ? `, which resets at ${resets}` : "",
+    ". Continue this task on another configured account? Leaving this unanswered waits, at no cost."
+  ].join("");
+  return {
+    toolCallId,
+    toolName: QUESTION_TOOL_NAME,
+    input: {
+      questions: [
+        {
+          header: "Account limit",
+          question,
+          options: [
+            ...candidates.map((candidate) => ({
+              label: candidate,
+              description: `Run on "${candidate}" until ${until}. The conversation is replayed as a fresh Claude session (a session cannot resume across accounts), and any MCP server configured only in "${source}"'s Claude profile will be missing.`
+            })),
+            {
+              label: STOP_ANSWER,
+              description: "End this turn now and leave the account as it is."
+            }
+          ],
+          multiple: false,
+          custom: true
+        }
+      ]
+    },
+    text: ""
+  };
+}
+function isDenied(output) {
+  return !!output && typeof output === "object" && output.denied === true;
+}
+function classify(pending, part) {
+  const output = unwrapToolOutput(part);
+  if (isDenied(output)) {
+    return {
+      kind: "stop",
+      reason: String(output.reason ?? "question rejected")
     };
   }
-  if (name.startsWith("mcp__")) {
-    const parts = name.slice(5).split("__");
-    if (parts.length >= 2) {
-      const serverName = parts[0];
-      const toolName = parts.slice(1).join("_");
-      const openCodeName = `${serverName}_${toolName}`;
-      log.debug("mapping MCP tool", { original: name, mapped: openCodeName });
-      return { name: openCodeName, input, executed: true };
+  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  if (answers.length === 0) return { kind: "stop", reason: "no answer" };
+  const picked = normalizeAccountName(answers[0]);
+  if (picked === STOP_ANSWER) {
+    return { kind: "stop", reason: "the operator chose to stop" };
+  }
+  const target = pending.candidates.find((candidate) => candidate === picked);
+  if (!target) {
+    return { kind: "stop", reason: `unrecognised answer "${answers[0]}"` };
+  }
+  return {
+    kind: "switch",
+    target,
+    sourceAccount: pending.sourceAccount,
+    resetsAt: pending.resetsAt
+  };
+}
+function consumeAccountFailoverAnswer(sessionKey2, prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type !== "tool-result" || typeof part.toolCallId !== "string") {
+        continue;
+      }
+      const key = pendingKey2(sessionKey2, part.toolCallId);
+      const pending = pendingQuestions2.get(key);
+      if (!pending) continue;
+      pendingQuestions2.delete(key);
+      return classify(pending, part);
     }
   }
-  if (OPENCODE_HANDLED_TOOLS.has(name)) {
-    const mappedInput = mapToolInput(name, input);
-    const openCodeName = name.toLowerCase();
-    log.debug("mapping CLI-executed tool", { name, openCodeName });
-    return { name: openCodeName, input: mappedInput, executed: true };
+  return null;
+}
+function formatFailoverNote(input) {
+  const resets = describeReset(input.resetsAt);
+  return `
+${FAILOVER_MARKER} "${input.sourceAccount}" is out of usage, so this conversation continues on "${input.target}" ${resets ? `until ${resets}` : "until opencode restarts"}. Claude cannot resume a session across accounts, so the thread is being replayed into a fresh one.
+`;
+}
+function formatFailoverStopNote(reason) {
+  return `
+${FAILOVER_MARKER} Staying on this account (${reason}). The turn ends here; the usage limit is unchanged.
+`;
+}
+function isFailoverPart(part) {
+  if (!part || typeof part.toolCallId !== "string") return false;
+  if (part.type !== "tool-call" && part.type !== "tool-result") return false;
+  return part.toolCallId.startsWith(ACCOUNT_FAILOVER_TOOL_CALL_PREFIX);
+}
+function stripAccountFailoverParts(prompt) {
+  let changed = false;
+  const out = [];
+  for (const message of prompt) {
+    const content = message.content;
+    if (!Array.isArray(content) || !content.some(isFailoverPart)) {
+      out.push(message);
+      continue;
+    }
+    changed = true;
+    const kept = content.filter((part) => !isFailoverPart(part));
+    if (kept.length === 0) continue;
+    out.push({ ...message, content: kept });
   }
-  return { name, input, executed: true };
+  return changed ? out : prompt;
+}
+function failoverContinuationText(target) {
+  return [
+    `The Claude account this conversation was running on hit its usage limit, so it has been moved to the "${target}" account and you are now in a fresh Claude session.`,
+    "The conversation so far is above. Continue the task from where it stopped: do not start over, do not re-plan, and do not repeat work that is already done.",
+    "Do not mention the account switch unless you are asked about it."
+  ].join(" ");
+}
+function buildFailoverContinuationPrompt(prompt, target) {
+  const stripped = stripAccountFailoverParts(prompt);
+  return [
+    ...stripped,
+    {
+      role: "user",
+      content: [{ type: "text", text: failoverContinuationText(target) }]
+    }
+  ];
+}
+function failoverUntil(resetsAt) {
+  return resetsAtToMs(resetsAt);
 }
 
 // src/cli-version.ts
@@ -381,6 +1185,17 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var cache = /* @__PURE__ */ new Map();
+var CLI_HYGIENE_ENV_VARS = [
+  "DISABLE_AUTOUPDATER",
+  "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"
+];
+function cliHygieneEnv(inherited = process.env) {
+  const filled = {};
+  for (const name of CLI_HYGIENE_ENV_VARS) {
+    if (inherited[name] === void 0) filled[name] = "1";
+  }
+  return filled;
+}
 function detectCliVersion(cliPath) {
   const cached = cache.get(cliPath);
   if (cached) return cached;
@@ -478,15 +1293,15 @@ import { unlink } from "fs/promises";
 // src/proxy-mcp.ts
 import { createServer } from "http";
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 import * as crypto from "crypto";
 import { EventEmitter } from "events";
 
 // src/tmp.ts
 import * as fs from "fs";
 import * as os from "os";
-import * as path from "path";
-var PLUGIN_TMP_DIR = path.join(
+import * as path2 from "path";
+var PLUGIN_TMP_DIR = path2.join(
   os.tmpdir(),
   `opencode-claude-code-${process.pid}`
 );
@@ -1173,7 +1988,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
         2
       );
       const hash = crypto.createHash("sha256").update(body).digest("hex").slice(0, 12);
-      const outPath = path2.join(
+      const outPath = path3.join(
         pluginTmpDir(),
         `proxy-${hash}.json`
       );
@@ -1598,187 +2413,28 @@ function resolvePendingProxyCallById(toolCallId, result) {
 }
 function rejectPendingProxyCallById(toolCallId, error) {
   const pending = pendingByCallId.get(toolCallId);
-  if (!pending) return false;
-  pendingByCallId.delete(toolCallId);
-  indexRemove(pending.sessionKey, toolCallId);
-  clearPendingTimers(pending);
-  pending.reject(error);
-  log.notice("rejected pending proxy call", {
-    sessionKey: pending.sessionKey,
-    toolCallId: pending.toolCallId,
-    toolName: pending.toolName,
-    error: error.message
-  });
-  return true;
-}
-function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
-  const s = callIdsBySession.get(sessionKey2);
-  if (!s) return 0;
-  const ids = [...s];
-  let count = 0;
-  for (const id of ids) {
-    if (rejectPendingProxyCallById(id, error)) count++;
-  }
-  return count;
-}
-
-// src/plan-mode-question.ts
-var QUESTION_TOOL_NAME = "question";
-var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
-var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
-var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
-var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
-var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
-var KEY_SEPARATOR = "\0";
-function isPlanModeQuestionActive(input) {
-  if (input.compactionMode) return false;
-  if (input.configured !== true) return false;
-  return input.opencodeHasQuestion;
-}
-var pendingQuestions = /* @__PURE__ */ new Map();
-function pendingKey(sessionKey2, questionToolCallId) {
-  return `${sessionKey2}${KEY_SEPARATOR}${questionToolCallId}`;
-}
-function clearExitPlanModeQuestions(sessionKey2) {
-  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
-  for (const key of pendingQuestions.keys()) {
-    if (key.startsWith(prefix)) pendingQuestions.delete(key);
-  }
-}
-function hasExitPlanModeQuestions(sessionKey2) {
-  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
-  return [...pendingQuestions.keys()].some((key) => key.startsWith(prefix));
-}
-function createExitPlanModeQuestionCall(sessionKey2, exitPlanModeToolUseId, plan, questionToolCallId = `exit_plan_question_${exitPlanModeToolUseId}`) {
-  pendingQuestions.set(pendingKey(sessionKey2, questionToolCallId), exitPlanModeToolUseId);
-  return {
-    toolCallId: questionToolCallId,
-    toolName: QUESTION_TOOL_NAME,
-    input: {
-      questions: [
-        {
-          header: "Plan approval",
-          question: PLAN_MODE_APPROVAL_QUESTION,
-          options: [
-            { label: "yes", description: "" },
-            { label: "no", description: "" }
-          ],
-          multiple: false,
-          custom: true
-        }
-      ]
-    },
-    text: plan ? `
-
-${plan}
-` : "\n\n"
-  };
-}
-function buildToolResultMessage(input) {
-  return JSON.stringify({
-    type: "user",
-    message: {
-      role: "user",
-      content: [
-        input.approved ? {
-          type: "tool_result",
-          tool_use_id: input.toolUseId,
-          content: APPROVED_EXIT_PLAN_MODE_MESSAGE
-        } : {
-          type: "tool_result",
-          tool_use_id: input.toolUseId,
-          content: `${REJECTED_EXIT_PLAN_MODE_PREFIX}
-${input.feedback || "no"}`,
-          is_error: true
-        }
-      ]
-    }
-  });
-}
-function tryParseJson(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-function unwrapToolOutput(part) {
-  const output = part?.output ?? part?.result;
-  if (typeof output === "string") return tryParseJson(output);
-  if (!output || typeof output !== "object") return output;
-  switch (output.type) {
-    case "json":
-    case "error-json":
-      return output.value;
-    case "text":
-    case "error-text":
-      return tryParseJson(String(output.value ?? ""));
-    case "execution-denied":
-      return {
-        denied: true,
-        reason: String(output.reason ?? "question rejected")
-      };
-    case "content":
-      return Array.isArray(output.value) ? output.value.map((item) => {
-        if (item?.type === "text") return item.text;
-        return JSON.stringify(item);
-      }).join("\n") : output.value;
-    default:
-      return output;
-  }
-}
-function unwrapOpencodeQuestionResult(value) {
-  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
-    return value.slice(
-      OPENCODE_QUESTION_RESULT_PREFIX.length,
-      -OPENCODE_QUESTION_RESULT_SUFFIX.length
-    );
-  }
-  return value;
-}
-function collectAnswerStrings(value) {
-  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
-  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
-  if (!value || typeof value !== "object") return [];
-  const obj = value;
-  if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
-  for (const key of ["answers", "answer", "selected", "selection", "value"]) {
-    if (key in obj) return collectAnswerStrings(obj[key]);
-  }
-  return [];
-}
-function classifyQuestionResult(part) {
-  const output = unwrapToolOutput(part);
-  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
-  if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
-    return { approved: true, feedback: "" };
-  }
-  return {
-    approved: false,
-    feedback: answers.length > 0 ? answers.join("\n") : "no"
-  };
-}
-function consumeExitPlanModeQuestionResult(sessionKey2, prompt) {
-  for (let i = prompt.length - 1; i >= 0; i--) {
-    const msg = prompt[i];
-    if (!Array.isArray(msg.content)) continue;
-    for (const part of msg.content) {
-      if (part?.type !== "tool-result" || typeof part.toolCallId !== "string") {
-        continue;
-      }
-      const key = pendingKey(sessionKey2, part.toolCallId);
-      const exitPlanModeToolUseId = pendingQuestions.get(key);
-      if (!exitPlanModeToolUseId) continue;
-      pendingQuestions.delete(key);
-      const result = classifyQuestionResult(part);
-      return buildToolResultMessage({
-        toolUseId: exitPlanModeToolUseId,
-        approved: result.approved,
-        feedback: result.feedback
-      });
-    }
+  if (!pending) return false;
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
+  clearPendingTimers(pending);
+  pending.reject(error);
+  log.notice("rejected pending proxy call", {
+    sessionKey: pending.sessionKey,
+    toolCallId: pending.toolCallId,
+    toolName: pending.toolName,
+    error: error.message
+  });
+  return true;
+}
+function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return 0;
+  const ids = [...s];
+  let count = 0;
+  for (const id of ids) {
+    if (rejectPendingProxyCallById(id, error)) count++;
   }
-  return null;
+  return count;
 }
 
 // src/compression-store.ts
@@ -1811,7 +2467,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 var MAX_HISTORY_EXCHANGES = 20;
 var SIDE_QUESTION_USAGE = "Usage: /btw <question>. Ask a side question about the current conversation without adding it to the main context.";
 var pendingProcesses = /* @__PURE__ */ new WeakSet();
-function isRecord(value) {
+function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var SYSTEM_REMINDER_BLOCK = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
@@ -1822,7 +2478,7 @@ function parseSideQuestionContent(content) {
   } else if (Array.isArray(content)) {
     const parts = [];
     for (const part of content) {
-      if (!isRecord(part) || part.type !== "text" || typeof part.text !== "string") return null;
+      if (!isRecord2(part) || part.type !== "text" || typeof part.text !== "string") return null;
       parts.push(part.text);
     }
     text = parts.join("\n");
@@ -1841,7 +2497,7 @@ function assistantText(content) {
   if (!Array.isArray(content)) return "";
   const parts = [];
   for (const part of content) {
-    if (isRecord(part) && part.type === "text" && typeof part.text === "string") parts.push(part.text);
+    if (isRecord2(part) && part.type === "text" && typeof part.text === "string") parts.push(part.text);
   }
   return parts.join("\n").trim();
 }
@@ -1871,9 +2527,9 @@ function dispatchSideQuestionResponse(activeProcess, line) {
   } catch {
     return false;
   }
-  if (!isRecord(message) || message.type !== "control_response") return false;
+  if (!isRecord2(message) || message.type !== "control_response") return false;
   const response = message.response;
-  if (!isRecord(response) || typeof response.request_id !== "string") return false;
+  if (!isRecord2(response) || typeof response.request_id !== "string") return false;
   return activeProcess.lineEmitter.emit(`side-question:${response.request_id}`, response);
 }
 async function requestSideQuestion(activeProcess, question, options) {
@@ -1958,7 +2614,7 @@ async function requestSideQuestion(activeProcess, question, options) {
         return;
       }
       const result = response.response;
-      if (response.subtype !== "success" || !isRecord(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
+      if (response.subtype !== "success" || !isRecord2(result) || typeof result.response !== "string" || typeof result.synthetic !== "boolean") {
         fail(new Error("Claude Code returned an invalid /btw response."));
         return;
       }
@@ -2056,7 +2712,11 @@ function cliEffortLevel(effort) {
 function claudeSpawnEnv(opts) {
   const env = {
     ...process.env,
-    TERM: "xterm-256color"
+    TERM: "xterm-256color",
+    // Pin the child to the binary whose version we detected, and keep it off
+    // non-essential network calls. Fills gaps only, so an explicit shell value
+    // survives: see `cliHygieneEnv` for why the version has to hold still.
+    ...cliHygieneEnv()
   };
   if (opts?.effort) {
     env.CLAUDE_CODE_EFFORT_LEVEL = cliEffortLevel(opts.effort);
@@ -2289,11 +2949,31 @@ async function deleteActiveProcessAndWait(key, options = {}) {
 function getClaudeSessionId(key) {
   return claudeSessions.get(key);
 }
+var MAX_CLAUDE_SESSION_ENTRIES = 64;
+function claudeSessionIsBusy(key) {
+  if (activeProcesses.has(key)) return true;
+  return getPendingProxyCalls(key).length > 0 || hasExitPlanModeQuestions(key);
+}
+function capClaudeSessions() {
+  for (const key of [...claudeSessions.keys()]) {
+    if (claudeSessions.size <= MAX_CLAUDE_SESSION_ENTRIES) return;
+    if (claudeSessionIsBusy(key)) continue;
+    log.info("claude session cap reached; releasing an idle session", {
+      sessionKey: key,
+      size: claudeSessions.size,
+      cap: MAX_CLAUDE_SESSION_ENTRIES
+    });
+    deleteClaudeSessionId(key);
+  }
+}
 function setClaudeSessionId(key, sessionId) {
+  claudeSessions.delete(key);
   claudeSessions.set(key, sessionId);
+  capClaudeSessions();
 }
 function deleteClaudeSessionId(key) {
   clearExitPlanModeQuestions(key);
+  clearAccountFailoverQuestions(key);
   const claudeSessionId = claudeSessions.get(key);
   if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
@@ -2350,6 +3030,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     systemPromptFile,
     effort,
     startedAt: Date.now(),
+    cliPath,
     cliArgs: [...cliArgs],
     unattendedLines: [],
     unattendedDropped: 0
@@ -2832,267 +3513,34 @@ async function handleBtwCommand(client, input, options = {}) {
       (idle) => idle ? "idle" : "timeout"
     )
   ]);
-  if (outcome === "inline") {
-    log.info("btw: answered inside the running turn, dropping the /btw message", {
-      sessionID: input.sessionID,
-      waitedMs: Date.now() - started
-    });
-    throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
-  }
-  log.info("btw: turn over, releasing the /btw message", {
-    sessionID: input.sessionID,
-    idle: outcome === "idle",
-    waitedMs: Date.now() - started
-  });
-  if (outcome === "timeout") {
-    showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
-    throw new BtwHandledError(BTW_TURN_TOO_LONG_MESSAGE);
-  }
-}
-
-// src/cli-events.ts
-function isRecord2(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function str(value) {
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function num(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-var RATE_LIMIT_MARKER = "\u258C **rate limit:**";
-var RATE_LIMIT_ACTION = "Enable extra usage or add credits on the account, wait for the window to reset, switch account, org or plan, or authenticate with an API key.";
-var OVERAGE_DISABLED_REASONS = {
-  overage_not_provisioned: "extra usage is not set up on this account",
-  org_level_disabled: "extra usage is disabled for your organization",
-  org_level_disabled_until: "extra usage is disabled for your organization for now",
-  out_of_credits: "the account's usage credits are spent",
-  seat_tier_level_disabled: "your seat tier does not allow extra usage",
-  member_level_disabled: "extra usage is disabled for your member account",
-  seat_tier_zero_credit_limit: "your seat tier has a zero credit limit",
-  group_zero_credit_limit: "your group has a zero credit limit",
-  member_zero_credit_limit: "your member account has a zero credit limit",
-  org_service_level_disabled: "your organization's service level does not include extra usage",
-  no_limits_configured: "no usage limits are configured for this account",
-  fetch_error: "the CLI could not read the account's usage limits"
-};
-var RATE_LIMIT_WINDOWS = {
-  five_hour: "the 5-hour window",
-  seven_day: "the 7-day window",
-  seven_day_opus: "the 7-day Opus window",
-  seven_day_sonnet: "the 7-day Sonnet window",
-  seven_day_overage_included: "the 7-day extra-usage window",
-  overage: "extra usage"
-};
-function parseRateLimitEvent(msg) {
-  if (msg.type !== "rate_limit_event") return null;
-  const info = msg.rate_limit_info;
-  if (!isRecord2(info)) return null;
-  return {
-    status: str(info.status),
-    rateLimitType: str(info.rateLimitType),
-    resetsAt: num(info.resetsAt),
-    utilization: num(info.utilization),
-    isUsingOverage: info.isUsingOverage === true,
-    overageStatus: str(info.overageStatus),
-    overageResetsAt: num(info.overageResetsAt),
-    overageDisabledReason: str(info.overageDisabledReason)
-  };
-}
-function formatResetsAt(resetsAt) {
-  if (resetsAt === void 0) return void 0;
-  const ms = resetsAt < 1e12 ? resetsAt * 1e3 : resetsAt;
-  const date = new Date(ms);
-  return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
-}
-function rateLimitKey(info) {
-  return [
-    info.status ?? "?",
-    info.rateLimitType ?? "?",
-    info.overageStatus ?? "?",
-    info.overageDisabledReason ?? "?"
-  ].join("|");
-}
-function isRateLimitRejected(info) {
-  return info.status === "rejected" || info.overageStatus === "rejected";
-}
-function describeRateLimit(info) {
-  if (!info.status && !info.overageStatus) return null;
-  const window = info.rateLimitType ? RATE_LIMIT_WINDOWS[info.rateLimitType] ?? info.rateLimitType : void 0;
-  const resets = formatResetsAt(info.resetsAt);
-  const overageResets = formatResetsAt(info.overageResetsAt);
-  const key = rateLimitKey(info);
-  if (isRateLimitRejected(info)) {
-    const parts = [];
-    parts.push(
-      info.status === "rejected" ? `Claude Code rejected this request: you are out of usage${window ? ` in ${window}` : ""}.` : "Claude Code rejected this request: paid extra usage is not available on this account."
-    );
-    const reason = info.overageDisabledReason ? OVERAGE_DISABLED_REASONS[info.overageDisabledReason] ?? info.overageDisabledReason : void 0;
-    if (reason) parts.push(`Extra usage is unavailable because ${reason}.`);
-    const resetAt = resets ?? overageResets;
-    if (resetAt) parts.push(`Resets at ${resetAt}.`);
-    parts.push(RATE_LIMIT_ACTION);
-    const message = parts.join(" ");
-    return { key, level: "warn", message, transcript: `
-${RATE_LIMIT_MARKER} ${message}
-` };
-  }
-  if (info.status === "allowed_warning" || info.overageStatus === "allowed_warning") {
-    const used = info.utilization === void 0 ? "" : ` (${Math.round(info.utilization * 100)}% used)`;
-    return {
-      key,
-      level: "notice",
-      message: `Approaching the usage limit${window ? ` for ${window}` : ""}${used}${resets ? `, resets at ${resets}` : ""}.`,
-      transcript: null
-    };
-  }
-  return {
-    key,
-    level: "info",
-    message: `usage limits updated${window ? ` for ${window}` : ""}`,
-    transcript: null
-  };
-}
-var reportedRateLimits = /* @__PURE__ */ new Set();
-function reportRateLimitEvent(msg) {
-  const info = parseRateLimitEvent(msg);
-  if (!info) return null;
-  const report = describeRateLimit(info);
-  if (!report) return null;
-  const data = { ...info };
-  if (reportedRateLimits.has(report.key)) {
-    log.debug(report.message, data);
-    return null;
-  }
-  reportedRateLimits.add(report.key);
-  log[report.level](report.message, data);
-  return report.transcript;
-}
-var API_KEY_SOURCES = /* @__PURE__ */ new Set([
-  "ANTHROPIC_API_KEY",
-  "apiKeyHelper",
-  "/login managed key",
-  "user",
-  "project",
-  "org",
-  "temporary"
-]);
-function parseSystemInit(msg) {
-  if (msg.type !== "system" || msg.subtype !== "init") return null;
-  const raw = msg;
-  const servers = [];
-  if (Array.isArray(raw.mcp_servers)) {
-    for (const entry of raw.mcp_servers) {
-      if (!isRecord2(entry)) continue;
-      servers.push({ name: str(entry.name) ?? "unknown", status: str(entry.status) ?? "unknown" });
-    }
-  }
-  return {
-    apiKeySource: str(raw.apiKeySource),
-    permissionMode: str(raw.permissionMode),
-    model: str(raw.model),
-    cliVersion: str(raw.claude_code_version),
-    toolCount: Array.isArray(raw.tools) ? raw.tools.length : 0,
-    mcpServers: servers
-  };
-}
-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's Agent SDK credit.`;
-  return ignoreAnthropicApiKey ? `${base} \`ignoreAnthropicApiKey\` is already on, so the key is not coming from the environment: check the CLI's own settings (\`claude config\`) or an \`apiKeyHelper\`.` : `${base} Set the provider option \`ignoreAnthropicApiKey: true\` to strip the key from spawns and fall back to the stored subscription auth.`;
-}
-var warnedApiKeySources = /* @__PURE__ */ new Set();
-var warnedMcpFailures = /* @__PURE__ */ new Set();
-function reportSystemInit(msg, options = {}) {
-  const info = parseSystemInit(msg);
-  if (!info) return;
-  log.info("claude session init", {
-    apiKeySource: info.apiKeySource ?? null,
-    permissionMode: info.permissionMode ?? null,
-    model: info.model ?? null,
-    cliVersion: info.cliVersion ?? null,
-    tools: info.toolCount,
-    mcpServers: info.mcpServers
-  });
-  for (const server2 of info.mcpServers) {
-    if (server2.status === "connected") continue;
-    const key2 = `${server2.name}:${server2.status}`;
-    const message = `MCP server "${server2.name}" is ${server2.status} in Claude Code; its tools are not available to the model this session.`;
-    if (warnedMcpFailures.has(key2)) {
-      log.debug(message, { server: server2.name, status: server2.status });
-      continue;
-    }
-    warnedMcpFailures.add(key2);
-    log.warn(message, { server: server2.name, status: server2.status });
-  }
-  const apiKeyMessage = apiKeySourceWarning(info.apiKeySource, options.ignoreAnthropicApiKey);
-  if (!apiKeyMessage) return;
-  const key = `${info.apiKeySource}:${options.ignoreAnthropicApiKey ? "ignored" : "passed"}`;
-  if (warnedApiKeySources.has(key)) {
-    log.debug(apiKeyMessage, { apiKeySource: info.apiKeySource });
-    return;
-  }
-  warnedApiKeySources.add(key);
-  log.warn(apiKeyMessage, { apiKeySource: info.apiKeySource });
-}
-var COMPACT_BOUNDARY_MARKER = "\u258C **context compacted:**";
-function parseCompactBoundary(msg) {
-  if (msg.type !== "system" || msg.subtype !== "compact_boundary") return null;
-  const raw = msg;
-  const meta = isRecord2(raw.compact_metadata) ? raw.compact_metadata : isRecord2(raw.compactMetadata) ? raw.compactMetadata : void 0;
-  return {
-    trigger: str(meta?.trigger) ?? "unknown",
-    preTokens: num(meta?.pre_tokens) ?? num(meta?.preTokens),
-    postTokens: num(meta?.post_tokens) ?? num(meta?.postTokens)
-  };
-}
-function formatCompactBoundaryNote(boundary) {
-  const how = boundary.trigger === "auto" ? "on its own" : `on a ${boundary.trigger} request`;
-  const sizes = boundary.preTokens !== void 0 && boundary.postTokens !== void 0 ? ` (${boundary.preTokens.toLocaleString("en-US")} tokens to ${boundary.postTokens.toLocaleString("en-US")})` : "";
-  return `
-${COMPACT_BOUNDARY_MARKER} Claude Code compacted its own context ${how}${sizes}. Earlier detail in this conversation is now a summary.
-`;
-}
-function reportCompactBoundary(msg) {
-  const boundary = parseCompactBoundary(msg);
-  if (!boundary) return null;
-  log.notice("claude code compacted its own context", {
-    trigger: boundary.trigger,
-    preTokens: boundary.preTokens ?? null,
-    postTokens: boundary.postTokens ?? null
+  if (outcome === "inline") {
+    log.info("btw: answered inside the running turn, dropping the /btw message", {
+      sessionID: input.sessionID,
+      waitedMs: Date.now() - started
+    });
+    throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
+  }
+  log.info("btw: turn over, releasing the /btw message", {
+    sessionID: input.sessionID,
+    idle: outcome === "idle",
+    waitedMs: Date.now() - started
   });
-  return formatCompactBoundaryNote(boundary);
-}
-var RESULT_ERROR_MARKER = "\u258C **claude code error:**";
-var RESULT_SUBTYPES = {
-  error_max_turns: "it hit its internal turn limit before finishing",
-  error_during_execution: "it failed while running the turn",
-  error_max_budget_usd: "it hit the configured spend limit for the turn",
-  error_max_structured_output_retries: "it could not produce valid structured output"
-};
-function describeResultFailure(msg) {
-  if (msg.type !== "result") return null;
-  const subtype = msg.subtype;
-  if (!subtype || subtype === "success") return null;
-  const explanation = RESULT_SUBTYPES[subtype];
-  return explanation ? `Claude Code ended the turn with \`${subtype}\`: ${explanation}.` : `Claude Code ended the turn with \`${subtype}\`.`;
-}
-function formatResultFailureNote(message) {
-  return `
-${RESULT_ERROR_MARKER} ${message}
-`;
+  if (outcome === "timeout") {
+    showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
+    throw new BtwHandledError(BTW_TURN_TOO_LONG_MESSAGE);
+  }
 }
 
 // src/startup-diagnostics.ts
 import { execFile as execFile2 } from "child_process";
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 import { promisify as promisify2 } from "util";
 import { fileURLToPath } from "url";
 
 // src/mcp-bridge.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
+import * as path4 from "path";
 import * as os2 from "os";
 import * as crypto2 from "crypto";
 import {
@@ -3153,14 +3601,14 @@ function deepMerge(target, source) {
 }
 function walkUp(opts) {
   const out = [];
-  let current = path3.resolve(opts.start);
+  let current = path4.resolve(opts.start);
   while (true) {
     for (const target of opts.targets) {
-      const candidate = path3.join(current, target);
+      const candidate = path4.join(current, target);
       if (opts.predicate(candidate)) out.push(candidate);
     }
-    if (opts.stop && current === path3.resolve(opts.stop)) break;
-    const parent = path3.dirname(current);
+    if (opts.stop && current === path4.resolve(opts.stop)) break;
+    const parent = path4.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -3168,28 +3616,28 @@ function walkUp(opts) {
 }
 function detectWorktree(cwd) {
   const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path3.resolve(override);
-  let current = path3.resolve(cwd);
+  if (override) return path4.resolve(override);
+  let current = path4.resolve(cwd);
   while (true) {
-    const gitPath = path3.join(current, ".git");
+    const gitPath = path4.join(current, ".git");
     try {
       if (fs3.existsSync(gitPath)) return current;
     } catch {
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
 }
 function globalConfigDir() {
-  const xdg = process.env.XDG_CONFIG_HOME ?? path3.join(os2.homedir(), ".config");
-  return path3.join(xdg, "opencode");
+  const xdg = process.env.XDG_CONFIG_HOME ?? path4.join(os2.homedir(), ".config");
+  return path4.join(xdg, "opencode");
 }
 function loadGlobalConfig() {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path3.join(dir, name);
+    const file = path4.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -3199,7 +3647,7 @@ function loadGlobalConfig() {
 function loadProjectFilesInDir(dir) {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
-    const file = path3.join(dir, name);
+    const file = path4.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -3210,7 +3658,7 @@ function dotOpencodeDirs(cwd, worktree) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path3.resolve(p);
+    const abs = path4.resolve(p);
     if (!seen.has(abs) && dirExists(abs)) {
       seen.add(abs);
       dirs.push(abs);
@@ -3226,7 +3674,7 @@ function dotOpencodeDirs(cwd, worktree) {
   }
   const home = os2.homedir();
   if (home) {
-    const homeDot = path3.join(home, ".opencode");
+    const homeDot = path4.join(home, ".opencode");
     if (dirExists(homeDot)) push(homeDot);
   }
   const envDir = process.env.OPENCODE_CONFIG_DIR;
@@ -3351,7 +3799,7 @@ function mergeOpencodeMcp(cwd, runtimeStatus) {
   const projectDirs = [];
   const seenProjectDirs = /* @__PURE__ */ new Set();
   for (const f of projectFiles) {
-    const d = path3.dirname(f);
+    const d = path4.dirname(f);
     if (!seenProjectDirs.has(d)) {
       seenProjectDirs.add(d);
       projectDirs.push(d);
@@ -3397,7 +3845,7 @@ function finishBridge(input) {
   }
   const body = JSON.stringify({ mcpServers: servers }, null, 2);
   const bodyDigest = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-  const outPath = path3.join(
+  const outPath = path4.join(
     pluginTmpDir(),
     `mcp-${bodyDigest}.json`
   );
@@ -3479,6 +3927,24 @@ async function fetchSessionDirectory(sessionID) {
     return void 0;
   }
 }
+async function fetchSessionParentId(sessionID) {
+  if (!sessionID || sessionID === "default") return void 0;
+  const client = opencodeClient;
+  if (!client?.session?.get) return void 0;
+  try {
+    const res = await client.session.get({ path: { id: sessionID } });
+    const data = res.data;
+    if (!data || typeof data !== "object") return void 0;
+    const parentID = data.parentID;
+    return typeof parentID === "string" && parentID.length > 0 ? parentID : void 0;
+  } catch (err) {
+    log.warn("failed to fetch opencode session parent", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
+}
 async function getRuntimeMcpStatus() {
   const client = opencodeClient;
   if (!client?.mcp?.status) return void 0;
@@ -3536,8 +4002,8 @@ var cachedPluginVersion;
 function pluginVersion() {
   if (cachedPluginVersion) return cachedPluginVersion;
   try {
-    const here = path4.dirname(fileURLToPath(import.meta.url));
-    const raw = fs4.readFileSync(path4.join(here, "..", "package.json"), "utf8");
+    const here = path5.dirname(fileURLToPath(import.meta.url));
+    const raw = fs4.readFileSync(path5.join(here, "..", "package.json"), "utf8");
     const version = JSON.parse(raw).version;
     cachedPluginVersion = typeof version === "string" ? version : "unknown";
   } catch {
@@ -3561,7 +4027,7 @@ var opencodeVersionProbe;
 function detectOpencodeVersion(execPath = process.execPath) {
   if (opencodeVersionProbe) return opencodeVersionProbe;
   opencodeVersionProbe = (async () => {
-    if (!path4.basename(execPath).toLowerCase().includes("opencode")) {
+    if (!path5.basename(execPath).toLowerCase().includes("opencode")) {
       log.debug("skipping opencode version probe: execPath is not opencode", { execPath });
       return void 0;
     }
@@ -3955,7 +4421,9 @@ var PLUGIN_NOTE_MARKERS = [
   COMPACT_BOUNDARY_MARKER,
   RATE_LIMIT_MARKER,
   RESULT_ERROR_MARKER,
-  DOCTOR_MARKER
+  DOCTOR_MARKER,
+  STREAM_TIMEOUT_MARKER,
+  FAILOVER_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -3968,6 +4436,7 @@ function stripPluginNotes(content) {
   return kept.length === content.length ? content : kept;
 }
 function filterSideQuestionHistory(prompt) {
+  prompt = stripAccountFailoverParts(prompt);
   let pluginCommand = false;
   const kept = prompt.filter((message) => {
     if (message.role === "user") {
@@ -4340,7 +4809,7 @@ Now continuing with the current message:
 
 // src/agent-models.ts
 import { readFile, readdir } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 
 // src/models.ts
 var PROVIDER_ID = "claude-code";
@@ -4718,11 +5187,11 @@ async function readAgentMarkdownRecords(directories) {
       const name = entry.slice(0, -3);
       if (records[name]) continue;
       try {
-        const text = await readFile(path5.join(directory, entry), "utf8");
+        const text = await readFile(path6.join(directory, entry), "utf8");
         records[name] = parseAgentFrontmatter(text);
       } catch (err) {
         log.debug("failed to read agent markdown", {
-          file: path5.join(directory, entry),
+          file: path6.join(directory, entry),
           error: String(err)
         });
       }
@@ -4734,12 +5203,12 @@ function agentDirectories(home, projectDirectory) {
   const directories = [];
   if (projectDirectory) {
     for (const name of AGENT_DIR_NAMES) {
-      directories.push(path5.join(projectDirectory, ".opencode", name));
+      directories.push(path6.join(projectDirectory, ".opencode", name));
     }
   }
   if (home) {
     for (const name of AGENT_DIR_NAMES) {
-      directories.push(path5.join(home, ".config", "opencode", name));
+      directories.push(path6.join(home, ".config", "opencode", name));
     }
   }
   return directories;
@@ -4749,13 +5218,13 @@ function agentDirectories(home, projectDirectory) {
 import * as crypto3 from "crypto";
 import * as fs5 from "fs";
 import * as os3 from "os";
-import * as path6 from "path";
+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);
-    const dir = path6.resolve(path6.dirname(here), "..", "skills");
+    const dir = path7.resolve(path7.dirname(here), "..", "skills");
     return dirExists2(dir) ? dir : null;
   } catch {
     return null;
@@ -4779,24 +5248,24 @@ function skillRoots(cwd) {
   const roots = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path6.resolve(p);
+    const abs = path7.resolve(p);
     if (seen.has(abs)) return;
     seen.add(abs);
     if (dirExists2(abs)) roots.push(abs);
   };
-  let current = path6.resolve(cwd);
+  let current = path7.resolve(cwd);
   while (true) {
-    push(path6.join(current, ".opencode", "skills"));
-    const parent = path6.dirname(current);
+    push(path7.join(current, ".opencode", "skills"));
+    const parent = path7.dirname(current);
     if (parent === current) break;
     current = parent;
   }
   const home = os3.homedir();
-  if (home) push(path6.join(home, ".opencode", "skills"));
+  if (home) push(path7.join(home, ".opencode", "skills"));
   const envDir = process.env.OPENCODE_CONFIG_DIR;
-  if (envDir) push(path6.join(envDir, "skills"));
-  const xdg = process.env.XDG_CONFIG_HOME ?? (home ? path6.join(home, ".config") : null);
-  if (xdg) push(path6.join(xdg, "opencode", "skills"));
+  if (envDir) push(path7.join(envDir, "skills"));
+  const xdg = process.env.XDG_CONFIG_HOME ?? (home ? path7.join(home, ".config") : null);
+  if (xdg) push(path7.join(xdg, "opencode", "skills"));
   return roots;
 }
 function collectSkills(root, claimed, found) {
@@ -4811,8 +5280,8 @@ function collectSkills(root, claimed, found) {
     const name = entry.name;
     if (name.startsWith(".")) continue;
     if (claimed.has(name)) continue;
-    const dir = path6.join(root, name);
-    if (!fileExists2(path6.join(dir, "SKILL.md"))) continue;
+    const dir = path7.join(root, name);
+    if (!fileExists2(path7.join(dir, "SKILL.md"))) continue;
     claimed.add(name);
     found.push({ name, dir });
   }
@@ -4836,7 +5305,7 @@ function registerBundledSkillPath(config) {
   if (!dir) return false;
   config.skills ??= {};
   const paths = config.skills.paths ??= [];
-  if (paths.some((p) => path6.resolve(p) === dir)) return false;
+  if (paths.some((p) => path7.resolve(p) === dir)) return false;
   paths.push(dir);
   return true;
 }
@@ -4852,13 +5321,13 @@ function buildSkillPluginDir(skills) {
   if (skills.length === 0) return null;
   const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
   const hash = crypto3.createHash("sha256").update(fingerprint).digest("hex").slice(0, 12);
-  const root = path6.join(pluginTmpDir(), `skills-${hash}`);
-  const manifest = path6.join(root, ".claude-plugin", "plugin.json");
+  const root = path7.join(pluginTmpDir(), `skills-${hash}`);
+  const manifest = path7.join(root, ".claude-plugin", "plugin.json");
   if (fileExists2(manifest)) return root;
   try {
     fs5.rmSync(root, { recursive: true, force: true });
-    fs5.mkdirSync(path6.join(root, ".claude-plugin"), { recursive: true });
-    fs5.mkdirSync(path6.join(root, "skills"), { recursive: true });
+    fs5.mkdirSync(path7.join(root, ".claude-plugin"), { recursive: true });
+    fs5.mkdirSync(path7.join(root, "skills"), { recursive: true });
     fs5.writeFileSync(
       manifest,
       JSON.stringify(
@@ -4872,7 +5341,7 @@ function buildSkillPluginDir(skills) {
       { encoding: "utf8", mode: 384 }
     );
     for (const skill of skills) {
-      linkSkill(skill.dir, path6.join(root, "skills", skill.name));
+      linkSkill(skill.dir, path7.join(root, "skills", skill.name));
     }
   } catch (err) {
     log.warn("failed to stage opencode skill plugin dir", {
@@ -4915,11 +5384,11 @@ import { unlink as unlink2 } from "fs/promises";
 // src/claude-session-bun.ts
 import * as os4 from "os";
 import * as fs6 from "fs";
-import * as path7 from "path";
+import * as path8 from "path";
 import { execFileSync } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 function resolveClaude(cmd = "claude") {
-  if (path7.isAbsolute(cmd) && fs6.existsSync(cmd)) return cmd;
+  if (path8.isAbsolute(cmd) && fs6.existsSync(cmd)) return cmd;
   const viaBun = Bun.which(cmd);
   if (viaBun) return viaBun;
   const isWin = os4.platform() === "win32";
@@ -4935,18 +5404,31 @@ function resolveClaude(cmd = "claude") {
   throw new Error(`Could not resolve command on PATH: ${cmd}`);
 }
 function encodeCwd(cwd) {
-  return path7.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+  return path8.resolve(cwd).replace(/[^a-zA-Z0-9]/g, "-");
+}
+function interactiveSpawnEnv(opts) {
+  return {
+    ...process.env,
+    CLAUDE_CONFIG_DIR: opts.configDir,
+    TERM: "xterm-256color",
+    // Pin the binary so a mid-session autoupdate cannot invalidate the
+    // detected version the flag gates read, and skip non-essential traffic.
+    // Fills gaps only, so a var the user exported survives untouched.
+    ...cliHygieneEnv(),
+    ...opts.ignoreAnthropicApiKey ? { ANTHROPIC_API_KEY: void 0, ANTHROPIC_AUTH_TOKEN: void 0 } : {},
+    ...opts.effort ? { CLAUDE_CODE_EFFORT_LEVEL: opts.effort } : {}
+  };
 }
 var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
-  if (!value) return path7.join(os4.homedir(), ".claude");
+  if (!value) return path8.join(os4.homedir(), ".claude");
   if (value === "~") return os4.homedir();
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path7.join(os4.homedir(), value.slice(2));
+    return path8.join(os4.homedir(), value.slice(2));
   }
-  return path7.resolve(value);
+  return path8.resolve(value);
 }
 var ClaudeSession = class {
   sessionId;
@@ -4964,11 +5446,11 @@ var ClaudeSession = class {
   signal;
   o;
   constructor(opts = {}) {
-    this.cwd = path7.resolve(opts.cwd ?? process.cwd());
+    this.cwd = path8.resolve(opts.cwd ?? process.cwd());
     this.configDir = resolveConfigDir(opts.configDir);
     this.signal = opts.signal;
     this.sessionId = randomUUID4();
-    this.jsonlPath = path7.join(
+    this.jsonlPath = path8.join(
       this.configDir,
       "projects",
       encodeCwd(this.cwd),
@@ -5023,13 +5505,13 @@ var ClaudeSession = class {
     this.lastDataAt = Date.now();
     this.proc = Bun.spawn([claude, ...args], {
       cwd: this.cwd,
-      env: {
-        ...process.env,
-        CLAUDE_CONFIG_DIR: this.o.configDir,
-        TERM: "xterm-256color",
-        ...this.o.ignoreAnthropicApiKey ? { ANTHROPIC_API_KEY: void 0, ANTHROPIC_AUTH_TOKEN: void 0 } : {},
-        ...this.o.effort ? { CLAUDE_CODE_EFFORT_LEVEL: this.o.effort } : {}
-      },
+      env: interactiveSpawnEnv({
+        // The resolved field, not `this.o.configDir`: same value (the
+        // constructor copies it in) but typed as always present.
+        configDir: this.configDir,
+        ignoreAnthropicApiKey: this.o.ignoreAnthropicApiKey,
+        effort: this.o.effort
+      }),
       terminal: {
         cols: this.o.cols,
         rows: this.o.rows,
@@ -6552,9 +7034,16 @@ var ClaudeCodeLanguageModel = class {
       cliToolCallIds: /* @__PURE__ */ new Set(),
       stripContextReminders: this.stripContextRemindersEnabled()
     });
+    const failover = await resolveFailoverSpawn({
+      account: this.config.account ?? DEFAULT_ACCOUNT,
+      baseCliPath: this.config.baseCliPath ?? this.config.cliPath,
+      cliPath: this.config.cliPath,
+      modelId: effectiveModelId
+    });
+    const cliPath = failover.cliPath;
     const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
-      detectCliVersion(this.config.cliPath),
+      detectCliVersion(cliPath),
       this.resolvePlanModeQuestion(compactionMode)
     ]);
     const systemPromptFile = buildAppendedSystemPrompt(
@@ -6565,10 +7054,10 @@ var ClaudeCodeLanguageModel = class {
       // An existing summary still carries: it is this key's prior context.
       { compressEnabled: false, compressionSummary: getCompressionSummary(sk) }
     );
-    const { model: spawnModelId, fast: fastMode } = parseModelId(effectiveModelId);
+    const { model: spawnModelId, fast: fastMode } = parseModelId(failover.modelId);
     const skillPluginDirs = await resolveSkillPluginDirs({
       cwd,
-      cliPath: this.config.cliPath,
+      cliPath,
       enabled: this.config.bridgeOpencodeSkills === true
     });
     const cliArgs = buildCliArgs({
@@ -6595,7 +7084,7 @@ var ClaudeCodeLanguageModel = class {
     });
     const { spawn: spawn2 } = await import("child_process");
     const { createInterface: createInterface2 } = await import("readline");
-    const proc = spawn2(this.config.cliPath, cliArgs, {
+    const proc = spawn2(cliPath, cliArgs, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env: claudeSpawnEnv({
@@ -6890,7 +7379,6 @@ ${plan}
   }
   async doStream(options) {
     const warnings = [];
-    const cliPath = this.config.cliPath;
     const skipPermissions = this.config.skipPermissions !== false;
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
@@ -6900,7 +7388,6 @@ ${plan}
       this.getOpencodeAgent(options.providerOptions),
       this.modelId
     );
-    const { model: spawnModelId, fast: fastMode } = parseModelId(effectiveModelId);
     const reasoningEffort = compactionMode ? void 0 : resolveAgentEffort(
       this.getOpencodeAgent(options.providerOptions),
       this.getReasoningEffort(options.providerOptions)
@@ -6917,6 +7404,17 @@ ${plan}
     const interactivePref = this.config.interactive ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT);
     const useInteractive = interactivePref && typeof globalThis.Bun?.Terminal === "function";
     const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
+    const sourceAccount = normalizeAccountName(
+      this.config.account ?? DEFAULT_ACCOUNT
+    );
+    const baseCliPath = this.config.baseCliPath ?? this.config.cliPath;
+    let failover = useInteractive || compactionMode ? { cliPath: this.config.cliPath, modelId: effectiveModelId, failedOver: false } : await resolveFailoverSpawn({
+      account: sourceAccount,
+      baseCliPath,
+      cliPath: this.config.cliPath,
+      modelId: effectiveModelId
+    });
+    let cliPath = failover.cliPath;
     const asideTransportRef = { cliPath, interactive: !!useInteractive };
     const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
     if (doctor) {
@@ -7059,15 +7557,90 @@ ${plan}
       deleteActiveProcess(sk);
       clearCompression(sk);
     }
+    const failoverAnswer = compactionMode || useInteractive ? null : consumeAccountFailoverAnswer(sk, options.prompt);
+    if (failoverAnswer?.kind === "stop") {
+      log.warn("account failover declined; ending the turn", {
+        sessionKey: sk,
+        account: sourceAccount,
+        reason: failoverAnswer.reason
+      });
+      const note = formatFailoverStopNote(failoverAnswer.reason);
+      const stream2 = new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "stream-start", warnings });
+          const id = generateId();
+          controller.enqueue({ type: "text-start", id });
+          controller.enqueue({ type: "text-delta", id, delta: note });
+          controller.enqueue({ type: "text-end", id });
+          controller.enqueue({
+            type: "error",
+            error: new Error(
+              `Claude account "${sourceAccount}" is out of usage and no other account was picked.`
+            )
+          });
+          controller.enqueue({
+            type: "finish",
+            finishReason: { unified: "error", raw: "account_limit" },
+            usage: toUsage({ input_tokens: 0, output_tokens: 0 }),
+            providerMetadata: {
+              "claude-code": {
+                path: "account-failover-stop",
+                synthetic: true,
+                usageUnavailable: true
+              }
+            }
+          });
+          controller.close();
+        }
+      });
+      return { stream: stream2, request: { body: { text: "" } } };
+    }
+    let failoverNote = null;
+    if (failoverAnswer?.kind === "switch") {
+      setAccountOverride(
+        failoverAnswer.sourceAccount,
+        failoverAnswer.target,
+        failoverUntil(failoverAnswer.resetsAt)
+      );
+      failover = await resolveFailoverSpawn({
+        account: sourceAccount,
+        baseCliPath,
+        cliPath: this.config.cliPath,
+        modelId: effectiveModelId
+      });
+      cliPath = failover.cliPath;
+      asideTransportRef.cliPath = cliPath;
+      failoverNote = formatFailoverNote({
+        sourceAccount: failoverAnswer.sourceAccount,
+        target: failoverAnswer.target,
+        resetsAt: failoverAnswer.resetsAt
+      });
+    }
+    const processForAccount = getActiveProcess(sk);
+    if (!compactionMode && !useInteractive && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
+      log.notice("claude process belongs to another account; starting fresh", {
+        sessionKey: sk,
+        was: processForAccount.cliPath,
+        now: cliPath,
+        failedOver: failover.failedOver
+      });
+      deleteActiveProcess(sk);
+      deleteClaudeSessionId(sk);
+    }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
-    const includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
+    let includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
+    if (failoverAnswer?.kind === "switch" && hasPriorConversation) {
+      includeHistoryContext = true;
+    }
+    const { model: spawnModelId, fast: fastMode } = parseModelId(failover.modelId);
     const exitPlanModeQuestionResult = compactionMode ? null : consumeExitPlanModeQuestionResult(sk, options.prompt);
     if (exitPlanModeQuestionResult) {
       log.info("sending plan approval decision to claude", { sk });
     }
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
-    const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, {
+    const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(options.prompt, failoverAnswer.target) : options.prompt;
+    const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(effectivePrompt, includeHistoryContext, {
       compactionMode,
       cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
       stripContextReminders: this.stripContextRemindersEnabled()
@@ -7088,8 +7661,23 @@ ${plan}
     );
     const [runtimeStatus, cliVersion] = await Promise.all([
       compactionMode ? Promise.resolve(void 0) : getRuntimeMcpStatus(),
-      detectCliVersion(this.config.cliPath)
+      detectCliVersion(cliPath)
     ]);
+    const failoverAccounts = failoverCandidates(
+      this.config.failoverAccounts,
+      sourceAccount
+    );
+    const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover !== "off" && !compactionMode && !useInteractive && isAccountFailoverQuestionActive({
+      configured: this.config.accountFailover,
+      candidates: failoverAccounts,
+      opencodeHasQuestion: (await loadLiveToolInfo()).hasQuestion,
+      compactionMode,
+      interactive: !!useInteractive,
+      // A subagent follows its parent's account for free, because the
+      // override is account-scoped. Asking it would put a form in a session
+      // the operator is usually not even looking at.
+      childSession: !!await fetchSessionParentId(affinity)
+    });
     log.info("doStream starting", {
       cwd,
       model: effectiveModelId,
@@ -7407,6 +7995,14 @@ ${plan}
               currentTextId = null;
             }
           };
+          if (failoverNote) {
+            controller.enqueue({
+              type: "text-delta",
+              id: startTextBlock(),
+              delta: failoverNote
+            });
+            endTextBlock();
+          }
           const reasoningIds = /* @__PURE__ */ new Map();
           const reasoningStarted = /* @__PURE__ */ new Map();
           let hadThinkingTextFromStream = false;
@@ -7441,7 +8037,12 @@ ${plan}
               resultFallbackTimer = null;
             }
           };
-          const startResultFallback = (delayMs = 6e4) => {
+          const RESULT_FALLBACK_MS = (() => {
+            const env = process.env.CLAUDE_CODE_RESULT_FALLBACK_MS;
+            const parsed = env ? Number.parseInt(env, 10) : NaN;
+            return Number.isFinite(parsed) && parsed > 0 ? parsed : 6e4;
+          })();
+          const startResultFallback = (delayMs = RESULT_FALLBACK_MS) => {
             clearFallbackTimer();
             if (!hasReceivedContent && !hasReceivedProgress || controllerClosed) return;
             resultFallbackTimer = setTimeout(() => {
@@ -7449,6 +8050,14 @@ ${plan}
               log.warn("result fallback timer fired \u2014 closing stream without result event", {
                 delayMs
               });
+              if (!autoContinueState.aborted) {
+                controller.enqueue({
+                  type: "text-delta",
+                  id: startTextBlock(),
+                  delta: formatStreamTimeoutNote(delayMs)
+                });
+                endTextBlock();
+              }
               closeHandler();
             }, delayMs);
           };
@@ -7579,6 +8188,7 @@ ${plan}
           const toolCallsById = /* @__PURE__ */ new Map();
           let resultMeta = {};
           let resultFailure;
+          let accountLimitHit = null;
           const drainBuffer = [];
           let drainTimer = null;
           const DRAIN_QUIET_MS = 100;
@@ -7630,7 +8240,7 @@ ${plan}
             } catch {
             }
           };
-          const finishWithExitPlanQuestion = (call) => {
+          const finishWithQuestionCall = (call) => {
             if (controllerClosed) return;
             endTextBlock();
             controller.enqueue({
@@ -7740,6 +8350,25 @@ ${plan}
               });
             }
             activeProcess?.pendingProxyCompletions?.clear();
+            if (accountLimitHit && failoverAskActive) {
+              const call = createAccountFailoverQuestionCall(sk, {
+                sourceAccount,
+                candidates: failoverAccounts,
+                resetsAt: accountLimitHit.resetsAt,
+                window: accountLimitHit.window
+              });
+              log.warn(
+                `Claude account "${sourceAccount}" is out of usage; asking which account to continue on.`,
+                {
+                  sessionKey: sk,
+                  candidates: failoverAccounts,
+                  toolCallId: call.toolCallId,
+                  resetsAt: accountLimitHit.resetsAt ?? null
+                }
+              );
+              finishWithQuestionCall(call);
+              return;
+            }
             const autoDecision = shouldAutoContinueIncompleteTurn(
               autoContinueState,
               {
@@ -7873,6 +8502,13 @@ ${plan}
                 }
               }
               if (msg.type === "rate_limit_event") {
+                const info = parseRateLimitEvent(msg);
+                if (info && isRateLimitRejected(info)) {
+                  accountLimitHit = {
+                    resetsAt: info.resetsAt ?? info.overageResetsAt,
+                    window: info.rateLimitType
+                  };
+                }
                 const note = reportRateLimitEvent(msg);
                 if (note) {
                   controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: note });
@@ -8036,7 +8672,7 @@ ${plan}
                         id: planId2,
                         delta: questionCall.text
                       });
-                      finishWithExitPlanQuestion(questionCall);
+                      finishWithQuestionCall(questionCall);
                       return;
                     }
                     const planId = startTextBlock();
@@ -8217,7 +8853,7 @@ ${plan}
                           id: planId2,
                           delta: questionCall.text
                         });
-                        finishWithExitPlanQuestion(questionCall);
+                        finishWithQuestionCall(questionCall);
                         return;
                       }
                       const planId = startTextBlock();
@@ -8389,6 +9025,11 @@ ${plan}
                     delta: msg.result
                   });
                 }
+                if (!accountLimitHit && msg.is_error && isAccountLimitError({
+                  resultText: typeof msg.result === "string" ? msg.result : null
+                })) {
+                  accountLimitHit = {};
+                }
                 const failure = describeResultFailure(msg);
                 if (failure) {
                   resultFailure = msg.subtype;
@@ -8812,148 +9453,6 @@ ${plan}
   }
 };
 
-// src/accounts.ts
-import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path8 from "path";
-var BASE_PROVIDER_ID = "claude-code";
-var DEFAULT_ACCOUNT = "default";
-var SHARED_CAPABILITY_ITEMS = [
-  "CLAUDE.md",
-  "settings.json",
-  "skills",
-  "agents",
-  "commands",
-  "plugins"
-];
-function normalizeAccountName(account) {
-  return account.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function resolveAccounts(value) {
-  if (!Array.isArray(value)) return null;
-  const accounts = value.map((account) => normalizeAccountName(String(account))).filter(Boolean);
-  return Array.from(/* @__PURE__ */ new Set([DEFAULT_ACCOUNT, ...accounts]));
-}
-function accountProviderId(account) {
-  return `${BASE_PROVIDER_ID}-${normalizeAccountName(account)}`;
-}
-function accountDisplayName(account) {
-  return `Claude Code (${titleizeAccount(account)})`;
-}
-function accountModelSuffix(account) {
-  const normalized = normalizeAccountName(account);
-  return normalized === DEFAULT_ACCOUNT ? void 0 : normalized;
-}
-function accountConfigDir(account) {
-  const normalized = normalizeAccountName(account);
-  if (!normalized || normalized === DEFAULT_ACCOUNT) return void 0;
-  return `~/.claude-${normalized}`;
-}
-function expandHome(value) {
-  const home = process.env.HOME ?? process.env.USERPROFILE;
-  if (value === "~") return home ?? value;
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path8.join(home, value.slice(2)) : value;
-  }
-  return value;
-}
-async function ensureAccountRuntime(account, baseCliPath) {
-  const configDir = accountConfigDir(account);
-  if (!configDir) return { cliPath: baseCliPath };
-  const expandedConfigDir = expandHome(configDir);
-  await mkdir(expandedConfigDir, { recursive: true });
-  try {
-    await ensureSharedCapabilities(expandedConfigDir);
-  } catch (err) {
-    log.warn("failed to symlink shared capabilities; continuing anyway", {
-      account,
-      configDir: expandedConfigDir,
-      error: String(err)
-    });
-  }
-  const cliPath = await writeAccountWrapper(
-    normalizeAccountName(account),
-    baseCliPath,
-    expandedConfigDir
-  );
-  return { cliPath, configDir: expandedConfigDir };
-}
-async function ensureSharedCapabilities(targetRoot) {
-  const sourceRoot = expandHome("~/.claude");
-  for (const item of SHARED_CAPABILITY_ITEMS) {
-    await ensureSharedCapabilityItem(sourceRoot, targetRoot, item);
-  }
-}
-async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path8.join(sourceRoot, item);
-  const target = path8.join(targetRoot, item);
-  let sourceStat;
-  try {
-    sourceStat = await lstat(source);
-  } catch {
-    return;
-  }
-  try {
-    const targetStat = await lstat(target);
-    if (targetStat.isSymbolicLink()) {
-      const current = await readlink(target);
-      const resolvedCurrent = path8.resolve(path8.dirname(target), current);
-      const resolvedSource = path8.resolve(source);
-      if (resolvedCurrent === resolvedSource) return;
-    }
-    log.warn("shared Claude capability already exists; leaving untouched", {
-      item,
-      target,
-      source
-    });
-    return;
-  } catch {
-  }
-  const type = sourceStat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
-  await symlink(source, target, type);
-}
-async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path8.join(
-    process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
-    "opencode-claude-code-plugin"
-  );
-  const wrapperPath = path8.join(cacheRoot, `claude-${account}`);
-  const suffix = `@${account}`;
-  await mkdir(cacheRoot, { recursive: true });
-  const script = `#!/usr/bin/env bash
-set -euo pipefail
-
-args=()
-while [[ $# -gt 0 ]]; do
-  if [[ "$1" == "--model" && $# -ge 2 ]]; then
-    model="$2"
-    if [[ "$model" == *${shellDoubleQuote(suffix)} ]]; then
-      model="\${model%${shellDoubleQuote(suffix)}}"
-    fi
-    args+=("$1" "$model")
-    shift 2
-  else
-    args+=("$1")
-    shift
-  fi
-done
-
-export CLAUDE_CONFIG_DIR=${shellSingleQuote(configDir)}
-exec ${shellSingleQuote(baseCliPath)} "\${args[@]}"
-`;
-  await writeFile(wrapperPath, script, "utf8");
-  await chmod(wrapperPath, 493);
-  return wrapperPath;
-}
-function shellSingleQuote(value) {
-  return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function shellDoubleQuote(value) {
-  return value.replace(/[$`"\\]/g, "\\$&");
-}
-function titleizeAccount(account) {
-  return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-}
-
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync4,
@@ -9148,6 +9647,9 @@ function createClaudeCode(settings = {}) {
       cwd: settings.cwd,
       account: settings.account,
       configDir: settings.configDir,
+      failoverAccounts: settings.failoverAccounts,
+      baseCliPath: settings.baseCliPath ?? cliPath,
+      accountFailover: settings.accountFailover ?? "ask",
       providerID: settings.providerID,
       skipPermissions: settings.skipPermissions ?? true,
       permissionMode: settings.permissionMode,
@@ -9274,7 +9776,11 @@ async function providerConfig(existing, providerID = PROVIDER_ID2, optionDefault
     npm: existing?.npm ?? pluginEntrypoint(),
     options: {
       ...mergedOptions,
-      ...runtime
+      ...runtime,
+      // The pre-wrapper binary, kept because `runtime` replaces `cliPath`
+      // with the account's wrapper and a failover has to build ANOTHER
+      // account's wrapper on top of the same base (src/account-failover.ts).
+      baseCliPath: cliPath
     }
     // models is intentionally omitted: both callers overwrite it with
     // configModelsForProvider(), which emits the flat config schema
@@ -9307,7 +9813,11 @@ async function expandAccountProviders(config) {
           providerID,
           {
             ...seedOptions,
-            account
+            account,
+            // The resolved list, so this account's language model can offer
+            // the others when it runs out of usage. `accounts` itself stays
+            // stripped by cleanProviderOptions.
+            failoverAccounts: accounts
           },
           accountDisplayName(account)
         ),