@khalilgharbaoui/opencode-claude-code-plugin 0.47.0 → 0.48.0

package/dist/index.d.ts

@@ -382,6 +382,13 @@ interface ClaudeCodeConfig {
      * `providerConfig`, not by the user.
      */
     baseCliPath?: string;
+    /**
+     * This spawn applies the account itself rather than through a wrapper
+     * script: it exports `CLAUDE_CONFIG_DIR` and takes the `@<account>` marker
+     * off `--model`. Set by `ensureAccountRuntime` on Windows only, where the
+     * wrapper is a shape worth avoiding (h #g221). Not a user option.
+     */
+    accountInProcess?: boolean;
     accountFailover?: AccountFailoverMode;
     providerID?: string;
     skipPermissions?: boolean;
@@ -510,6 +517,11 @@ interface ClaudeCodeProviderSettings {
     failoverAccounts?: string[];
     /** The CLI path before the per-account wrapper substitution. */
     baseCliPath?: string;
+    /**
+     * Written by the config hook on Windows, where there is no wrapper script
+     * and the spawn applies the account itself. Not a user option.
+     */
+    accountInProcess?: boolean;
     /**
      * When this account is out of usage, show the operator a form listing the
      * other configured accounts and continue the task on the pick, inside the
@@ -1051,6 +1063,10 @@ interface ClaudeStreamMessage {
         display_name?: string;
         agent_id?: string;
         description?: string;
+        /** `elicitation` only: the MCP server that asked for operator input. */
+        mcp_server_name?: string;
+        /** `elicitation` only: `form` or `url`. */
+        mode?: string;
     };
     /**
      * On an `assistant` message the CLI synthesised to report a failure: the

package/dist/index.js

@@ -154,7 +154,16 @@ function translateStreamForHost(stream, dialect = "v1") {
 import { homedir as homedir2 } from "os";
 
 // src/accounts.ts
-import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
+import {
+  chmod,
+  copyFile,
+  link,
+  lstat,
+  mkdir,
+  readlink,
+  symlink,
+  writeFile
+} from "fs/promises";
 import path from "path";
 
 // src/logger.ts
@@ -401,8 +410,9 @@ function resolveAccounts(value) {
 function accountProviderId(account) {
   return `${BASE_PROVIDER_ID}-${normalizeAccountName(account)}`;
 }
-function accountDisplayName(account) {
-  return `Claude Code (${titleizeAccount(account)})`;
+function accountDisplayName(account, tier) {
+  const name = titleizeAccount(account);
+  return `Claude Code (${tier ? `${name}, ${tier}` : name})`;
 }
 function accountModelSuffix(account) {
   const normalized = normalizeAccountName(account);
@@ -425,13 +435,14 @@ function expandHome(value) {
   }
   return value;
 }
-async function ensureAccountRuntime(account, baseCliPath) {
+async function ensureAccountRuntime(account, baseCliPath, deps = {}) {
+  const platform2 = deps.platform ?? process.platform;
   const configDir = accountConfigDir(account);
   if (!configDir) return { cliPath: baseCliPath };
   const expandedConfigDir = expandHome(configDir);
   await mkdir(expandedConfigDir, { recursive: true });
   try {
-    await ensureSharedCapabilities(expandedConfigDir);
+    await ensureSharedCapabilities(expandedConfigDir, platform2);
   } catch (err) {
     log.warn("failed to symlink shared capabilities; continuing anyway", {
       account,
@@ -439,6 +450,13 @@ async function ensureAccountRuntime(account, baseCliPath) {
       error: String(err)
     });
   }
+  if (platform2 === "win32") {
+    return {
+      cliPath: baseCliPath,
+      configDir: expandedConfigDir,
+      accountInProcess: true
+    };
+  }
   const cliPath = await writeAccountWrapper(
     normalizeAccountName(account),
     baseCliPath,
@@ -446,13 +464,21 @@ async function ensureAccountRuntime(account, baseCliPath) {
   );
   return { cliPath, configDir: expandedConfigDir };
 }
-async function ensureSharedCapabilities(targetRoot) {
+async function ensureSharedCapabilities(targetRoot, platform2) {
   const sourceRoot = expandHome("~/.claude");
   for (const item of SHARED_CAPABILITY_ITEMS) {
-    await ensureSharedCapabilityItem(sourceRoot, targetRoot, item);
+    try {
+      await ensureSharedCapabilityItem(sourceRoot, targetRoot, item, platform2);
+    } catch (err) {
+      log.warn("could not share a Claude capability with the account", {
+        item,
+        target: path.join(targetRoot, item),
+        error: String(err)
+      });
+    }
   }
 }
-async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
+async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item, platform2) {
   const source = path.join(sourceRoot, item);
   const target = path.join(targetRoot, item);
   let sourceStat;
@@ -477,8 +503,29 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     return;
   } catch {
   }
-  const type = sourceStat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
-  await symlink(source, target, type);
+  if (sourceStat.isDirectory()) {
+    await symlink(source, target, platform2 === "win32" ? "junction" : "dir");
+    return;
+  }
+  if (platform2 !== "win32") {
+    await symlink(source, target, "file");
+    return;
+  }
+  try {
+    await symlink(source, target, "file");
+    return;
+  } catch {
+  }
+  try {
+    await link(source, target);
+    return;
+  } catch {
+  }
+  await copyFile(source, target);
+  log.warn(
+    "copied a shared Claude capability into the account config dir instead of linking it; later edits to the original will not be picked up",
+    { item, target }
+  );
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
   const cacheRoot = path.join(
@@ -5067,6 +5114,9 @@ function claudeSpawnEnv(opts) {
   if (opts?.promptCacheTtl) {
     env.CLAUDE_CODE_PROMPT_CACHE_TTL = opts.promptCacheTtl;
   }
+  if (opts?.configDir) {
+    env.CLAUDE_CONFIG_DIR = opts.configDir;
+  }
   if (opts?.ignoreAnthropicApiKey) {
     delete env.ANTHROPIC_API_KEY;
     delete env.ANTHROPIC_AUTH_TOKEN;
@@ -5184,6 +5234,11 @@ function getActiveProcess(key) {
   }
   return ap;
 }
+function processBelongsToAnotherAccount(active, cliPath, configDir) {
+  if (!active) return false;
+  if (active.cliPath && active.cliPath !== cliPath) return true;
+  return !!active.configDir && active.configDir !== configDir;
+}
 function setActiveProcess(key, ap) {
   cancelIdleProcessEviction(key);
   activeProcesses.set(key, ap);
@@ -5399,7 +5454,7 @@ function invalidateOtherEffortSessions(baseKey, effort) {
     clearBackgroundTasks(key);
   }
 }
-function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort, promptCacheTtl) {
+function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash, systemPromptFile, ignoreAnthropicApiKey, effort, promptCacheTtl, configDir) {
   evictIfNeeded();
   log.info("spawning new claude process", {
     cliPath,
@@ -5407,13 +5462,14 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     cwd,
     sessionKey: sessionKey2,
     effort,
-    promptCacheTtl
+    promptCacheTtl,
+    configDir
   });
   const plan = planClaudeSpawn(cliPath, cliArgs);
   const proc = spawn(plan.file, plan.args, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort, promptCacheTtl }),
+    env: claudeSpawnEnv({ ignoreAnthropicApiKey, effort, promptCacheTtl, configDir }),
     windowsVerbatimArguments: plan.windowsVerbatimArguments
   });
   const lineEmitter = new EventEmitter3();
@@ -5428,6 +5484,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     startedAt: Date.now(),
     cliPath,
     cliArgs: [...cliArgs],
+    configDir,
     unattendedLines: [],
     unattendedDropped: 0
   };
@@ -5553,7 +5610,8 @@ function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropi
     old.systemPromptFile,
     ignoreAnthropicApiKey,
     old.effort,
-    old.promptCacheTtl
+    old.promptCacheTtl,
+    old.configDir
   );
   replacement.mcpServers = old.mcpServers;
   replacement.pendingProxyCompletions = old.pendingProxyCompletions;
@@ -5984,6 +6042,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN detected; stripping it from claude spawns (ignoreAnthropicApiKey) so requests use your subscription auth, not pay-as-you-go API billing.",
   "Code Mode execute not forwarded: no model-visible input schema",
   "Code Mode execute not forwarded: read-only permission preset",
+  "MCP server asked for operator input and was declined: a headless Claude Code session cannot prompt, so its elicitation can only be refused. Run that server's flow in Claude Code directly, or configure it not to elicit.",
   "MCP tool not routed through the proxy: another proxy tool already holds that name, and it keeps it",
   "account failover declined; ending the turn",
   "agent effort override refused: unknown level",
@@ -6020,6 +6079,8 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "cleanup-stale: error processing cache root",
   "cleanup-stale: rmSync failed",
   "continuing this conversation's claude session under the new model or effort instead of replaying it",
+  "copied a shared Claude capability into the account config dir instead of linking it; later edits to the original will not be picked up",
+  "could not share a Claude capability with the account",
   "delivering proxy results after interrupted continuation",
   "draining proxy calls queued between turns",
   "empty user content; sending sentinel to satisfy CLI",
@@ -6208,6 +6269,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   finishReason: "enum",
   hash: "enum",
   hostApi: "enum",
+  // One of `SHARED_CAPABILITY_ITEMS`: a fixed list this package defines.
+  item: "enum",
   kind: "enum",
   level: "enum",
   mode: "enum",
@@ -6517,8 +6580,8 @@ function redactLogLine(raw, context) {
   if (!parsed.data || Object.keys(parsed.data).length === 0) return head;
   return `${head} ${JSON.stringify(sanitizeLogData(parsed.data, context))}`;
 }
-function readLogTail(path13, maxBytes = BUNDLE_TAIL_BYTES) {
-  const fd = openSync(path13, "r");
+function readLogTail(path14, maxBytes = BUNDLE_TAIL_BYTES) {
+  const fd = openSync(path14, "r");
   try {
     const size = fstatSync(fd).size;
     const length = Math.min(size, maxBytes);
@@ -6698,7 +6761,10 @@ async function fetchPlanUsage(cliPath, options = {}) {
     if (support && await support(cliPath) === "unsupported") {
       return { status: "failed", error: "Plan usage is unavailable: this Claude CLI does not support headless output. Check usage in the Claude CLI directly." };
     }
-    const env = claudeSpawnEnv({ ignoreAnthropicApiKey: options.ignoreAnthropicApiKey });
+    const env = claudeSpawnEnv({
+      ignoreAnthropicApiKey: options.ignoreAnthropicApiKey,
+      configDir: options.configDir
+    });
     const stdout = await run(
       cliPath,
       ["-p", "/cost", "--output-format", "json"],
@@ -7369,7 +7435,8 @@ async function gatherDoctorReport(options) {
     });
   }
   const planUsage = wantsPlanUsage(options.argument ?? "") ? await (options.planUsageImpl ?? fetchPlanUsage)(cliPath, {
-    ignoreAnthropicApiKey: options.ignoreAnthropicApiKey
+    ignoreAnthropicApiKey: options.ignoreAnthropicApiKey,
+    configDir: options.configDir
   }) : { status: "not-requested" };
   return {
     plugin: base.plugin,
@@ -10652,7 +10719,7 @@ function spawnInteractiveProcess(opts) {
 // src/account-transcript.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { constants as fsConstants } from "fs";
-import { chmod as chmod2, copyFile, lstat as lstat2, mkdir as mkdir2 } from "fs/promises";
+import { chmod as chmod2, copyFile as copyFile2, lstat as lstat2, mkdir as mkdir2 } from "fs/promises";
 import path11 from "path";
 var transcriptPath = interactiveTranscriptPath;
 function configDirForAccount(account) {
@@ -10682,7 +10749,7 @@ async function carryTranscriptToAccount(input) {
   const target = renamed ? transcriptPath({ configDir: targetConfigDir, cwd, sessionId: carriedId }) : targetOwn;
   try {
     await mkdir2(path11.dirname(target), { recursive: true, mode: 448 });
-    await copyFile(live.file, target, fsConstants.COPYFILE_EXCL);
+    await copyFile2(live.file, target, fsConstants.COPYFILE_EXCL);
     await chmod2(target, 384);
   } catch (err) {
     return { kind: "refused", reason: "copy-failed", detail: String(err) };
@@ -10714,9 +10781,9 @@ import { readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "
 import { homedir as homedir8 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join11 } from "path";
-function readPromptFileIfPresent(path13) {
+function readPromptFileIfPresent(path14) {
   try {
-    const content = readFileSync6(path13, "utf8").trim();
+    const content = readFileSync6(path14, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -10821,9 +10888,9 @@ function extractSystemMessages(prompt) {
 }
 var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLAUDE.local.md"]);
 function userAuthoredInstructions(forwarded, opts = {}) {
-  const readFile2 = opts.readFile ?? ((path13) => {
+  const readFile2 = opts.readFile ?? ((path14) => {
     try {
-      return readFileSync6(path13, "utf8");
+      return readFileSync6(path14, "utf8");
     } catch {
       return null;
     }
@@ -10835,16 +10902,16 @@ function userAuthoredInstructions(forwarded, opts = {}) {
   }
   const seen = /* @__PURE__ */ new Set();
   for (const match of forwarded.matchAll(/^Instructions from: (.+)$/gm)) {
-    const path13 = match[1].trim();
-    if (seen.has(path13) || !isAbsolute3(path13)) continue;
-    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path13))) continue;
-    seen.add(path13);
-    const file = readFile2(path13);
+    const path14 = match[1].trim();
+    if (seen.has(path14) || !isAbsolute3(path14)) continue;
+    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path14))) continue;
+    seen.add(path14);
+    const file = readFile2(path14);
     if (!file?.trim()) continue;
     const start = match.index + match[0].length + 1;
     const content = forwarded.startsWith(file, start) ? file : forwarded.startsWith(file.trimEnd(), start) ? file.trimEnd() : null;
     if (content === null) continue;
-    out.push({ text: `Instructions from: ${path13}
+    out.push({ text: `Instructions from: ${path14}
 ${content}`, content });
   }
   return out;
@@ -10881,10 +10948,10 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path13 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path14 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync6(path13, content, { encoding: "utf8", mode: 384 });
-    return path13;
+    writeFileSync6(path14, content, { encoding: "utf8", mode: 384 });
+    return path14;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -11215,6 +11282,8 @@ _Reply with your answer to continue._
 }
 
 // src/control-request.ts
+var ELICITATION_DECLINE = { action: "decline" };
+var warnedElicitationServers = /* @__PURE__ */ new Set();
 function controlRequestBehaviorForTool(config, toolName) {
   const configured = config.controlRequestToolBehaviors;
   if (configured && toolName) {
@@ -11283,6 +11352,18 @@ function handleControlRequest(config, msg, proc) {
     }
     return true;
   }
+  if (request.subtype === "elicitation") {
+    const server2 = request.mcp_server_name || "unknown";
+    writeControlResponse(proc, requestId, { ...ELICITATION_DECLINE });
+    if (!warnedElicitationServers.has(server2)) {
+      warnedElicitationServers.add(server2);
+      log.warn(
+        "MCP server asked for operator input and was declined: a headless Claude Code session cannot prompt, so its elicitation can only be refused. Run that server's flow in Claude Code directly, or configure it not to elicit.",
+        { server: server2, mode: request.mode ?? "form" }
+      );
+    }
+    return true;
+  }
   writeControlResponse(proc, requestId, {});
   log.debug("control request acknowledged", {
     requestId,
@@ -12001,14 +12082,18 @@ var FAST_MODE_REASONS = {
   pending: "the CLI is still checking availability"
 };
 var warnedFastModeReasons = /* @__PURE__ */ new Set();
-function reportFastModeState(msg, requested) {
+function reportFastModeState(msg, requested, phase = "result") {
   const state = msg.fast_mode_state;
   if (!state) return;
   if (!requested) {
-    log.debug("fast mode state", { state });
+    log.debug("fast mode state", { state, phase });
     return;
   }
   if (state === "on") {
+    if (phase === "init") {
+      log.debug("fast mode reported on at session start", { state, phase });
+      return;
+    }
     log.info("fast mode active", { state });
     return;
   }
@@ -12503,7 +12588,7 @@ function createLineHandler(state, ctx) {
             claudeSessionId: msg.session_id
           });
         }
-        reportFastModeState(msg, ctx.fastMode);
+        reportFastModeState(msg, ctx.fastMode, "init");
         reportSystemInit(msg, {
           ignoreAnthropicApiKey: ctx.config.ignoreAnthropicApiKey
         });
@@ -13069,6 +13154,7 @@ ${plan}
       }
       if (msg.type === "result") {
         clearFallbackTimer(state);
+        reportFastModeState(msg, ctx.fastMode, "result");
         if (msg.session_id) {
           setClaudeSessionId(state.sessionKey, msg.session_id);
         }
@@ -13691,6 +13777,11 @@ var ClaudeCodeLanguageModel = class {
         interactive: !!useInteractive,
         turnStats: this.config.turnStats === true,
         ignoreAnthropicApiKey: this.config.ignoreAnthropicApiKey === true,
+        // Where the plugin applies the account itself rather than through a
+        // wrapper (`accountInProcess`, Windows), the `/cost` spawn needs the
+        // same config dir a turn gets, or it reports the default account's
+        // plan usage instead of this provider's.
+        configDir: this.config.accountInProcess ? this.config.configDir : void 0,
         // `/claude-code-doctor usage` opts into the CLI's own plan-usage
         // report; anything else here is ignored, as it always has been.
         argument: doctor.rest
@@ -13891,11 +13982,12 @@ var ClaudeCodeLanguageModel = class {
         resetsAt: failoverAnswer.resetsAt
       });
     }
+    const spawnConfigDir = this.config.accountInProcess ? this.skillBridgeSpawn(failover).configDir : void 0;
     const processForAccount = getActiveProcess(sk);
-    if (!compactionMode && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
+    if (!compactionMode && processBelongsToAnotherAccount(processForAccount, cliPath, spawnConfigDir)) {
       log.notice("claude process belongs to another account; starting fresh", {
         sessionKey: sk,
-        was: processForAccount.cliPath,
+        was: processForAccount?.cliPath,
         now: cliPath,
         failedOver: failover.failedOver
       });
@@ -13938,7 +14030,7 @@ var ClaudeCodeLanguageModel = class {
         });
         deleteClaudeSessionId(sk);
       }
-    } else if (!compactionMode && sessionBeforeAccountCheck && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
+    } else if (!compactionMode && sessionBeforeAccountCheck && processBelongsToAnotherAccount(processForAccount, cliPath, spawnConfigDir)) {
       deleteClaudeSessionId(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
@@ -14051,7 +14143,9 @@ var ClaudeCodeLanguageModel = class {
     if (this.config.forkSessions === true && !compactionMode) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
-    const { model: spawnModelId, fast: fastMode } = parseModelId(failover.modelId);
+    const { model: spawnModelId, fast: fastMode } = parseModelId(
+      this.config.accountInProcess ? stripAccountSuffix(failover.modelId) : failover.modelId
+    );
     const exitPlanModeQuestionResult = compactionMode ? null : consumeExitPlanModeQuestionResult(sk, options.prompt);
     if (exitPlanModeQuestionResult) {
       log.info("sending plan approval decision to claude", { sk });
@@ -14681,7 +14775,8 @@ var ClaudeCodeLanguageModel = class {
                 spawnSystemPromptFile,
                 self.config.ignoreAnthropicApiKey,
                 reasoningEffort,
-                promptCacheTtl
+                promptCacheTtl,
+                spawnConfigDir
               );
               ap.mcpServers = spawnMcpServers;
               state.proc = ap.proc;
@@ -15242,11 +15337,80 @@ var ClaudeCodeLanguageModel = class {
   }
 };
 
+// src/account-tier.ts
+import { readFileSync as readFileSync7 } from "fs";
+import path12 from "path";
+var ORGANIZATION_TYPE_LABELS = {
+  claude_max: "Max",
+  claude_pro: "Pro",
+  claude_team: "Team",
+  claude_enterprise: "Enterprise",
+  claude_free: "Free"
+};
+var RATE_LIMIT_TIER_LABELS = {
+  default_claude_max_5x: "5x",
+  default_claude_max_20x: "20x"
+};
+var tierCache = /* @__PURE__ */ new Map();
+function accountTierConfigDir(account) {
+  const configured = accountConfigDirPath(account);
+  if (configured) return configured;
+  const fromEnv = process.env.CLAUDE_CONFIG_DIR;
+  return fromEnv && fromEnv.trim() ? expandHome(fromEnv.trim()) : expandHome("~/.claude");
+}
+function readAccountTier(account) {
+  const normalized = normalizeAccountName(account) || DEFAULT_ACCOUNT;
+  const configDir = accountTierConfigDir(normalized);
+  const cached = tierCache.get(configDir);
+  if (cached !== void 0) return cached ?? void 0;
+  const label = readTierFromConfigDir(configDir, normalized === DEFAULT_ACCOUNT);
+  tierCache.set(configDir, label ?? null);
+  return label;
+}
+function readTierFromConfigDir(configDir, allowLegacyFallback) {
+  const candidates = [path12.join(configDir, ".claude.json")];
+  if (allowLegacyFallback) candidates.push(expandHome("~/.claude.json"));
+  for (const candidate of candidates) {
+    const oauth = readOauthAccount(candidate);
+    if (!oauth) continue;
+    const label = tierLabel(oauth);
+    if (label) return label;
+  }
+  return void 0;
+}
+function readOauthAccount(file) {
+  let raw;
+  try {
+    raw = readFileSync7(file, "utf8");
+  } catch {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const oauth = parsed.oauthAccount;
+    return oauth && typeof oauth === "object" ? oauth : void 0;
+  } catch {
+    log.debug("could not parse a Claude config file for its plan tier", { file });
+    return void 0;
+  }
+}
+function tierLabel(oauthAccount) {
+  const organizationType = oauthAccount.organizationType;
+  if (typeof organizationType !== "string") return void 0;
+  const base = ORGANIZATION_TYPE_LABELS[organizationType];
+  if (!base) return void 0;
+  if (base !== "Max") return base;
+  const rateLimitTier = oauthAccount.organizationRateLimitTier;
+  const multiple = typeof rateLimitTier === "string" ? RATE_LIMIT_TIER_LABELS[rateLimitTier] : void 0;
+  return multiple ? `${base} ${multiple}` : base;
+}
+
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync5,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
   writeFileSync as writeFileSync7
@@ -15273,7 +15437,7 @@ function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync7(cfg, "utf8"));
+    const json = JSON.parse(readFileSync8(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -15294,7 +15458,7 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync7(join13(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync8(join13(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
@@ -15306,7 +15470,7 @@ function markerPath() {
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync7(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync8(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -15363,7 +15527,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync7(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync8(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -15382,7 +15546,7 @@ function cleanupOne(cacheRoot, ourDir) {
   const cachePkgJson = join13(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync7(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync8(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
       writeFileSync7(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
@@ -15462,7 +15626,7 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path12 from "path";
+import path13 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -15491,7 +15655,7 @@ function toV1Session(info) {
   if (!info || typeof info !== "object") return void 0;
   const session = info;
   const root = session.location?.directory;
-  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path12.resolve(root, session.subpath) : root : void 0;
+  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path13.resolve(root, session.subpath) : root : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {
@@ -15683,7 +15847,7 @@ function planV2Providers(seedSettings, defaultProxyTools) {
     return {
       info: {
         id: providerID,
-        name: accountDisplayName(account),
+        name: accountDisplayName(account, readAccountTier(account)),
         activation: "enabled",
         package: V2_PLUGIN_PACKAGE,
         settings: {
@@ -16221,7 +16385,7 @@ async function expandAccountProviders(config) {
             // stripped by cleanProviderOptions.
             failoverAccounts: accounts
           },
-          accountDisplayName(account)
+          accountDisplayName(account, readAccountTier(account))
         ),
         models: configModelsForProvider(
           existing?.models ?? seed?.models ?? {},