@khalilgharbaoui/opencode-claude-code-plugin 0.37.0 → 0.38.0

package/README.md

@@ -55,7 +55,7 @@ Nothing in the picker? [Troubleshooting](./docs/troubleshooting/symptoms.md) is
 |---|---|
 | **Selective tool proxy** | Choose, per tool, whether Claude Code or opencode executes it. Proxied calls end on an event (the result, an abort, the next message, the child exiting), never on a clock. [Guide](./docs/guides/tool-proxy.md) |
 | **Claude's own tools, MCP and skills** | `Read`, `Grep`, `Glob`, `WebSearch` run in Claude Code; your opencode MCP servers are bridged in; your opencode skills can be staged for Claude's `Skill` tool. [MCP](./docs/configuration/mcp.md) · [Skills](./docs/configuration/skills.md) |
-| **Several accounts, with failover** | `"accounts": ["personal", "work"]` becomes one provider per account. Out of usage mid-task? opencode's question form offers the others, and nothing moves until you pick. [Accounts](./docs/configuration/accounts.md) |
+| **Several accounts** | `"accounts": ["personal", "work"]` becomes one provider per account. Out of usage mid-task? One line says which account, which window and when it resets in your own time zone, and names the others to pick a model from. [Accounts](./docs/configuration/accounts.md) |
 | **Subagents: your account, their model** | `forceModel`, `reasoningEffort` and `cacheTtl` in an agent file, inheriting the caller's account. `task_batch` runs several subagents at once. [Subagents](./docs/configuration/subagents.md) |
 | **18 models, reasoning variants, fast mode** | Haiku 4.5 through Opus 5.5, Fable and Mythos, each with a `(N×)` list-price suffix, `low` to `max` effort variants, and a fallback chain for a model this account cannot run today. [Models](./docs/models.md) |
 | **`/btw` and `/claude-code-doctor`** | Side questions on the live process, and a health report whose `bundle` form is redacted by allowlist so it is safe to paste into a public issue. [`/btw`](./docs/guides/btw.md) · [Doctor](./docs/guides/doctor.md) |

package/dist/index.js

@@ -149,6 +149,7 @@ import path from "path";
 import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
+import { isMainThread } from "worker_threads";
 var LEVEL_RANK = {
   debug: 0,
   info: 1,
@@ -241,15 +242,110 @@ function fmt(level, msg, data) {
 function shouldEmit(level) {
   return LEVEL_RANK[level] >= LEVEL_RANK[activeConfig.level];
 }
-function shouldTui(level) {
+var tuiHostOverride;
+function isTuiHost() {
+  return tuiHostOverride ?? !isMainThread;
+}
+var MAX_BUFFERED_SINK_ENTRIES = 50;
+var MAX_TOASTED_MESSAGES = 200;
+var toastBurstLimit = 3;
+var toastBurstWindowMs = 2e3;
+var activeSink = null;
+var bufferedEntries = [];
+var droppedBeforeSink = 0;
+var toastedMessages = /* @__PURE__ */ new Set();
+var burstWindowStart = 0;
+var burstCount = 0;
+var burstSuppressed = 0;
+var burstSummaryTimer = null;
+function setLogSink(sink) {
+  activeSink = sink;
+  if (!sink) return;
+  const pending = bufferedEntries;
+  const dropped = droppedBeforeSink;
+  bufferedEntries = [];
+  droppedBeforeSink = 0;
+  for (const entry of pending) deliverToSink(entry);
+  if (dropped > 0) {
+    const message = `${dropped} earlier log line(s) were dropped before opencode's log channel was available`;
+    deliverToSink({
+      level: "warn",
+      message,
+      line: fmt("WARN", message)
+    });
+  }
+}
+function routeToSink(entry) {
+  if (!activeSink) {
+    if (bufferedEntries.length >= MAX_BUFFERED_SINK_ENTRIES) {
+      droppedBeforeSink += 1;
+      return;
+    }
+    bufferedEntries.push(entry);
+    return;
+  }
+  deliverToSink(entry);
+}
+function deliverToSink(entry) {
+  const sink = activeSink;
+  if (!sink) return;
+  try {
+    sink.log(entry);
+  } catch {
+  }
+  if (entry.level !== "warn" && entry.level !== "error") return;
+  if (toastedMessages.has(entry.message)) return;
+  if (toastedMessages.size < MAX_TOASTED_MESSAGES) toastedMessages.add(entry.message);
+  if (!allowToastNow()) return;
+  sendToast(sink, entry);
+}
+function sendToast(sink, entry) {
+  try {
+    sink.toast(entry);
+  } catch {
+  }
+}
+function allowToastNow() {
+  const now = Date.now();
+  if (now - burstWindowStart >= toastBurstWindowMs) {
+    burstWindowStart = now;
+    burstCount = 0;
+  }
+  if (burstCount < toastBurstLimit) {
+    burstCount += 1;
+    return true;
+  }
+  burstSuppressed += 1;
+  armBurstSummary();
+  return false;
+}
+function armBurstSummary() {
+  if (burstSummaryTimer) return;
+  burstSummaryTimer = setTimeout(() => {
+    burstSummaryTimer = null;
+    const suppressed = burstSuppressed;
+    burstSuppressed = 0;
+    if (suppressed <= 0) return;
+    const sink = activeSink;
+    if (!sink) return;
+    const message = `${suppressed} more claude-code warning(s) were not shown; the full text is in opencode's log`;
+    sendToast(sink, { level: "warn", message, line: fmt("WARN", message) });
+  }, toastBurstWindowMs);
+  burstSummaryTimer.unref?.();
+}
+function shouldSurface(level) {
   if (level === "warn" || level === "error") return true;
   return activeConfig.mode === "debug";
 }
 function emit(level, msg, data) {
   if (!shouldEmit(level)) return;
   const line = fmt(level.toUpperCase(), msg, data);
-  if (shouldTui(level)) {
-    console.error(line);
+  if (shouldSurface(level)) {
+    if (isTuiHost()) {
+      routeToSink({ level, message: msg, data, line });
+    } else {
+      console.error(line);
+    }
   }
   writeToFile(line);
 }
@@ -488,6 +584,20 @@ function formatResetsAt(resetsAt) {
   const date = new Date(ms);
   return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
 }
+function formatLocalMinute(ms) {
+  const when = new Date(ms);
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${when.getFullYear()}-${pad(when.getMonth() + 1)}-${pad(when.getDate())} ${pad(when.getHours())}:${pad(when.getMinutes())}`;
+}
+function formatResetsAtLocal(resetsAt) {
+  const ms = resetsAtToMs(resetsAt);
+  if (ms === void 0 || Number.isNaN(new Date(ms).getTime())) return void 0;
+  return formatLocalMinute(ms);
+}
+function describeRateLimitWindow(rateLimitType) {
+  if (!rateLimitType) return void 0;
+  return RATE_LIMIT_WINDOWS[rateLimitType] ?? rateLimitType;
+}
 function rateLimitKey(info) {
   return [
     info.status ?? "?",
@@ -503,7 +613,7 @@ function isRateLimitRejected(info) {
 }
 function describeRateLimit(info) {
   if (!info.status && !info.overageStatus) return null;
-  const window = info.rateLimitType ? RATE_LIMIT_WINDOWS[info.rateLimitType] ?? info.rateLimitType : void 0;
+  const window = describeRateLimitWindow(info.rateLimitType);
   const resets = formatResetsAt(info.resetsAt);
   const overageResets = formatResetsAt(info.overageResetsAt);
   const key = rateLimitKey(info);
@@ -518,9 +628,7 @@ function describeRateLimit(info) {
     if (resetAt) parts.push(`Resets at ${resetAt}.`);
     parts.push(RATE_LIMIT_ACTION);
     const message = parts.join(" ");
-    return { key, level: "warn", message, transcript: `
-${RATE_LIMIT_MARKER} ${message}
-` };
+    return { key, level: "warn", message, transcript: null };
   }
   if (info.status === "allowed_warning" || info.overageStatus === "allowed_warning") {
     const used = info.utilization === void 0 ? "" : ` (${Math.round(info.utilization * 100)}% used)`;
@@ -987,6 +1095,7 @@ var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
 var OPENCODE_QUESTION_RESULT_PREFIX = "User has answered your questions: ";
 var OPENCODE_QUESTION_RESULT_SUFFIX = ". You can now continue with the user's answers in mind.";
 var OPENCODE_UNANSWERED = "Unanswered";
+var DCP_MESSAGE_ID_SUFFIX = /(?:\s*<dcp-message-id>[^<>]*<\/dcp-message-id>)+\s*$/;
 var KEY_SEPARATOR = "\0";
 function isPlanModeQuestionActive(input) {
   if (input.compactionMode) return false;
@@ -1086,15 +1195,16 @@ function unwrapToolOutput(part) {
   }
 }
 function unwrapOpencodeQuestionResult(value, question) {
-  const sentence = value.trim();
+  const untagged = value.replace(DCP_MESSAGE_ID_SUFFIX, "");
+  const sentence = untagged.trim();
   if (!sentence.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) || !sentence.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
-    return value;
+    return untagged;
   }
   const body = sentence.slice(
     OPENCODE_QUESTION_RESULT_PREFIX.length,
     sentence.length - OPENCODE_QUESTION_RESULT_SUFFIX.length
   );
-  if (!body.startsWith('"') || !body.endsWith('"')) return value;
+  if (!body.startsWith('"') || !body.endsWith('"')) return untagged;
   let answer;
   const head = question === void 0 ? void 0 : `"${question}"="`;
   if (head && body.startsWith(head) && body.length > head.length) {
@@ -1103,7 +1213,7 @@ function unwrapOpencodeQuestionResult(value, question) {
     const split = body.lastIndexOf('"="');
     if (split > 0) answer = body.slice(split + 3, -1);
   }
-  if (answer === void 0) return value;
+  if (answer === void 0) return untagged;
   return answer === OPENCODE_UNANSWERED ? "" : answer;
 }
 function collectAnswerStrings(value, question) {
@@ -1161,6 +1271,13 @@ var ACCOUNT_LIMIT_PATTERNS = [
   /you[’'`]?ve hit your individual spend limit/i
 ];
 var ACCOUNT_BLOCK_MARKER = "\u258C **claude account:**";
+var USAGE_LIMIT_MARKER = "\u258C **usage limit:**";
+function describeOtherAccounts(candidates) {
+  const names = candidates.map((candidate) => normalizeAccountName(candidate)).filter(Boolean).map((candidate) => `"${candidate}"`);
+  if (names.length === 0) return "";
+  const joined = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}`;
+  return `the ${joined} account`;
+}
 var ACCOUNT_BLOCKS = {
   authentication_failed: { what: "is not logged in (its login expired or was revoked)", login: true },
   oauth_org_not_allowed: { what: "belongs to an organization that does not allow this login", login: false },
@@ -1184,17 +1301,51 @@ function formatAccountBlockNote(input) {
   const block = ACCOUNT_BLOCKS[input.kind];
   const account = normalizeAccountName(input.account || DEFAULT_ACCOUNT);
   const fix = block.login ? `Log in again with \`${loginCommandFor(input.configDir)}\`, then resend your message.` : "Check the account at claude.ai, then resend your message.";
-  const then = input.offeringSwitch ? " Or pick another account below." : "";
+  const others = input.offeringSwitch ? "" : describeOtherAccounts(input.candidates ?? []);
+  const then = input.offeringSwitch ? " Or pick another account below." : others ? ` Or pick a model from ${others} and resend.` : "";
   return `
 ${ACCOUNT_BLOCK_MARKER} the Claude account "${account}" ${block.what}. ${fix}${then}
 `;
 }
+function formatUsageLimitNote(input) {
+  const account = normalizeAccountName(input.sourceAccount || DEFAULT_ACCOUNT);
+  const window = describeRateLimitWindow(input.window);
+  const resets = formatResetsAtLocal(input.resetsAt);
+  const others = describeOtherAccounts(input.candidates);
+  const what = [
+    `the Claude account "${account}" is out of usage`,
+    window ? ` in ${window}` : "",
+    resets ? `, which resets at ${resets}` : "",
+    "."
+  ].join("");
+  const advice = others ? `Pick a model from ${others} and resend your message, or wait for the window to reset.` : "Wait for the window to reset, or enable extra usage on the account.";
+  return `
+${USAGE_LIMIT_MARKER} ${what} ${advice}
+`;
+}
 function isAccountLimitError(input) {
   if (input.rateLimit && isRateLimitRejected(input.rateLimit)) return true;
   const text = input.resultText;
   if (typeof text !== "string" || text.length === 0) return false;
   return ACCOUNT_LIMIT_PATTERNS.some((pattern) => pattern.test(text));
 }
+var lastAccountLimits = /* @__PURE__ */ new Map();
+function rememberAccountLimit(account, facts) {
+  const name = normalizeAccountName(account || DEFAULT_ACCOUNT);
+  if (!name) return;
+  lastAccountLimits.set(name, { resetsAt: facts.resetsAt, window: facts.window });
+}
+function recallAccountLimit(account, now = Date.now()) {
+  const name = normalizeAccountName(account || DEFAULT_ACCOUNT);
+  const facts = lastAccountLimits.get(name);
+  if (!facts) return {};
+  const resetsAtMs = resetsAtToMs(facts.resetsAt);
+  const fresh = resetsAtMs !== void 0 && resetsAtMs > now;
+  return {
+    ...fresh ? { resetsAt: facts.resetsAt } : {},
+    ...facts.window === void 0 ? {} : { window: facts.window }
+  };
+}
 var accountOverrides = /* @__PURE__ */ new Map();
 function setAccountOverride(source, target, until, now = Date.now()) {
   const from = normalizeAccountName(source || DEFAULT_ACCOUNT);
@@ -1262,7 +1413,7 @@ function isAccountFailoverQuestionActive(input) {
   if (input.compactionMode) return false;
   if (input.interactive) return false;
   if (input.childSession) return false;
-  if (input.configured === "off") return false;
+  if (input.configured !== "ask") return false;
   if (input.candidates.length === 0) return false;
   return input.opencodeHasQuestion;
 }
@@ -5378,6 +5529,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "btw: early aside failed; the message will ask again",
   "cannot interrupt this transport; waiting for the turn to end",
   "claude --version output unparseable",
+  "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.",
   "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
@@ -6232,11 +6384,6 @@ function compareBuilds(loaded, onDisk) {
     rebuiltAt: onDisk.mtimeMs
   };
 }
-function formatLocalMinute(ms) {
-  const when = new Date(ms);
-  const pad = (value) => String(value).padStart(2, "0");
-  return `${when.getFullYear()}-${pad(when.getMonth() + 1)}-${pad(when.getDate())} ${pad(when.getHours())}:${pad(when.getMinutes())}`;
-}
 function formatStaleBuildNote(stale) {
   const loadedAt = formatLocalMinute(stale.loadedAt);
   if (stale.kind === "version") {
@@ -7462,6 +7609,7 @@ var PLUGIN_NOTE_MARKERS = [
   SILENT_TURN_MARKER,
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER,
+  USAGE_LIMIT_MARKER,
   MODEL_FALLBACK_MARKER,
   UNATTENDED_REPLAY_MARKER,
   STALE_BUILD_MARKER
@@ -9872,6 +10020,7 @@ function createTurnState(init) {
     lastCallUsage: void 0,
     resultFailure: void 0,
     accountLimitHit: null,
+    usageLimitNote: false,
     accountBlock: null,
     modelRefusal: null,
     drainBuffer: [],
@@ -10652,6 +10801,7 @@ function createLineHandler(state, ctx) {
             resetsAt: info.resetsAt ?? info.overageResetsAt,
             window: info.rateLimitType
           };
+          rememberAccountLimit(ctx.sourceAccount, state.accountLimitHit);
         }
         const note = reportRateLimitEvent(msg);
         if (note) {
@@ -10935,6 +11085,13 @@ ${plan}
         if (hasText) {
           state.hasReceivedContent = true;
         }
+        const apiErrorReply = msg.is_api_error_message === true;
+        const limitErrorReply = apiErrorReply && ctx.usageLimitNoteActive && !state.accountBlock && (msg.error === "rate_limit" || isAccountLimitError({
+          resultText: msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
+        }));
+        if (limitErrorReply) {
+          state.accountLimitHit ??= recallAccountLimit(ctx.sourceAccount);
+        }
         if (hasText && !hasToolUse) {
           startResultFallback(state);
         }
@@ -10943,6 +11100,7 @@ ${plan}
         }
         for (const block2 of msg.message.content) {
           if (block2.type === "text" && block2.text) {
+            if (limitErrorReply) continue;
             resetLastVisibleTextBlock(state);
             const blockId = state.startTextBlock();
             state.controller.enqueue({
@@ -11155,7 +11313,15 @@ ${plan}
         if (deliverPendingCompletions(state)) {
           return;
         }
-        if (!state.currentTextId && msg.is_error && typeof msg.result === "string" && msg.result.trim().length > 0) {
+        if (!state.accountLimitHit && msg.is_error && isAccountLimitError({
+          resultText: typeof msg.result === "string" ? msg.result : null
+        })) {
+          state.accountLimitHit = recallAccountLimit(ctx.sourceAccount);
+        }
+        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;
+        if (!state.currentTextId && msg.is_error && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
           const errId = state.startTextBlock();
           state.controller.enqueue({
             type: "text-delta",
@@ -11163,11 +11329,6 @@ ${plan}
             delta: msg.result
           });
         }
-        if (!state.accountLimitHit && msg.is_error && isAccountLimitError({
-          resultText: typeof msg.result === "string" ? msg.result : null
-        })) {
-          state.accountLimitHit = {};
-        }
         if (ctx.modelFallbackArmed && !state.modelRefusal) {
           state.modelRefusal = modelRefusalFromResult(msg);
         }
@@ -11181,7 +11342,11 @@ ${plan}
               kind: state.accountBlock,
               account: ctx.sourceAccount,
               configDir: ctx.config.configDir,
-              offeringSwitch
+              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
+              // route and nothing else on screen says it exists (h #g194).
+              candidates: ctx.failoverAccounts
             })
           });
           state.endTextBlock();
@@ -12060,7 +12225,7 @@ var ClaudeCodeLanguageModel = class {
       this.config.failoverAccounts,
       sourceAccount
     );
-    const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover !== "off" && !compactionMode && !useInteractive && // A `doGenerate` caller takes the override and reports the plain
+    const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover === "ask" && !compactionMode && !useInteractive && // A `doGenerate` caller takes the override and reports the plain
     // rate-limit error, never the form. See `TurnMode`.
     mode !== "generate" && isAccountFailoverQuestionActive({
       configured: this.config.accountFailover,
@@ -12073,6 +12238,7 @@ var ClaudeCodeLanguageModel = class {
       // the operator is usually not even looking at.
       childSession: !!await fetchSessionParentId(affinity)
     });
+    const usageLimitNoteActive = !compactionMode && mode !== "generate" && !failoverAskActive;
     let staleBuild = null;
     if (!compactionMode && mode !== "generate" && affinity !== "default") {
       staleBuild = staleBuildWatch().check();
@@ -12620,6 +12786,26 @@ var ClaudeCodeLanguageModel = class {
                 return;
               }
             }
+            if (state.usageLimitNote) {
+              log.warn("claude account is out of usage; the turn ends with a note", {
+                sessionKey: sk,
+                account: sourceAccount,
+                window: state.accountLimitHit?.window ?? null,
+                resetsAt: state.accountLimitHit?.resetsAt ?? null,
+                candidates: failoverAccounts
+              });
+              controller.enqueue({
+                type: "text-delta",
+                id: state.startTextBlock(),
+                delta: formatUsageLimitNote({
+                  sourceAccount,
+                  candidates: failoverAccounts,
+                  resetsAt: state.accountLimitHit?.resetsAt,
+                  window: state.accountLimitHit?.window
+                })
+              });
+              state.endTextBlock();
+            }
             if (runAutoContinue(state, msg)) return;
             for (const [idx, reasoningId] of state.reasoningIds) {
               if (state.reasoningStarted.get(idx)) {
@@ -12693,6 +12879,8 @@ var ClaudeCodeLanguageModel = class {
             planModeQuestionActive,
             sourceAccount,
             failoverAskActive,
+            usageLimitNoteActive,
+            failoverAccounts,
             modelFallbackArmed,
             attempt,
             handleControlRequest: handleControlRequest2,
@@ -13142,6 +13330,72 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
+// src/tui-log-sink.ts
+var LOG_SERVICE_NAME = "opencode-claude-code";
+var TOAST_TITLE = "claude-code";
+var TOAST_DURATION_MS = 1e4;
+var MAX_TOAST_CHARS = 240;
+var APP_LOG_LEVEL = {
+  debug: "debug",
+  info: "info",
+  notice: "info",
+  warn: "warn",
+  error: "error"
+};
+function toastMessage(message) {
+  const flat = message.replace(/\s+/g, " ").trim();
+  if (flat.length <= MAX_TOAST_CHARS) return flat;
+  return `${flat.slice(0, MAX_TOAST_CHARS - 1)}\u2026`;
+}
+function appLogBody(entry) {
+  return {
+    service: LOG_SERVICE_NAME,
+    level: APP_LOG_LEVEL[entry.level],
+    message: entry.message,
+    ...entry.data && Object.keys(entry.data).length > 0 ? { extra: entry.data } : {}
+  };
+}
+function toastBody(entry) {
+  return {
+    title: TOAST_TITLE,
+    message: toastMessage(entry.message),
+    variant: entry.level === "error" ? "error" : "warning",
+    duration: TOAST_DURATION_MS
+  };
+}
+function fireAndForget(call) {
+  try {
+    const result = call();
+    if (result && typeof result.catch === "function") {
+      void result.catch(() => void 0);
+    }
+  } catch {
+  }
+}
+function createOpencodeLogSink(client) {
+  if (!client || typeof client !== "object") return null;
+  const sdk = client;
+  const canLog = typeof sdk.app?.log === "function";
+  const canToast = typeof sdk.tui?.showToast === "function";
+  if (!canLog && !canToast) return null;
+  return {
+    log(entry) {
+      if (!canLog) return;
+      fireAndForget(() => sdk.app.log({ body: appLogBody(entry) }));
+    },
+    toast(entry) {
+      if (!canToast) return;
+      fireAndForget(() => sdk.tui.showToast({ body: toastBody(entry) }));
+    }
+  };
+}
+function registerOpencodeLogSink(client) {
+  const sink = createOpencodeLogSink(client);
+  if (!sink) return false;
+  setLogSink(sink);
+  return true;
+}
+
 // src/v2-client.ts
 import path10 from "path";
 function formatAgentTypeList(agents) {
@@ -13693,7 +13947,11 @@ function createClaudeCode(settings = {}) {
       configDir: settings.configDir,
       failoverAccounts: settings.failoverAccounts,
       baseCliPath: settings.baseCliPath ?? cliPath,
-      accountFailover: settings.accountFailover ?? "ask",
+      // Passed through, with no default applied here: the form is opt-in and
+      // `isAccountFailoverQuestionActive` asks for an explicit `"ask"`, so an
+      // unset option must stay unset rather than being written to one mode or
+      // the other in only one of the two entry points (h #g194).
+      accountFailover: settings.accountFailover,
       providerID: settings.providerID,
       skipPermissions: preset?.skipPermissions ?? settings.skipPermissions ?? true,
       permissionMode: preset?.permissionMode ?? settings.permissionMode,
@@ -13966,7 +14224,9 @@ var server = async (input) => {
   ensureProcessExitCleanup();
   const opencodeVersion = pickOpencodeVersion(input);
   if (input && typeof input === "object" && "client" in input) {
-    setOpencodeClient(input.client);
+    const client = input.client;
+    setOpencodeClient(client);
+    registerOpencodeLogSink(client);
   }
   setOpencodeProjectDirectory(pickOpencodeDirectory(input));
   return {