@khalilgharbaoui/opencode-claude-code-plugin 0.60.1 → 0.60.2

package/dist/index.d.ts

@@ -1634,22 +1634,22 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      * 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.
+     * Anything but `"auto"` is `runModelChain` behind `stopOnCancel`. 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.
+     * Cancelling the returned stream is a stop, in every mode: a caller that has
+     * gone away must reach the turn it started, or the CLI runs it to the end
+     * and bills it. Each attempt gets a signal that the caller's own
+     * `abortSignal` and a `cancel()` both abort, so a cancel takes the turn's
+     * ordinary abort path, and with `"auto"` the loop starts no further account
+     * once either has happened. Until (h #g257) only `"auto"` did this.
      */
     private runAccountFailover;
     /**

package/dist/index.js

@@ -1998,17 +1998,21 @@ function describeReset(resetsAt) {
 }
 function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${ACCOUNT_FAILOVER_TOOL_CALL_PREFIX}${Math.random().toString(36).slice(2, 10)}`) {
   const source = normalizeAccountName(input.sourceAccount || DEFAULT_ACCOUNT);
+  const failed = normalizeAccountName(input.failedAccount || source);
   const candidates = input.candidates.map((c) => normalizeAccountName(c));
   const resets = describeReset(input.resetsAt);
   const until = resets ?? "opencode restarts";
-  const question = input.reason ? `The Claude account "${source}" ${input.reason}. Continue this task on another configured account? Leaving this unanswered waits, at no cost.` : [
-    `The Claude account "${source}" is out of usage`,
+  const question = input.reason ? `The Claude account "${failed}" ${input.reason}. Continue this task on another configured account? Leaving this unanswered waits, at no cost.` : [
+    `The Claude account "${failed}" is out of usage`,
     input.window ? ` in ${input.window}` : "",
     resets ? `, which resets at ${resets}` : "",
     ". Continue this task on another configured account? Leaving this unanswered waits, at no cost."
   ].join("");
   pendingQuestions2.set(pendingKey2(sessionKey2, toolCallId), {
     sourceAccount: source,
+    // Only after a chain of overrides; otherwise the two are one account.
+    ...failed !== source ? { failedAccount: failed } : {},
+    ...input.reason ? { reason: input.reason } : {},
     candidates: [...candidates],
     resetsAt: input.resetsAt,
     question
@@ -2024,7 +2028,7 @@ function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${A
           options: [
             ...candidates.map((candidate) => ({
               label: candidate,
-              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.`
+              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 "${failed}"'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 "${failed}"'s Claude profile will be missing.`
             })),
             {
               label: STOP_ANSWER,
@@ -2068,6 +2072,8 @@ function classify(pending2, part) {
     kind: "switch",
     target,
     sourceAccount: pending2.sourceAccount,
+    ...pending2.failedAccount ? { failedAccount: pending2.failedAccount } : {},
+    ...pending2.reason ? { reason: pending2.reason } : {},
     resetsAt: pending2.resetsAt
   };
 }
@@ -2095,6 +2101,7 @@ function consumeAccountFailoverAnswer(sessionKey2, prompt, fallback) {
       return classify(
         {
           sourceAccount: normalizeAccountName(fallback.sourceAccount || DEFAULT_ACCOUNT),
+          ...fallback.failedAccount ? { failedAccount: normalizeAccountName(fallback.failedAccount) } : {},
           candidates: fallback.candidates.map((c) => normalizeAccountName(c))
         },
         orphan
@@ -2105,8 +2112,9 @@ function consumeAccountFailoverAnswer(sessionKey2, prompt, fallback) {
 }
 function formatFailoverNote(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.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.
+${FAILOVER_MARKER} "${input.sourceAccount}" ${input.reason ?? "is out of usage"}, so this conversation continues on "${input.target}" ${resets ? `until ${resets}` : "until opencode restarts"}. ${arrival}
 `;
 }
 function formatAutoFailoverNote(input) {
@@ -3800,13 +3808,27 @@ import { createHash } from "crypto";
 var fingerprints = /* @__PURE__ */ new Map();
 var fingerprintSeq = 0;
 var MAX_FORK_FINGERPRINTS = 64;
-function hashPart(hash, part) {
+var DIGEST_VERSION = 2;
+var DCP_MESSAGE_ID_TAG = /<dcp-message-id(?:\s[^>]*)?>[^<]*<\/dcp-message-id>/g;
+var DCP_COMPACT_REF_LINE = /^@(?:\d+|b\d+|blocked)@(?: \[[^\]\n]*\])?$/;
+function withoutDcpRefs(text) {
+  let out = text.includes("<dcp-message-id") ? text.replace(DCP_MESSAGE_ID_TAG, "") : text;
+  for (; ; ) {
+    const trimmed = out.trimEnd();
+    if (!trimmed.endsWith("@") && !trimmed.endsWith("]")) return out;
+    const lineStart = trimmed.lastIndexOf("\n") + 1;
+    if (!DCP_COMPACT_REF_LINE.test(trimmed.slice(lineStart))) return out;
+    out = trimmed.slice(0, lineStart);
+  }
+}
+function hashPart(hash, part, version) {
   const p = part;
   const type = typeof p?.type === "string" ? p.type : "unknown";
+  const content = (text) => version >= 2 ? withoutDcpRefs(text) : text;
   switch (type) {
     case "text":
       hash.update("text\0");
-      hash.update(String(p?.text ?? ""));
+      hash.update(content(String(p?.text ?? "")));
       break;
     case "tool-call":
       hash.update("call\0");
@@ -3818,7 +3840,7 @@ function hashPart(hash, part) {
       hash.update("result\0");
       hash.update(String(p?.toolName ?? ""));
       hash.update("\0");
-      hash.update(stableJson(p?.output));
+      hash.update(stableJson(p?.output, version >= 2 ? withoutDcpRefs : void 0));
       break;
     case "file":
     case "image": {
@@ -3840,9 +3862,10 @@ function hashPart(hash, part) {
   }
   hash.update("");
 }
-function stableJson(value) {
+function stableJson(value, text) {
   const seen = /* @__PURE__ */ new WeakSet();
   const walk = (node) => {
+    if (typeof node === "string") return text ? text(node) : node;
     if (node === null || typeof node !== "object") return node;
     if (seen.has(node)) return "[circular]";
     seen.add(node);
@@ -3859,16 +3882,16 @@ function stableJson(value) {
     return "[unserializable]";
   }
 }
-function messageDigest(msg) {
+function messageDigest(msg, version) {
   const hash = createHash("sha256");
   hash.update(msg.role);
   hash.update("\0");
   if (typeof msg.content === "string") {
     hash.update("text\0");
-    hash.update(msg.content);
+    hash.update(version >= 2 ? withoutDcpRefs(msg.content) : msg.content);
     hash.update("");
   } else if (Array.isArray(msg.content)) {
-    for (const part of msg.content) hashPart(hash, part);
+    for (const part of msg.content) hashPart(hash, part, version);
   }
   return hash.digest("hex").slice(0, 32);
 }
@@ -3881,7 +3904,7 @@ function conversationDigests(prompt, opts) {
     }
     out.push({
       role: msg.role,
-      digest: opts?.assistantContent === false && msg.role === "assistant" ? ASSISTANT_TURN_DIGEST : messageDigest(msg)
+      digest: opts?.assistantContent === false && msg.role === "assistant" ? ASSISTANT_TURN_DIGEST : messageDigest(msg, opts?.version ?? DIGEST_VERSION)
     });
   }
   return out;
@@ -4251,6 +4274,13 @@ var SPAWN_MCP_TIMEOUT_MS = 12e4;
 function spawnMcpTimeoutEnv(inherited = process.env) {
   return inherited.MCP_TIMEOUT === void 0 ? { MCP_TIMEOUT: String(SPAWN_MCP_TIMEOUT_MS) } : {};
 }
+var CLI_DEFAULT_MCP_TIMEOUT_MS = 3e4;
+function effectiveSpawnMcpTimeoutMs(inherited = process.env) {
+  const value = inherited.MCP_TIMEOUT;
+  if (value === void 0) return SPAWN_MCP_TIMEOUT_MS;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 2147483647) : CLI_DEFAULT_MCP_TIMEOUT_MS;
+}
 function detectCliVersion(cliPath) {
   const cached2 = cache2.get(cliPath);
   if (cached2) return cached2;
@@ -7218,7 +7248,7 @@ function isDigest(value) {
 }
 function isRecord2(value) {
   const record = value;
-  return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest) && (record.shape === void 0 || Array.isArray(record.shape) && record.shape.every(isDigest)) && (record.configDir === void 0 || typeof record.configDir === "string") && (record.account === void 0 || typeof record.account === "string");
+  return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest) && (record.shape === void 0 || Array.isArray(record.shape) && record.shape.every(isDigest)) && (record.configDir === void 0 || typeof record.configDir === "string") && (record.account === void 0 || typeof record.account === "string") && (record.version === void 0 || typeof record.version === "number");
 }
 function load2() {
   if (records) return records;
@@ -7271,7 +7301,7 @@ function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath, where)
   const configDir = where?.configDir;
   const account = where?.account;
   const current = load2().get(sessionKey2);
-  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.shape !== void 0 && current.configDir === configDir && current.account === account && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
+  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.shape !== void 0 && current.configDir === configDir && current.account === account && current.version === DIGEST_VERSION && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
     return;
   }
   save2((merged) => {
@@ -7283,6 +7313,7 @@ function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath, where)
       shape: shape2,
       ...configDir === void 0 ? {} : { configDir },
       ...account === void 0 ? {} : { account },
+      version: DIGEST_VERSION,
       updatedAt: Date.now()
     });
   });
@@ -7317,7 +7348,7 @@ function findResumePoint(opts) {
     return void 0;
   };
   if (record.cliPath !== opts.cliPath) return refuse("another-claude-binary");
-  if (!continuesRecordedConversation(record.chain, opts.prompt)) {
+  if (!continuesRecordedConversation(record.chain, opts.prompt, { version: record.version ?? 1 })) {
     return refuse("conversation-changed");
   }
   if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
@@ -7355,7 +7386,8 @@ function findSiblingResumePoint(opts) {
       continue;
     }
     if (!record.shape || !continuesRecordedConversation(record.shape, opts.prompt, {
-      assistantContent: false
+      assistantContent: false,
+      version: record.version ?? 1
     })) {
       refusal = "sibling-conversation-changed";
       continue;
@@ -7885,6 +7917,18 @@ function isTerminalResultLine(line) {
     return false;
   }
 }
+function isSystemInitLine(line) {
+  if (!line.includes('"init"')) return false;
+  try {
+    const parsed = JSON.parse(line);
+    return parsed.type === "system" && parsed.subtype === "init";
+  } catch {
+    return false;
+  }
+}
+function noteInitLine(ap, line) {
+  if (!ap.initSeen && isSystemInitLine(line)) ap.initSeen = true;
+}
 function settleTurn(ap) {
   ap.turnInFlight = false;
   const waiters = ap.turnIdleWaiters ?? [];
@@ -8246,6 +8290,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   rl.on("line", (line) => {
     if (dispatchSideQuestionResponse(ap, line)) return;
     noteTurnLine(ap, line);
+    noteInitLine(ap, line);
     if (lineEmitter.listenerCount("line") === 0) {
       bufferUnattendedLine(ap, line);
       return;
@@ -8860,9 +8905,10 @@ function resolveBudgetWarnAt(value) {
   }
   return [...new Set(value)].sort((a, b) => a - b);
 }
-function costDelta(claudeSessionId, totalCostUsd, cumulative) {
-  if (!Number.isFinite(totalCostUsd) || totalCostUsd <= 0) return 0;
-  if (!cumulative || !claudeSessionId) return totalCostUsd;
+function takeResultCost(claudeSessionId, totalCostUsd, cumulative) {
+  if (!Number.isFinite(totalCostUsd) || totalCostUsd <= 0) return { deltaUsd: 0, noBaseline: false };
+  if (!cumulative) return { deltaUsd: totalCostUsd, noBaseline: false };
+  if (!claudeSessionId) return { deltaUsd: totalCostUsd, noBaseline: true };
   const previous = lastTotals.get(claudeSessionId);
   lastTotals.delete(claudeSessionId);
   lastTotals.set(claudeSessionId, totalCostUsd);
@@ -8871,8 +8917,9 @@ function costDelta(claudeSessionId, totalCostUsd, cumulative) {
     if (oldest.done) break;
     lastTotals.delete(oldest.value);
   }
-  if (previous === void 0 || totalCostUsd < previous) return totalCostUsd;
-  return totalCostUsd - previous;
+  if (previous === void 0) return { deltaUsd: totalCostUsd, noBaseline: true };
+  if (totalCostUsd < previous) return { deltaUsd: totalCostUsd, noBaseline: false };
+  return { deltaUsd: totalCostUsd - previous, noBaseline: false };
 }
 function recordSessionCost(session, deltaUsd) {
   if (!(deltaUsd > 0)) return;
@@ -8931,8 +8978,10 @@ function formatBudgetStopNote(spentUsd, capUsd) {
   return `${BUDGET_MARKER} this conversation has spent ${formatUsd(spentUsd)} against its ${formatUsd(capUsd)} \`maxBudgetUsd\`, so this turn was not started and nothing was sent to Claude. Raise \`maxBudgetUsd\` in the provider options and relaunch opencode (plugin options are read once at startup), or start a new session.`;
 }
 function recordResultCost(budget, claudeSessionId, totalCostUsd) {
-  if (typeof totalCostUsd !== "number") return;
-  recordSessionCost(budget.session, costDelta(claudeSessionId, totalCostUsd, budget.cumulative));
+  if (typeof totalCostUsd !== "number") return void 0;
+  const cost = takeResultCost(claudeSessionId, totalCostUsd, budget.cumulative);
+  recordSessionCost(budget.session, cost.deltaUsd);
+  return cost;
 }
 function takeBudgetNote(budget) {
   if (!budget.notes) return null;
@@ -9148,6 +9197,7 @@ var BUNDLE_DATA_ALLOWLIST = {
   // booleans: every one of these is a decision the plugin made
   applied: "flag",
   attached: "flag",
+  beforeInit: "flag",
   bridgeSkipNativeSkills: "flag",
   channelClosed: "flag",
   compaction: "flag",
@@ -9249,9 +9299,11 @@ var BUNDLE_DATA_ALLOWLIST = {
   durationMs: "duration",
   elapsedMs: "duration",
   remainingMs: "duration",
+  startWatchdogMs: "duration",
   timeoutMs: "duration",
   waitedMs: "duration",
   costUsd: "money",
+  turnCostUsd: "money",
   // enums: a fixed vocabulary this package or the CLI defines
   apiKeySource: "enum",
   delivery: "enum",
@@ -11696,6 +11748,11 @@ function extractTurnStats(msg) {
   if (Array.isArray(msg.permission_denials)) stats.permissionDenials = msg.permission_denials;
   return stats;
 }
+function footerCostUsd(cost, resumedSession) {
+  if (!cost) return void 0;
+  if (cost.noBaseline && resumedSession) return void 0;
+  return cost.deltaUsd;
+}
 function formatCost(costUsd) {
   if (!Number.isFinite(costUsd) || costUsd < 0) return "$0.00";
   return costUsd >= 1 ? `$${costUsd.toFixed(2)}` : `$${costUsd.toFixed(4)}`;
@@ -15559,6 +15616,8 @@ function createTurnState(init) {
     asideSinkUnregister: null,
     resultFallbackTimer: null,
     startWatchdog: null,
+    startWatchdogArmedMs: 0,
+    startWatchdogBeforeInit: false,
     respawnAttempted: false,
     hasReceivedContent: false,
     hasReceivedProgress: false,
@@ -15934,7 +15993,11 @@ function onStartWatchdogFire(state) {
   if (state.respawnAttempted) {
     log.error(
       "claude process still silent after respawn; ending turn",
-      { sessionKey: state.sessionKey }
+      {
+        sessionKey: state.sessionKey,
+        startWatchdogMs: state.startWatchdogArmedMs,
+        beforeInit: state.startWatchdogBeforeInit
+      }
     );
     deleteActiveProcess(state.sessionKey);
     deleteClaudeSessionId(state.sessionKey);
@@ -15955,7 +16018,11 @@ function onStartWatchdogFire(state) {
   state.respawnAttempted = true;
   log.warn(
     "no stdout after envelope write; respawning claude process to resume conversation",
-    { sessionKey: state.sessionKey, startWatchdogMs: state.startWatchdogMs }
+    {
+      sessionKey: state.sessionKey,
+      startWatchdogMs: state.startWatchdogArmedMs,
+      beforeInit: state.startWatchdogBeforeInit
+    }
   );
   state.lineEmitter.off("line", state.lineHandler);
   state.lineEmitter.off("close", state.closeHandler);
@@ -16007,14 +16074,29 @@ function onStartWatchdogFire(state) {
   }
   armStartWatchdog(state);
 }
+var START_WATCHDOG_INIT_MARGIN_MS = 3e4;
+function startWatchdogDelayMs(configuredMs, beforeInit, mcpTimeoutMs = effectiveSpawnMcpTimeoutMs()) {
+  return beforeInit ? Math.max(configuredMs, mcpTimeoutMs + START_WATCHDOG_INIT_MARGIN_MS) : configuredMs;
+}
 function armStartWatchdog(state) {
   clearStartWatchdog(state);
   if (state.controllerClosed) return;
+  const ap = state.activeProcess;
+  state.startWatchdogBeforeInit = !ap?.interactiveControl && ap?.initSeen !== true;
+  state.startWatchdogArmedMs = startWatchdogDelayMs(
+    state.startWatchdogMs,
+    state.startWatchdogBeforeInit
+  );
   state.startWatchdog = setTimeout(
     () => onStartWatchdogFire(state),
-    state.startWatchdogMs
+    state.startWatchdogArmedMs
   );
 }
+function noteStartWatchdogInit(state) {
+  if (!state.startWatchdog || !state.startWatchdogBeforeInit) return;
+  if (state.activeProcess?.initSeen !== true) return;
+  armStartWatchdog(state);
+}
 function deliverPendingCompletions(state, force = false) {
   const pending2 = state.activeProcess?.pendingProxyCompletions;
   const entries = [...pending2?.values() ?? []].filter(
@@ -16370,6 +16452,7 @@ function createLineHandler(state, ctx) {
         subtype: msg.subtype
       });
       if (msg.type === "system" && msg.subtype === "init") {
+        noteStartWatchdogInit(state);
         if (msg.session_id) {
           setClaudeSessionId(state.sessionKey, msg.session_id);
           log.info("session initialized", {
@@ -16968,7 +17051,7 @@ ${plan}
         if (msg.session_id) {
           setClaudeSessionId(state.sessionKey, msg.session_id);
         }
-        if (ctx.budget) recordResultCost(ctx.budget, msg.session_id, msg.total_cost_usd);
+        const resultCost = ctx.budget ? recordResultCost(ctx.budget, msg.session_id, msg.total_cost_usd) : ctx.config.turnStats && typeof msg.total_cost_usd === "number" ? takeResultCost(msg.session_id, msg.total_cost_usd, !ctx.interactive) : void 0;
         if (deliverPendingCompletions(state)) {
           return;
         }
@@ -17061,10 +17144,17 @@ ${plan}
           numTurns: msg.num_turns,
           isError: msg.is_error,
           subtype: msg.subtype,
-          ...turnStatsLogPayload(turnStats)
+          ...turnStatsLogPayload(turnStats),
+          turnCostUsd: resultCost?.deltaUsd
         });
         if (ctx.config.turnStats && !ctx.compactionMode && !msg.is_error && !failure) {
-          const footer = formatTurnStatsBlock(turnStats);
+          const footer = formatTurnStatsBlock({
+            ...turnStats,
+            costUsd: footerCostUsd(
+              resultCost,
+              state.activeProcess?.cliArgs?.includes("--resume") === true
+            )
+          });
           if (footer) {
             state.controller.enqueue({
               type: "text-delta",
@@ -17139,6 +17229,26 @@ async function isProxyCallStillServed(callId) {
 setProxyDeadlineGuard(({ callId }) => isProxyCallStillServed(callId));
 var FORWARD_SETTLE_MS = 250;
 var CHILD_EXIT_STATUS_GRACE_MS = 250;
+function stopOnCancel(stream, cancelled2) {
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) controller.close();
+        else controller.enqueue(value);
+      } catch (error) {
+        try {
+          controller.error(error);
+        } catch {
+        }
+      }
+    },
+    cancel(reason) {
+      cancelled2.abort(reason);
+    }
+  });
+}
 var ClaudeCodeLanguageModel = class {
   specificationVersion = "v3";
   modelId;
@@ -17626,32 +17736,35 @@ var ClaudeCodeLanguageModel = class {
    * 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.
+   * Anything but `"auto"` is `runModelChain` behind `stopOnCancel`. 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.
+   * Cancelling the returned stream is a stop, in every mode: a caller that has
+   * gone away must reach the turn it started, or the CLI runs it to the end
+   * and bills it. Each attempt gets a signal that the caller's own
+   * `abortSignal` and a `cancel()` both abort, so a cancel takes the turn's
+   * ordinary abort path, and with `"auto"` the loop starts no further account
+   * once either has happened. Until (h #g257) only `"auto"` did this.
    */
   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
     };
+    if (this.config.accountFailover !== "auto") {
+      const inner2 = await this.runModelChain(attemptOptions, mode);
+      return { ...inner2, stream: stopOnCancel(inner2.stream, cancelled2) };
+    }
+    const self = this;
+    const run = { tried: /* @__PURE__ */ new Set() };
     const stopped = () => attemptOptions.abortSignal.aborted;
     let inner = await this.runModelChain(attemptOptions, mode, run);
     const request = inner.request;
@@ -17693,9 +17806,8 @@ var ClaudeCodeLanguageModel = class {
           }
         }
       },
-      async cancel(reason) {
+      cancel(reason) {
         cancelled2.abort(reason);
-        await reader?.cancel(reason).catch(() => void 0);
       }
     });
     return { stream, request };
@@ -18102,16 +18214,19 @@ var ClaudeCodeLanguageModel = class {
       resetsAt: autoSwitch.resetsAt
     } : compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
       sourceAccount,
+      // What the form would offer now: an override still standing is
+      // still the account that failed, and is not on offer (h #g257).
+      failedAccount: failover.target ?? sourceAccount,
       candidates: failoverCandidates(
         this.config.failoverAccounts,
         sourceAccount,
         groups
-      )
+      ).filter((account) => account !== (failover.target ?? sourceAccount))
     });
     if (failoverAnswer?.kind === "stop") {
       log.warn("account failover declined; ending the turn", {
         sessionKey: sk,
-        account: sourceAccount,
+        account: failover.target ?? sourceAccount,
         reason: failoverAnswer.reason
       });
       const note = formatFailoverStopNote(failoverAnswer.reason);
@@ -18125,7 +18240,10 @@ var ClaudeCodeLanguageModel = class {
           controller.enqueue({
             type: "error",
             error: new Error(
-              `Claude account "${sourceAccount}" is out of usage and no other account was picked.`
+              // The account that failed: after a chain of overrides that is
+              // not the provider's own (h #g257). A stop answer also follows
+              // an expired login, so this does not say "out of usage".
+              `Claude account "${failover.target ?? sourceAccount}" cannot serve this turn and no other account was picked.`
             )
           });
           controller.enqueue({
@@ -18229,13 +18347,6 @@ var ClaudeCodeLanguageModel = class {
       }
       cliPath = failover.cliPath;
       asideTransportRef.cliPath = cliPath;
-      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);
@@ -18307,6 +18418,14 @@ var ClaudeCodeLanguageModel = class {
         reason: autoSwitch.reason,
         carried: conversationOnTarget
       });
+    } else if (!autoSwitch && failoverAnswer?.kind === "switch") {
+      failoverNote = formatFailoverNote({
+        sourceAccount: failoverAnswer.failedAccount ?? failoverAnswer.sourceAccount,
+        target: failoverAnswer.target,
+        resetsAt: failoverAnswer.resetsAt,
+        reason: failoverAnswer.reason,
+        carried: conversationOnTarget
+      });
     }
     let accountGroupNote = null;
     if (!compactionMode && groups && accountProviders.size > 0 && includeHistoryContext && failoverAnswer?.kind !== "switch") {
@@ -18573,11 +18692,12 @@ var ClaudeCodeLanguageModel = class {
         "The read-only preset on the interactive transport needs Claude Code 2.1.263 or newer (--restricted and --permission-mode dontAsk). Update claude, or use the headless transport."
       );
     }
+    const spawnedAccount = failover.target ?? sourceAccount;
     const failoverAccounts = failoverCandidates(
       this.config.failoverAccounts,
       sourceAccount,
       groups
-    );
+    ).filter((account) => account !== spawnedAccount);
     const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover === "ask" && !compactionMode && // A `doGenerate` caller takes the override and reports the plain
     // rate-limit error, never the form. See `TurnMode`.
     mode !== "generate" && isAccountFailoverQuestionActive({
@@ -18590,7 +18710,6 @@ 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 = () => {
@@ -18599,7 +18718,7 @@ var ClaudeCodeLanguageModel = class {
       }
       return autoFailoverChoice ?? void 0;
     };
-    const limitAccount = accountRun ? spawnedAccount : sourceAccount;
+    const limitAccount = spawnedAccount;
     const usageLimitNoteActive = !compactionMode && mode !== "generate" && !failoverAskActive;
     const usageWarnThresholds = resolveUsageWarnThresholds(this.config.usageWarnThresholds);
     const usageSwitchAt = this.config.usageSwitchAt === null ? null : resolveUsageSwitchAt(this.config.usageSwitchAt);
@@ -19348,7 +19467,11 @@ var ClaudeCodeLanguageModel = class {
             state.activeProcess?.pendingProxyCompletions?.clear();
             if ((state.accountLimitHit || state.accountBlock) && failoverAskActive && msg.is_error === true) {
               const call = createAccountFailoverQuestionCall(sk, {
+                // The override a pick sets is keyed on the provider's own
+                // account, the one every turn of this conversation resolves
+                // from; the form names the account that actually failed.
                 sourceAccount,
+                failedAccount: limitAccount,
                 candidates: failoverAccounts,
                 resetsAt: state.accountLimitHit?.resetsAt,
                 window: state.accountLimitHit?.window,
@@ -19356,7 +19479,7 @@ var ClaudeCodeLanguageModel = class {
                 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.`,
+                `Claude account "${limitAccount}" ${state.accountLimitHit || !state.accountBlock ? "is out of usage" : `cannot serve (${state.accountBlock})`}; asking which account to continue on.`,
                 {
                   sessionKey: sk,
                   candidates: failoverAccounts,
@@ -19447,7 +19570,7 @@ var ClaudeCodeLanguageModel = class {
               state.endTextBlock();
               state.resultFailure ??= "usage_limit";
             }
-            if (accountRun && state.accountLimitHit && msg.is_error === true) {
+            if (state.accountLimitHit && msg.is_error === true) {
               state.resultFailure ??= "usage_limit";
             }
             if (runAutoContinue(state, msg)) return;
@@ -19566,7 +19689,11 @@ var ClaudeCodeLanguageModel = class {
             interactive: useInteractive,
             sourceAccount: limitAccount,
             usageAccount: spawnedAccount,
-            accountConfigDir: accountRun ? self.skillBridgeSpawn(failover).configDir : self.config.configDir,
+            // The config dir of the account that ran, so an account-block note
+            // names that account's login command. The provider's own when no
+            // override moved the turn; until (h #g257) `"off"` and `"ask"`
+            // named the provider's even after one had.
+            accountConfigDir: self.skillBridgeSpawn(failover).configDir,
             failoverAskActive,
             autoFailoverTarget,
             usageLimitNoteActive,