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

package/dist/index.d.ts

@@ -435,6 +435,8 @@ interface ClaudeCodeConfig {
     resumeAfterRestart?: boolean;
     /** Carry a conversation's Claude session over when its model or effort changes. Default true. */
     resumeAcrossModelChanges?: boolean;
+    /** Carry a conversation's Claude transcript over on an account switch. Default true. */
+    crossAccountResume?: boolean;
     logging?: LoggingConfig;
 }
 interface LoggingConfig {
@@ -856,6 +858,30 @@ interface ClaudeCodeProviderSettings {
      * false` turns this off too.
      */
     resumeAcrossModelChanges?: boolean;
+    /**
+     * Continue the same Claude conversation when it moves to another account,
+     * instead of replaying the whole thread as text into a fresh session there.
+     * Default `true`; it does nothing at all on a single-account install.
+     *
+     * An account is a `CLAUDE_CONFIG_DIR`, and a conversation is one transcript
+     * file inside it, so the move is a file copy into the target account's own
+     * `projects/<encoded cwd>/` plus the `--resume` that already exists. Claude
+     * Code 2.1.288 resumes a copied transcript with its context intact, resolves
+     * a session by FILENAME, and appends to the copy without touching the
+     * original (h #g218).
+     *
+     * Every refusal falls back to the replay and says which in the log: no
+     * transcript to carry, something that is not a plain file at the target
+     * path, or a copy that failed. The source transcript is never moved,
+     * deleted or written to, and an existing file is never overwritten (the
+     * carry takes a fresh session id instead).
+     *
+     * What was measured is the file layout, with a second config dir holding a
+     * copy of the same credentials; whether a different Anthropic account's
+     * token answers a conversation produced under another one is not yet
+     * verified live. Set `false` to keep the replay.
+     */
+    crossAccountResume?: boolean;
     /**
      * Routing for Claude's built-in `WebSearch` tool.
      *

package/dist/index.js

@@ -1490,7 +1490,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 +1601,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) }]
     }
   ];
 }
@@ -5994,6 +5994,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",
@@ -6091,6 +6092,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 +6137,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   emitted: "flag",
   enabled: "flag",
   executed: "flag",
+  failedOver: "flag",
+  renamed: "flag",
   isUsingOverage: "flag",
   hadProxyActivity: "flag",
   hadReasoning: "flag",
@@ -6513,8 +6517,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(path13, maxBytes = BUNDLE_TAIL_BYTES) {
+  const fd = openSync(path13, "r");
   try {
     const size = fstatSync(fd).size;
     const length = Math.min(size, maxBytes);
@@ -9127,6 +9131,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 +10649,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, 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 copyFile(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(path13) {
   try {
-    const content = readFileSync6(path12, "utf8").trim();
+    const content = readFileSync6(path13, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -10749,9 +10821,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 ?? ((path13) => {
     try {
-      return readFileSync6(path12, "utf8");
+      return readFileSync6(path13, "utf8");
     } catch {
       return null;
     }
@@ -10763,16 +10835,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 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);
     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: ${path13}
 ${content}`, content });
   }
   return out;
@@ -10809,10 +10881,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 path13 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync6(path12, content, { encoding: "utf8", mode: 384 });
-    return path12;
+    writeFileSync6(path13, content, { encoding: "utf8", mode: 384 });
+    return path13;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -13828,12 +13900,51 @@ var ClaudeCodeLanguageModel = class {
         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 && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
       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 +13990,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 +14012,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
@@ -13946,7 +14057,11 @@ var ClaudeCodeLanguageModel = class {
       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,
@@ -14628,7 +14743,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.`,
@@ -15346,7 +15462,7 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path11 from "path";
+import path12 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -15375,7 +15491,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 ? path12.resolve(root, session.subpath) : root : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {
@@ -15934,6 +16050,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,