@khalilgharbaoui/opencode-claude-code-plugin 0.54.2 → 0.55.0

package/dist/index.js

@@ -1623,6 +1623,9 @@ function resolveAccountOverride(source, now = Date.now()) {
   }
   return entry.target;
 }
+function clearAccountOverride(source) {
+  accountOverrides.delete(normalizeAccountName(source || DEFAULT_ACCOUNT));
+}
 function stripAccountSuffix(modelId) {
   const at = modelId.indexOf("@");
   return at === -1 ? modelId : modelId.slice(0, at);
@@ -1671,6 +1674,15 @@ function failoverCandidates(accounts, source, groups) {
   }
   return out;
 }
+function isAccountKnownUnavailable(account, now = Date.now()) {
+  if (resolveAccountOverride(account, now) !== void 0) return true;
+  return recallAccountLimit(account, now).resetsAt !== void 0;
+}
+function nextAutoFailoverAccount(candidates, tried, now = Date.now()) {
+  return candidates.find(
+    (account) => !tried.has(account) && !isAccountKnownUnavailable(account, now)
+  );
+}
 var pendingQuestions2 = /* @__PURE__ */ new Map();
 function pendingKey2(sessionKey2, toolCallId) {
   return `${sessionKey2}${KEY_SEPARATOR2}${toolCallId}`;
@@ -1797,6 +1809,13 @@ function formatFailoverNote(input) {
 ${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 formatAutoFailoverNote(input) {
+  const resets = describeReset(input.resetsAt);
+  const arrival = input.carried ? "The conversation continues where it stopped." : "The conversation is replayed into a fresh Claude session there.";
+  return `
+${FAILOVER_MARKER} "${input.failedAccount}" ${input.reason ?? "is out of usage"}, so this turn moved to "${input.target}" automatically and stays there until ${resets ?? "opencode restarts"}. ${arrival}
+`;
+}
 function formatFailoverStopNote(reason) {
   return `
 ${FAILOVER_MARKER} Staying on this account (${reason}). The turn ends here; the usage limit is unchanged.
@@ -6391,6 +6410,79 @@ function tailIsReplyOnly(history, from) {
   return true;
 }
 
+// src/conversation-gap.ts
+var served = /* @__PURE__ */ new Map();
+var servedSeq = 0;
+var MAX_SERVED_CONVERSATIONS = 64;
+function recordServedConversation(sessionKey2, prompt) {
+  const chain = conversationDigests(prompt, { assistantContent: false });
+  if (chain.length === 0) return;
+  served.delete(sessionKey2);
+  served.set(sessionKey2, { chain, seq: ++servedSeq });
+  while (served.size > MAX_SERVED_CONVERSATIONS) {
+    const oldest = served.keys().next();
+    if (oldest.done) break;
+    served.delete(oldest.value);
+  }
+}
+function forgetServedConversation(sessionKey2) {
+  served.delete(sessionKey2);
+}
+function moveServedConversation(fromKey, toKey) {
+  const record = served.get(fromKey);
+  if (!record) return;
+  served.delete(fromKey);
+  served.delete(toKey);
+  served.set(toKey, { ...record, seq: ++servedSeq });
+}
+function findMissedMessages(sessionKey2, prompt) {
+  const record = served.get(sessionKey2);
+  if (!record) return null;
+  const messages = prompt;
+  let lastAssistant = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") {
+      lastAssistant = i;
+      break;
+    }
+  }
+  if (lastAssistant < 0) return null;
+  const history = [];
+  for (let i = 0; i <= lastAssistant; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool") continue;
+    const [entry] = conversationDigests([msg], { assistantContent: false });
+    history.push({ index: i, role: entry.role, digest: entry.digest });
+  }
+  const recorded = record.chain;
+  if (recorded.length === 0 || recorded.length > history.length) return null;
+  for (let i = 0; i < recorded.length; i++) {
+    if (recorded[i].role !== history[i].role) return null;
+    if (recorded[i].digest !== history[i].digest) return null;
+  }
+  let firstUser = -1;
+  for (let i = recorded.length; i < history.length; i++) {
+    if (history[i].role === "user") {
+      firstUser = i;
+      break;
+    }
+  }
+  if (firstUser < 0) return null;
+  const from = history[firstUser].index;
+  const missed = messages.slice(from, lastAssistant + 1);
+  let userMessages = 0;
+  for (let i = firstUser; i < history.length; i++) {
+    if (history[i].role === "user") userMessages++;
+  }
+  log.debug("this claude session missed part of the conversation", {
+    sessionKey: sessionKey2,
+    recorded: recorded.length,
+    missed: missed.length,
+    userMessages
+  });
+  return { messages: missed, userMessages };
+}
+
 // src/session-resume-store.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync3, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir6 } from "os";
@@ -7321,6 +7413,7 @@ function deleteClaudeSessionId(key) {
   if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
   forgetForkFingerprint(key);
+  forgetServedConversation(key);
   forgetResumePoint(key);
 }
 function transferClaudeSession(fromKey, toKey) {
@@ -7332,6 +7425,7 @@ function transferClaudeSession(fromKey, toKey) {
   setClaudeSessionId(toKey, claudeSessionId);
   moveResumePoint(fromKey, toKey);
   moveForkFingerprint(fromKey, toKey);
+  moveServedConversation(fromKey, toKey);
   clearExitPlanModeQuestions(fromKey);
   clearAccountFailoverQuestions(fromKey);
   clearSubagentDispatchQuestions(fromKey);
@@ -7975,12 +8069,14 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "agent prompt cache ttl refused: unknown value",
   "auto-continuation stopped",
   "auto-continuing incomplete claude result",
+  "automatic account switch skipped an account whose runtime could not be prepared",
   "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 cannot serve this turn; continuing it on the next account automatically",
   "claude account is out of usage; the turn ends with a note",
   "claude already registers a different skill under this name; not bridging ours",
   "claude cli < 2.1.142 detected; Opus 4.7 thinking summaries unavailable. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
@@ -8054,6 +8150,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "interactiveBypass is ignored: skipPermissions governs the interactive transport too",
   "malformed data URI, skipping file part",
   "no active process to respawn (start watchdog); ending turn",
+  "no configured account could take this turn; it ends here",
   "no proxyTools entry was recognised; nothing will be proxied this turn",
   "no stdout after envelope write; respawning claude process to resume conversation",
   "opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction",
@@ -8083,6 +8180,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 the messages this claude session missed: the conversation continued under another session key",
   "replaying this conversation as text on the other account",
   "replaying this conversation rather than carrying it across accounts",
   "result fallback timer fired \u2014 closing stream without result event",
@@ -8534,8 +8632,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(path15, maxBytes = BUNDLE_TAIL_BYTES) {
-  const fd = openSync(path15, "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);
@@ -9837,8 +9935,10 @@ function clipWithMarker(text, max) {
 \u2026[truncated ${text.length - max} chars]`;
 }
 var MAX_REPLAY_MESSAGE_CHARS = 2e3;
-var MAX_REPLAY_LAST_REPLY_CHARS = 12e3;
 var MAX_REPLAY_HEAD_CHARS = 1e3;
+var MAX_REPLAY_RECENT_MESSAGES = 6;
+var MAX_REPLAY_RECENT_MESSAGE_CHARS = 12e3;
+var MAX_REPLAY_TOTAL_CHARS = 18e4;
 function clipMiddle(text, max) {
   if (text.length <= max) return text;
   const head = Math.min(Math.floor(max / 4), MAX_REPLAY_HEAD_CHARS);
@@ -9902,39 +10002,58 @@ ${clipWithMarker(
   }
   return { text: lines.join("\n"), toolResultCount };
 }
+function isConversationMessage(msg) {
+  return msg.role === "user" || msg.role === "assistant" || msg.role === "tool";
+}
 function compactConversationHistory(prompt, opts = {}) {
   const mode = opts.mode ?? "fresh-session";
   prompt = filterSideQuestionHistory(prompt);
   if (mode === "compaction") {
     return buildCompactionHistory(prompt);
   }
-  const conversationMessages = prompt.filter(
-    (m) => m.role === "user" || m.role === "assistant" || m.role === "tool"
-  );
+  if (opts.messages) {
+    const run = filterSideQuestionHistory(opts.messages).filter(isConversationMessage);
+    return run.length === 0 ? null : renderReplay(run);
+  }
+  const conversationMessages = prompt.filter(isConversationMessage);
   if (conversationMessages.length <= 1) {
     return null;
   }
-  const historyParts = [];
-  let lastAssistant = -1;
-  for (let i = conversationMessages.length - 2; i >= 0; i--) {
-    if (conversationMessages[i].role === "assistant") {
-      lastAssistant = i;
-      break;
-    }
-  }
-  for (let i = 0; i < conversationMessages.length - 1; i++) {
-    const msg = conversationMessages[i];
+  return renderReplay(conversationMessages.slice(0, -1));
+}
+function renderReplay(messages) {
+  const entries = [];
+  let total = 0;
+  let rank = 0;
+  let omitted = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
     const role = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : "Tool";
     const { text } = renderMessageContentForCompaction(msg);
-    if (text.trim()) {
-      const max = i === lastAssistant ? MAX_REPLAY_LAST_REPLY_CHARS : MAX_REPLAY_MESSAGE_CHARS;
-      historyParts.push(`${role}: ${clipMiddle(text, max)}`);
+    if (!text.trim()) continue;
+    const max = rank < MAX_REPLAY_RECENT_MESSAGES ? MAX_REPLAY_RECENT_MESSAGE_CHARS : MAX_REPLAY_MESSAGE_CHARS;
+    rank++;
+    const entry = `${role}: ${clipMiddle(text, max)}`;
+    if (total + entry.length > MAX_REPLAY_TOTAL_CHARS) {
+      omitted = i + 1;
+      break;
     }
+    entries.push(entry);
+    total += entry.length + 2;
   }
-  if (historyParts.length === 0) {
-    return null;
+  if (entries.length === 0) return null;
+  entries.reverse();
+  if (omitted > 0) {
+    log.info("replay bounded: the oldest messages were dropped", {
+      omitted,
+      kept: entries.length,
+      chars: total
+    });
+    entries.unshift(
+      `[${omitted} earlier message${omitted === 1 ? "" : "s"} omitted: the replay is capped at ${MAX_REPLAY_TOTAL_CHARS} characters]`
+    );
   }
-  return historyParts.join("\n\n");
+  return entries.join("\n\n");
 }
 function buildCompactionHistory(prompt) {
   const entries = [];
@@ -10038,6 +10157,27 @@ ${historyContext}
 
 Now continuing with the current message:
 
+`
+      });
+    }
+  } else if (opts.missed && opts.missed.length > 0) {
+    const missed = compactConversationHistory(prompt, { messages: opts.missed });
+    if (missed) {
+      log.info("including the messages this claude session missed", {
+        messages: opts.missed.length,
+        chars: missed.length
+      });
+      content.push({
+        type: "text",
+        text: `<missed_conversation>
+The conversation continued under another opencode agent or model while this session was not asked. These are the messages exchanged since your last reply, replayed as text. They are part of this conversation: decisions and plans made there stand, and work done there is done.
+
+${missed}
+
+</missed_conversation>
+
+Now continuing with the current message:
+
 `
       });
     }
@@ -12313,9 +12453,9 @@ import { readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "
 import { homedir as homedir11 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join15 } from "path";
-function readPromptFileIfPresent(path15) {
+function readPromptFileIfPresent(path14) {
   try {
-    const content = readFileSync9(path15, "utf8").trim();
+    const content = readFileSync9(path14, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -12433,9 +12573,9 @@ function extractSystemMessages(prompt) {
 }
 var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLAUDE.local.md"]);
 function userAuthoredInstructions(forwarded, opts = {}) {
-  const readFile3 = opts.readFile ?? ((path15) => {
+  const readFile3 = opts.readFile ?? ((path14) => {
     try {
-      return readFileSync9(path15, "utf8");
+      return readFileSync9(path14, "utf8");
     } catch {
       return null;
     }
@@ -12447,16 +12587,16 @@ function userAuthoredInstructions(forwarded, opts = {}) {
   }
   const seen = /* @__PURE__ */ new Set();
   for (const match of forwarded.matchAll(/^Instructions from: (.+)$/gm)) {
-    const path15 = match[1].trim();
-    if (seen.has(path15) || !isAbsolute3(path15)) continue;
-    if (CLAUDE_NATIVE_INSTRUCTION_FILES.has(basename2(path15))) continue;
-    seen.add(path15);
-    const file = readFile3(path15);
+    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 = readFile3(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: ${path15}
+    out.push({ text: `Instructions from: ${path14}
 ${content}`, content });
   }
   return out;
@@ -12493,10 +12633,10 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join15(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path14 = join15(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync8(path15, content, { encoding: "utf8", mode: 384 });
-    return path15;
+    writeFileSync8(path14, content, { encoding: "utf8", mode: 384 });
+    return path14;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -14514,6 +14654,7 @@ ${plan}
           resultText: msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
         }));
         const limitErrorReply = limitFromReply && ctx.usageLimitNoteActive;
+        const autoFailoverReply = (limitFromReply || accountBlockKind(msg) !== null) && ctx.autoFailoverTarget() !== void 0;
         const compactionApiError = ctx.compactionMode && (apiErrorReply || typeof msg.error === "string");
         if (limitFromReply) {
           state.accountLimitHit ??= recallAccountLimit(ctx.sourceAccount);
@@ -14535,7 +14676,7 @@ ${plan}
         }
         for (const block2 of msg.message.content) {
           if (block2.type === "text" && block2.text) {
-            if (limitErrorReply) continue;
+            if (limitErrorReply || autoFailoverReply) continue;
             if (compactionApiError) {
               state.compactionFailureText ??= block2.text;
               continue;
@@ -14763,9 +14904,11 @@ ${plan}
         })) {
           state.accountLimitHit = recallAccountLimit(ctx.sourceAccount);
         }
+        const autoFailoverResult = msg.is_error === true && (!!state.accountLimitHit || !!state.accountBlock) && ctx.autoFailoverTarget() !== void 0;
         state.usageLimitNote = ctx.usageLimitNoteActive && !!state.accountLimitHit && // An expired login or a billing hold writes its own note just below
         // and says what to run; two notes about one failure is one too many.
-        !state.accountBlock && msg.is_error === true;
+        !state.accountBlock && msg.is_error === true && // Moved to another account: that account's answer is this turn's.
+        !autoFailoverResult;
         const compactionFailure = ctx.compactionMode && (msg.is_error === true || typeof msg.subtype === "string" && msg.subtype !== "success");
         if (compactionFailure) {
           if (typeof msg.result === "string" && msg.result.trim()) {
@@ -14774,7 +14917,7 @@ ${plan}
           state.resultFailure ??= state.accountBlock ?? (state.accountLimitHit ? "usage_limit" : void 0) ?? (typeof msg.subtype === "string" && msg.subtype !== "success" ? msg.subtype : "error");
         }
         if (!state.currentTextId && msg.is_error && !compactionFailure && // Already on screen from the reply frame, word for word.
-        !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
+        !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && !autoFailoverResult && typeof msg.result === "string" && msg.result.trim().length > 0) {
           const errId = state.startTextBlock();
           state.controller.enqueue({
             type: "text-delta",
@@ -14788,14 +14931,14 @@ ${plan}
         if (state.accountBlock && msg.is_error) {
           state.resultFailure ??= state.accountBlock;
           const offeringSwitch = ctx.failoverAskActive;
-          if (!compactionFailure) {
+          if (!compactionFailure && !autoFailoverResult) {
             state.controller.enqueue({
               type: "text-delta",
               id: state.startTextBlock(),
               delta: formatAccountBlockNote({
                 kind: state.accountBlock,
                 account: ctx.sourceAccount,
-                configDir: ctx.config.configDir,
+                configDir: ctx.accountConfigDir,
                 offeringSwitch,
                 // Read only when the form is not taking the turn, which is the
                 // default: moving the work by hand is then the operator's only
@@ -14814,7 +14957,7 @@ ${plan}
         const failure = describeResultFailure(msg);
         if (failure) {
           state.resultFailure = msg.subtype;
-          if (!compactionFailure) {
+          if (!compactionFailure && !autoFailoverResult) {
             state.controller.enqueue({
               type: "text-delta",
               id: state.startTextBlock(),
@@ -15312,12 +15455,93 @@ var ClaudeCodeLanguageModel = class {
    * because which method opencode used is not in them.
    */
   async streamTurn(options, mode) {
-    const result = await this.runModelChain(options, mode);
+    const result = await this.runAccountFailover(options, mode);
     return {
       ...result,
       stream: translateStreamForHost(result.stream, this.config.hostApi ?? "v1")
     };
   }
+  /**
+   * Run the turn, moving the same request to the next eligible configured
+   * account when the one it ran on is out of usage or cannot serve
+   * (`accountFailover: "auto"`). The single wiring point for the automatic
+   * switch, and outside `runModelChain` on purpose: an account switch starts
+   * that account's own model chain from the top.
+   *
+   * Anything but `"auto"` is `runModelChain` and one `await`, so `"off"` and
+   * `"ask"` are exactly what they were. With `"auto"`, the attempt that failed
+   * decides the switch itself (`completeResult` sets `run.switchTo` and closes
+   * its stream without a `finish`), and the next attempt's prologue makes the
+   * switch the form's pick would have made. This only splices the attempts
+   * into one caller turn: one `stream-start`, and the `finish` of whichever
+   * attempt did not switch.
+   *
+   * The bound is `run.tried`, as it is `tried` for the model chain: every
+   * account spawned or switched to goes in, and none in it is picked again.
+   *
+   * Cancelling the returned stream is a stop, for every attempt: this loop is
+   * the plugin starting more work on the caller's behalf, so a caller that
+   * has gone away must reach all of it. Each attempt gets a signal that the
+   * caller's own `abortSignal` and a `cancel()` both abort, and the loop
+   * starts no further account once either has happened.
+   */
+  async runAccountFailover(options, mode) {
+    if (this.config.accountFailover !== "auto") return this.runModelChain(options, mode);
+    const self = this;
+    const run = { tried: /* @__PURE__ */ new Set() };
+    const cancelled2 = new AbortController();
+    const attemptOptions = {
+      ...options,
+      abortSignal: options.abortSignal ? AbortSignal.any([options.abortSignal, cancelled2.signal]) : cancelled2.signal
+    };
+    const stopped = () => attemptOptions.abortSignal.aborted;
+    let inner = await this.runModelChain(attemptOptions, mode, run);
+    const request = inner.request;
+    let reader;
+    const stream = new ReadableStream({
+      async start(controller) {
+        let started2 = false;
+        try {
+          for (; ; ) {
+            reader = inner.stream.getReader();
+            try {
+              for (; ; ) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                if (value.type === "stream-start") {
+                  if (started2) continue;
+                  started2 = true;
+                }
+                controller.enqueue(value);
+              }
+            } finally {
+              reader.releaseLock();
+            }
+            if (!run.switchTo) break;
+            if (stopped()) {
+              log.info("turn stopped before the automatic account switch; not switching", {
+                target: run.switchTo.target
+              });
+              break;
+            }
+            inner = await self.runModelChain(attemptOptions, mode, run);
+          }
+        } catch (error) {
+          if (!stopped()) controller.enqueue({ type: "error", error });
+        } finally {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+      },
+      async cancel(reason) {
+        cancelled2.abort(reason);
+        await reader?.cancel(reason).catch(() => void 0);
+      }
+    });
+    return { stream, request };
+  }
   /**
    * Run the turn, moving to the next model in the fallback chain if the one
    * it started on is refused. The single wiring point for `src/model-fallback.ts`.
@@ -15336,14 +15560,14 @@ var ClaudeCodeLanguageModel = class {
    * and an exhausted chain leaves the last attempt un-armed so its error
    * surfaces exactly as it does today.
    */
-  async runModelChain(options, mode) {
+  async runModelChain(options, mode, accountRun) {
     const agent = this.getOpencodeAgent(options);
     const chain = this.isCompactionCall(options) ? [] : resolveFallbackChain(agent, resolveAgentModel(agent, this.modelId));
-    if (chain.length === 0) return this.doStreamForHost(options, void 0, mode);
+    if (chain.length === 0) return this.doStreamForHost(options, void 0, mode, accountRun);
     const self = this;
     const tried = /* @__PURE__ */ new Set();
     let attempt = { armed: true };
-    let inner = await this.doStreamForHost(options, attempt, mode);
+    let inner = await this.doStreamForHost(options, attempt, mode, accountRun);
     const request = inner.request;
     const stream = new ReadableStream({
       async start(controller) {
@@ -15413,7 +15637,7 @@ var ClaudeCodeLanguageModel = class {
               modelOverride: next,
               armed: nextFallbackModel(chain, tried) !== void 0
             };
-            inner = await self.doStreamForHost(options, attempt, mode);
+            inner = await self.doStreamForHost(options, attempt, mode, accountRun);
           }
         } catch (error) {
           controller.enqueue({ type: "error", error });
@@ -15427,8 +15651,10 @@ var ClaudeCodeLanguageModel = class {
     });
     return { stream, request };
   }
-  async doStreamForHost(options, attempt, mode = "stream") {
+  async doStreamForHost(options, attempt, mode = "stream", accountRun) {
     const warnings = [];
+    const autoSwitch = accountRun?.switchTo;
+    if (accountRun) accountRun.switchTo = void 0;
     const turnAbort = watchTurnAbort(options.abortSignal);
     const abortedBeforeWork = (stage) => {
       log.info("abort before the turn asked claude for work; nothing spawned", {
@@ -15668,12 +15894,17 @@ var ClaudeCodeLanguageModel = class {
       });
     }
     const hasPriorConversation = options.prompt.filter((m) => m.role === "user" || m.role === "assistant").length > 1;
-    if (!hasPriorConversation) {
+    if (!hasPriorConversation && !autoSwitch) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
       clearCompression(sk);
     }
-    const failoverAnswer = compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
+    const failoverAnswer = autoSwitch ? {
+      kind: "switch",
+      target: autoSwitch.target,
+      sourceAccount: autoSwitch.sourceAccount,
+      resetsAt: autoSwitch.resetsAt
+    } : compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
       sourceAccount,
       candidates: failoverCandidates(
         this.config.failoverAccounts,
@@ -15731,13 +15962,84 @@ var ClaudeCodeLanguageModel = class {
         cliPath: this.config.cliPath,
         modelId: effectiveModelId
       });
+      while (autoSwitch && accountRun && failover.target !== failoverAnswer.target) {
+        log.notice("automatic account switch skipped an account whose runtime could not be prepared", {
+          sessionKey: sk,
+          target: failoverAnswer.target
+        });
+        const next = nextAutoFailoverAccount(
+          failoverCandidates(this.config.failoverAccounts, sourceAccount, groups),
+          accountRun.tried
+        );
+        if (!next) {
+          clearAccountOverride(failoverAnswer.sourceAccount);
+          log.warn("no configured account could take this turn; it ends here", {
+            sessionKey: sk,
+            account: autoSwitch.failedAccount,
+            cause: autoSwitch.cause
+          });
+          const note = mode === "generate" ? null : autoSwitch.cause === "usage_limit" ? formatUsageLimitNote({
+            sourceAccount: autoSwitch.failedAccount,
+            candidates: [],
+            resetsAt: autoSwitch.resetsAt,
+            window: autoSwitch.window
+          }) : formatAccountBlockNote({
+            kind: autoSwitch.cause,
+            account: autoSwitch.failedAccount,
+            configDir: autoSwitch.failedConfigDir,
+            offeringSwitch: false,
+            candidates: []
+          });
+          const cause = autoSwitch.cause;
+          const exhausted = new ReadableStream({
+            start(controller) {
+              controller.enqueue({ type: "stream-start", warnings });
+              if (note) {
+                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: "finish",
+                finishReason: { unified: "error", raw: cause },
+                usage: toUsage2({ input_tokens: 0, output_tokens: 0 }),
+                providerMetadata: {
+                  "claude-code": {
+                    path: "account-failover-exhausted",
+                    synthetic: true,
+                    usageUnavailable: true
+                  }
+                }
+              });
+              controller.close();
+            }
+          });
+          return { stream: exhausted, request: { body: { text: "" } } };
+        }
+        accountRun.tried.add(next);
+        failoverAnswer.target = next;
+        setAccountOverride(
+          failoverAnswer.sourceAccount,
+          next,
+          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
-      });
+      if (!autoSwitch) {
+        failoverNote = formatFailoverNote({
+          sourceAccount: failoverAnswer.sourceAccount,
+          target: failoverAnswer.target,
+          resetsAt: failoverAnswer.resetsAt
+        });
+      }
     }
     const spawnConfigDir = this.config.accountInProcess ? this.skillBridgeSpawn(failover).configDir : void 0;
     const processForAccount = getActiveProcess(sk);
@@ -15801,6 +16103,15 @@ var ClaudeCodeLanguageModel = class {
     if (failoverAnswer?.kind === "switch" && hasPriorConversation && !conversationOnTarget) {
       includeHistoryContext = true;
     }
+    if (autoSwitch && failoverAnswer?.kind === "switch" && mode !== "generate") {
+      failoverNote = formatAutoFailoverNote({
+        failedAccount: autoSwitch.failedAccount,
+        target: failoverAnswer.target,
+        resetsAt: autoSwitch.resetsAt,
+        reason: autoSwitch.reason,
+        carried: conversationOnTarget
+      });
+    }
     let accountGroupNote = null;
     if (!compactionMode && groups && accountProviders.size > 0 && includeHistoryContext && failoverAnswer?.kind !== "switch") {
       const foreign = findForeignAccountSibling({
@@ -15973,6 +16284,14 @@ var ClaudeCodeLanguageModel = class {
         messages: options.prompt.length
       });
     }
+    const missed = !compactionMode && !includeHistoryContext && failoverAnswer?.kind !== "switch" && !accountGroupNote && (!!getClaudeSessionId(sk) || !!getActiveProcess(sk)) ? findMissedMessages(sk, filterSideQuestionHistory(options.prompt)) : null;
+    if (missed) {
+      log.notice("replaying the messages this claude session missed: the conversation continued under another session key", {
+        sessionKey: sk,
+        messages: missed.messages.length,
+        userMessages: missed.userMessages
+      });
+    }
     if (this.config.forkSessions === true && !compactionMode) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
@@ -15993,7 +16312,8 @@ var ClaudeCodeLanguageModel = class {
       compactionMode,
       compactionInstructions: useInteractive && compactionMode ? extractSystemMessages(effectivePrompt).join("\n\n") : void 0,
       cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
-      stripContextReminders: this.stripContextRemindersEnabled()
+      stripContextReminders: this.stripContextRemindersEnabled(),
+      missed: missed?.messages
     });
     const ptyPlanMode = useInteractive && !compactionMode && this.config.permissionMode === "plan";
     const resolvedProxy = compactionMode ? null : ptyPlanMode ? this.resolvedProxyTools()?.filter((def) => def.name !== "write" && def.name !== "edit") ?? null : this.resolvedProxyTools();
@@ -16058,6 +16378,16 @@ var ClaudeCodeLanguageModel = class {
       // the operator is usually not even looking at.
       childSession: !!await fetchSessionParentId(affinity)
     });
+    const spawnedAccount = failover.target ?? sourceAccount;
+    accountRun?.tried.add(spawnedAccount);
+    let autoFailoverChoice;
+    const autoFailoverTarget = () => {
+      if (autoFailoverChoice === void 0) {
+        autoFailoverChoice = accountRun && !compactionMode ? nextAutoFailoverAccount(failoverAccounts, accountRun.tried) ?? null : null;
+      }
+      return autoFailoverChoice ?? void 0;
+    };
+    const limitAccount = accountRun ? spawnedAccount : sourceAccount;
     const usageLimitNoteActive = !compactionMode && mode !== "generate" && !failoverAskActive;
     let staleBuild = null;
     if (!compactionMode && mode !== "generate" && affinity !== "default") {
@@ -16698,6 +17028,9 @@ var ClaudeCodeLanguageModel = class {
                 account: failover.target ?? sourceAccount
               });
             }
+            if (!compactionMode) {
+              recordServedConversation(sk, filterSideQuestionHistory(options.prompt));
+            }
             if (deliverPendingCompletions(state)) {
               if (state.drainBuffer.length > 0) drainNow(state);
               return;
@@ -16735,6 +17068,36 @@ var ClaudeCodeLanguageModel = class {
               finishWithQuestionCall(state, call);
               return;
             }
+            const autoTarget = (state.accountLimitHit || state.accountBlock) && msg.is_error === true ? autoFailoverTarget() : void 0;
+            if (autoTarget && accountRun) {
+              const target = autoTarget;
+              accountRun.tried.add(target);
+              accountRun.switchTo = {
+                target,
+                sourceAccount,
+                failedAccount: limitAccount,
+                cause: state.accountLimitHit ? "usage_limit" : state.accountBlock,
+                resetsAt: state.accountLimitHit?.resetsAt,
+                window: state.accountLimitHit?.window,
+                failedConfigDir: self.skillBridgeSpawn(failover).configDir,
+                reason: state.accountLimitHit || !state.accountBlock ? void 0 : describeAccountBlock(state.accountBlock)
+              };
+              log.warn("claude account cannot serve this turn; continuing it on the next account automatically", {
+                sessionKey: sk,
+                account: limitAccount,
+                target,
+                cause: state.accountLimitHit ? "usage_limit" : state.accountBlock,
+                resetsAt: state.accountLimitHit?.resetsAt ?? null
+              });
+              state.endTextBlock();
+              state.controllerClosed = true;
+              cleanupTurn();
+              try {
+                controller.close();
+              } catch {
+              }
+              return;
+            }
             if (modelFallbackArmed && attempt && msg.is_error === true) {
               const refusal = state.modelRefusal ?? (state.accountLimitHit && !failoverAskActive && !state.accountBlock ? { kind: "account_limit" } : null);
               if (refusal) {
@@ -16763,19 +17126,20 @@ var ClaudeCodeLanguageModel = class {
               }
             }
             if (state.usageLimitNote) {
+              const noteCandidates = accountRun ? [] : failoverAccounts;
               log.warn("claude account is out of usage; the turn ends with a note", {
                 sessionKey: sk,
-                account: sourceAccount,
+                account: limitAccount,
                 window: state.accountLimitHit?.window ?? null,
                 resetsAt: state.accountLimitHit?.resetsAt ?? null,
-                candidates: failoverAccounts
+                candidates: noteCandidates
               });
               controller.enqueue({
                 type: "text-delta",
                 id: state.startTextBlock(),
                 delta: formatUsageLimitNote({
-                  sourceAccount,
-                  candidates: failoverAccounts,
+                  sourceAccount: limitAccount,
+                  candidates: noteCandidates,
                   resetsAt: state.accountLimitHit?.resetsAt,
                   window: state.accountLimitHit?.window,
                   resetsText: state.accountLimitHit?.resetsText
@@ -16784,6 +17148,9 @@ var ClaudeCodeLanguageModel = class {
               state.endTextBlock();
               state.resultFailure ??= "usage_limit";
             }
+            if (accountRun && state.accountLimitHit && msg.is_error === true) {
+              state.resultFailure ??= "usage_limit";
+            }
             if (runAutoContinue(state, msg)) return;
             for (const [idx, reasoningId] of state.reasoningIds) {
               if (state.reasoningStarted.get(idx)) {
@@ -16868,10 +17235,14 @@ var ClaudeCodeLanguageModel = class {
             fastMode,
             planModeQuestionActive,
             interactive: useInteractive,
-            sourceAccount,
+            sourceAccount: limitAccount,
+            accountConfigDir: accountRun ? self.skillBridgeSpawn(failover).configDir : self.config.configDir,
             failoverAskActive,
+            autoFailoverTarget,
             usageLimitNoteActive,
-            failoverAccounts,
+            // Read only when no switch takes the turn, which under `"auto"`
+            // means no account is left to offer.
+            failoverAccounts: accountRun ? [] : failoverAccounts,
             modelFallbackArmed,
             attempt,
             handleControlRequest: handleControlRequest2,
@@ -17514,7 +17885,6 @@ function registerOpencodeLogSink(client) {
 }
 
 // src/v2-client.ts
-import path14 from "path";
 function formatAgentTypeList(agents) {
   const lines = agents.flatMap((agent) => {
     if (agent.hidden === true || agent.mode === "primary") return [];
@@ -17542,8 +17912,7 @@ function describe(value) {
 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 ? path14.resolve(root, session.subpath) : root : void 0;
+  const directory = typeof session.location?.directory === "string" ? session.location.directory : void 0;
   return { ...info, directory, parentID: session.parentID };
 }
 function toV1Messages(messages) {