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

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(
@@ -1490,7 +1537,7 @@ function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${A
           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.`
+              description: input.carryTranscript === false ? `Run on "${candidate}" until ${until}. The conversation is replayed as a fresh Claude session, and any MCP server configured only in "${source}"'s Claude profile will be missing.` : `Run on "${candidate}" until ${until}. The conversation continues where it stopped if its Claude transcript can be carried across, and is replayed as a fresh Claude session if it cannot; either way, any MCP server configured only in "${source}"'s Claude profile will be missing.`
             })),
             {
               label: STOP_ANSWER,
@@ -1601,20 +1648,20 @@ function stripAccountFailoverParts(prompt) {
   }
   return changed ? out : prompt;
 }
-function failoverContinuationText(target) {
+function failoverContinuationText(target, resumed = false) {
   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.",
+    resumed ? `The Claude account this conversation was running on hit its usage limit, so it has been moved to the "${target}" account. This is the same conversation, continued: everything you already know still stands.` : `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) {
+function buildFailoverContinuationPrompt(prompt, target, resumed = false) {
   const stripped = stripAccountFailoverParts(prompt);
   return [
     ...stripped,
     {
       role: "user",
-      content: [{ type: "text", text: failoverContinuationText(target) }]
+      content: [{ type: "text", text: failoverContinuationText(target, resumed) }]
     }
   ];
 }
@@ -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",
@@ -5994,6 +6053,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "btw: a turn is running but no claude process appeared for it",
   "btw: early aside failed; the message will ask again",
   "cannot interrupt this transport; waiting for the turn to end",
+  "carried this conversation's claude transcript to the other account",
   "carrying the claude conversation over to the new session key",
   "claude --version output unparseable",
   "claude account is out of usage; the turn ends with a note",
@@ -6019,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",
@@ -6091,6 +6153,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "remote URL images are not supported by Claude CLI, skipping",
   "replaying stdout the child emitted between turns",
   "replaying the conversation as text: no claude session was available to continue",
+  "replaying this conversation as text on the other account",
   "result fallback timer fired \u2014 closing stream without result event",
   "resuming the claude session from before the restart instead of replaying it",
   "shared Claude capability already exists; leaving untouched",
@@ -6135,6 +6198,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   emitted: "flag",
   enabled: "flag",
   executed: "flag",
+  failedOver: "flag",
+  renamed: "flag",
   isUsingOverage: "flag",
   hadProxyActivity: "flag",
   hadReasoning: "flag",
@@ -6204,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",
@@ -6513,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(path12, maxBytes = BUNDLE_TAIL_BYTES) {
-  const fd = openSync(path12, "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);
@@ -6694,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"],
@@ -7365,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,
@@ -9127,6 +9198,14 @@ function classifyScreen(text) {
   }
   return null;
 }
+function interactiveTranscriptPath(opts) {
+  return path10.join(
+    resolveConfigDir(opts.configDir),
+    "projects",
+    encodeCwd(path10.resolve(opts.cwd)),
+    `${opts.sessionId}.jsonl`
+  );
+}
 function configDirEnv(configDir) {
   return configDir ? { CLAUDE_CONFIG_DIR: configDir } : {};
 }
@@ -10637,14 +10716,74 @@ function spawnInteractiveProcess(opts) {
   return ap;
 }
 
+// src/account-transcript.ts
+import { randomUUID as randomUUID6 } from "crypto";
+import { constants as fsConstants } from "fs";
+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) {
+  const normalized = normalizeAccountName(account || DEFAULT_ACCOUNT);
+  return resolveConfigDir(
+    normalized === DEFAULT_ACCOUNT ? void 0 : accountConfigDirPath(normalized)
+  );
+}
+async function carryTranscriptToAccount(input) {
+  const { sessionId, cwd, targetConfigDir } = input;
+  const targetOwn = transcriptPath({ configDir: targetConfigDir, cwd, sessionId });
+  const targetOwnStat = await statTranscript(targetOwn);
+  if (targetOwnStat.kind === "other") {
+    return { kind: "refused", reason: "target-not-a-file", detail: targetOwn };
+  }
+  let live;
+  for (const dir of dedupe2([targetConfigDir, ...input.accountConfigDirs])) {
+    const candidate = transcriptPath({ configDir: dir, cwd, sessionId });
+    const stat = candidate === targetOwn ? targetOwnStat : await statTranscript(candidate);
+    if (stat.kind !== "file") continue;
+    if (!live || stat.size > live.size) live = { file: candidate, size: stat.size };
+  }
+  if (!live) return { kind: "refused", reason: "no-transcript-anywhere" };
+  if (live.file === targetOwn) return { kind: "already-there", sessionId };
+  const renamed = targetOwnStat.kind === "file";
+  const carriedId = renamed ? (input.newSessionId ?? randomUUID6)() : sessionId;
+  const target = renamed ? transcriptPath({ configDir: targetConfigDir, cwd, sessionId: carriedId }) : targetOwn;
+  try {
+    await mkdir2(path11.dirname(target), { recursive: true, mode: 448 });
+    await copyFile2(live.file, target, fsConstants.COPYFILE_EXCL);
+    await chmod2(target, 384);
+  } catch (err) {
+    return { kind: "refused", reason: "copy-failed", detail: String(err) };
+  }
+  return { kind: "carried", sessionId: carriedId, from: live.file, to: target, renamed };
+}
+async function statTranscript(file) {
+  try {
+    const stat = await lstat2(file);
+    return stat.isFile() ? { kind: "file", size: stat.size } : { kind: "other", size: 0 };
+  } catch {
+    return { kind: "none", size: 0 };
+  }
+}
+function dedupe2(dirs) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const dir of dirs) {
+    const resolved = path11.resolve(dir);
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    out.push(resolved);
+  }
+  return out;
+}
+
 // src/prompts.ts
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir8 } from "os";
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join11 } from "path";
-function readPromptFileIfPresent(path12) {
+function readPromptFileIfPresent(path14) {
   try {
-    const content = readFileSync6(path12, "utf8").trim();
+    const content = readFileSync6(path14, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -10749,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 ?? ((path12) => {
+  const readFile2 = opts.readFile ?? ((path14) => {
     try {
-      return readFileSync6(path12, "utf8");
+      return readFileSync6(path14, "utf8");
     } catch {
       return null;
     }
@@ -10763,16 +10902,16 @@ function userAuthoredInstructions(forwarded, opts = {}) {
   }
   const seen = /* @__PURE__ */ new Set();
   for (const match of forwarded.matchAll(/^Instructions from: (.+)$/gm)) {
-    const path12 = match[1].trim();
-    if (seen.has(path12) || !isAbsolute3(path12)) continue;
-    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path12))) continue;
-    seen.add(path12);
-    const file = readFile2(path12);
+    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: ${path12}
+    out.push({ text: `Instructions from: ${path14}
 ${content}`, content });
   }
   return out;
@@ -10809,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 path12 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID6()}.md`);
+  const path14 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync6(path12, content, { encoding: "utf8", mode: 384 });
-    return path12;
+    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;
@@ -11143,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) {
@@ -11211,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,
@@ -11929,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;
   }
@@ -12431,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
         });
@@ -12997,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);
         }
@@ -13619,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
@@ -13819,21 +13982,61 @@ 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
       });
       deleteActiveProcess(sk);
+    }
+    let conversationOnTarget = false;
+    const multiAccount = (this.config.failoverAccounts?.length ?? 0) > 1;
+    const sessionBeforeAccountCheck = getClaudeSessionId(sk);
+    if (!compactionMode && multiAccount && this.config.crossAccountResume !== false && sessionBeforeAccountCheck) {
+      const carry = await carryTranscriptToAccount({
+        sessionId: sessionBeforeAccountCheck,
+        cwd,
+        targetConfigDir: resolveConfigDir(this.skillBridgeSpawn(failover).configDir),
+        // Every account's own directory, plus this model's configured one:
+        // `configDir` is an option, so an account's directory is not always
+        // the `~/.claude-<name>` the name alone would build.
+        accountConfigDirs: [
+          ...(this.config.failoverAccounts ?? []).map(configDirForAccount),
+          resolveConfigDir(this.config.configDir)
+        ]
+      });
+      if (carry.kind === "carried" || carry.kind === "already-there") {
+        if (carry.sessionId !== sessionBeforeAccountCheck) {
+          setClaudeSessionId(sk, carry.sessionId);
+        }
+        conversationOnTarget = true;
+        if (carry.kind === "carried") {
+          log.notice("carried this conversation's claude transcript to the other account", {
+            sessionKey: sk,
+            renamed: carry.renamed,
+            sessionId: carry.sessionId,
+            failedOver: failover.failedOver
+          });
+        }
+      } else if (!getActiveProcess(sk)) {
+        log.notice("replaying this conversation as text on the other account", {
+          sessionKey: sk,
+          reason: carry.reason,
+          failedOver: failover.failedOver
+        });
+        deleteClaudeSessionId(sk);
+      }
+    } else if (!compactionMode && sessionBeforeAccountCheck && processBelongsToAnotherAccount(processForAccount, cliPath, spawnConfigDir)) {
       deleteClaudeSessionId(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
     let includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
-    if (failoverAnswer?.kind === "switch" && hasPriorConversation) {
+    if (failoverAnswer?.kind === "switch" && hasPriorConversation && !conversationOnTarget) {
       includeHistoryContext = true;
     }
     let forkFromClaudeSessionId;
@@ -13879,12 +14082,12 @@ var ClaudeCodeLanguageModel = class {
     let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
-      const transcriptPath = (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
         cliPath,
-        transcriptPath,
+        transcriptPath: transcriptPath2,
         onRefused: (reason) => {
           replayReason = reason;
         }
@@ -13901,7 +14104,7 @@ var ClaudeCodeLanguageModel = class {
           sessionKey: sk,
           prompt: options.prompt,
           cliPath,
-          transcriptPath,
+          transcriptPath: transcriptPath2,
           // `claudeSessionIsWriting`, not `getActiveProcess`: this walks every
           // sibling key, and that one refreshes LRU order and cancels idle
           // timers on everything it touches (the same reason the fork lookup
@@ -13940,13 +14143,19 @@ 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 });
     }
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
-    const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(options.prompt, failoverAnswer.target) : options.prompt;
+    const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(
+      options.prompt,
+      failoverAnswer.target,
+      conversationOnTarget
+    ) : options.prompt;
     const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(effectivePrompt, includeHistoryContext, {
       compactionMode,
       compactionInstructions: useInteractive && compactionMode ? extractSystemMessages(effectivePrompt).join("\n\n") : void 0,
@@ -14566,7 +14775,8 @@ var ClaudeCodeLanguageModel = class {
                 spawnSystemPromptFile,
                 self.config.ignoreAnthropicApiKey,
                 reasoningEffort,
-                promptCacheTtl
+                promptCacheTtl,
+                spawnConfigDir
               );
               ap.mcpServers = spawnMcpServers;
               state.proc = ap.proc;
@@ -14628,7 +14838,8 @@ var ClaudeCodeLanguageModel = class {
                 candidates: failoverAccounts,
                 resetsAt: state.accountLimitHit?.resetsAt,
                 window: state.accountLimitHit?.window,
-                reason: state.accountLimitHit || !state.accountBlock ? void 0 : describeAccountBlock(state.accountBlock)
+                reason: state.accountLimitHit || !state.accountBlock ? void 0 : describeAccountBlock(state.accountBlock),
+                carryTranscript: self.config.crossAccountResume !== false
               });
               log.warn(
                 `Claude account "${sourceAccount}" ${state.accountLimitHit || !state.accountBlock ? "is out of usage" : `cannot serve (${state.accountBlock})`}; asking which account to continue on.`,
@@ -15126,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
@@ -15157,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(
@@ -15178,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;
@@ -15190,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;
@@ -15247,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;
   }
@@ -15266,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");
@@ -15346,7 +15626,7 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path11 from "path";
+import path13 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -15375,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 ? path11.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) {
@@ -15567,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: {
@@ -15934,6 +16214,7 @@ function createClaudeCode(settings = {}) {
       forkSessions: settings.forkSessions === true,
       resumeAfterRestart: settings.resumeAfterRestart !== false,
       resumeAcrossModelChanges: settings.resumeAcrossModelChanges !== false,
+      crossAccountResume: settings.crossAccountResume !== false,
       transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
@@ -16104,7 +16385,7 @@ async function expandAccountProviders(config) {
             // stripped by cleanProviderOptions.
             failoverAccounts: accounts
           },
-          accountDisplayName(account)
+          accountDisplayName(account, readAccountTier(account))
         ),
         models: configModelsForProvider(
           existing?.models ?? seed?.models ?? {},