charness 3.0.0 → 3.1.0

package/dist/bot.js

@@ -66,6 +66,7 @@ require("./connectors/jira/sessionKeyCodec");
 const agentTrigger_1 = require("./agentTrigger");
 const sessionPick_1 = require("./sessionPick");
 const claudeCliAdapter_1 = require("./adapters/claudeCliAdapter");
+const openCodeAdapter_1 = require("./adapters/openCodeAdapter");
 const terminalAdapter_1 = require("./adapters/terminalAdapter");
 const openCodeQuestionFlow_1 = require("./openCodeQuestionFlow");
 const pendingQuestionRepost_1 = require("./pendingQuestionRepost");
@@ -192,6 +193,15 @@ const reminders_1 = require("./connectors/telegram/commands/reminders");
 const modelProviders_1 = require("./connectors/telegram/commands/modelProviders");
 const compaction_1 = require("./connectors/telegram/commands/compaction");
 const autoContinueLimits_1 = require("./connectors/telegram/commands/autoContinueLimits");
+const claudeAccounts_1 = require("./connectors/telegram/commands/claudeAccounts");
+const claudeProfiles_1 = require("./utils/claudeProfiles");
+const claudeUsage_1 = require("./utils/claudeUsage");
+const claudeUsageRefresher_1 = require("./utils/claudeUsageRefresher");
+const claudeLimitSwitch_1 = require("./utils/claudeLimitSwitch");
+const fallbackChain_1 = require("./utils/fallbackChain");
+const fallbackBridge_1 = require("./utils/fallbackBridge");
+const fallbackChain_2 = require("./connectors/telegram/commands/fallbackChain");
+const resolveBinary_1 = require("./utils/resolveBinary");
 // ═══════════════════════════════════════════════════════════════════════════════
 //  ENV parsing & fatal validation
 // ═══════════════════════════════════════════════════════════════════════════════
@@ -828,6 +838,12 @@ const limitResumeNoticePinnedMessageId = new Map();
  * Cleared by {@link cancelApiRetry} (the user took over / the session went away).
  */
 const autoContinueOffNoticedThreads = new Set();
+/**
+ * The OPEN «switch» offer per thread (`utils/fallbackChain.ts`): the limit episode the buttons on the notice
+ * were posted for, the rung the topic was on and the candidate list the buttons index into. A tap is honoured
+ * only while the thread's open offer is the button's episode; retired with the episode in {@link cancelApiRetry}.
+ */
+const fallbackSwitchOffers = new Map();
 const threadModelLists = new Map();
 const awaitingModelSelection = new Set();
 const statusCoalescers = new Map();
@@ -1089,7 +1105,7 @@ function handleApiError(key, cls) {
         // Each repeat is offered to the open request: the dedup is per request, so one
         // opened after the first notice still hears about the limit (and is stopped).
         const wait = { kind: 'autoResumeOff' };
-        void announceLimitWait(key, wait, getLimitWaitTexts(key, wait, 0), isFirstOffNotice);
+        void announceUsageLimitOrSwitch(key, cls, Date.now(), wait, 0, isFirstOffNotice);
         return;
     }
     const entry = apiRetryTimers.get(k);
@@ -1135,7 +1151,7 @@ function handleApiError(key, cls) {
         limitWait = cls.resetAt !== undefined
             ? { kind: 'afterReset', resetAt: cls.resetAt, fireAt: action.fireAt }
             : { kind: 'nextAttempt', fireAt: action.fireAt };
-        void announceLimitWait(key, limitWait, getLimitWaitTexts(key, limitWait, action.attempt), true);
+        void announceUsageLimitOrSwitch(key, cls, action.fireAt, limitWait, action.attempt, true);
     }
     else {
         void replyToThread(key, (0, i18n_1.t)('apiRetry.transientNotice', {
@@ -1242,6 +1258,13 @@ const apiRetryKickDeps = {
     trackContinuation: async (key, options) => {
         await requestWakeUpEngine?.trackContinuationTurn(key, options);
     },
+    resumeOnRung: async (key, rung) => {
+        const from = getTopicFallbackPosition(key);
+        if (from !== null && (0, fallbackChain_1.checkIsSameFallbackAccount)(from, rung))
+            return false; // already there
+        const outcome = await switchTopicToFallbackEntry(key, from, rung, { isAnnounced: true });
+        return outcome.isSwitched;
+    },
     clearSavedRetry: clearSavedApiRetry,
 };
 /**
@@ -1251,7 +1274,7 @@ const apiRetryKickDeps = {
  * when it is due (`isPlainNoticeDue`) and no answer said it — no open request,
  * or the answer could not be delivered.
  */
-async function announceLimitWait(key, wait, texts, isPlainNoticeDue) {
+async function announceLimitWait(key, wait, texts, isPlainNoticeDue, plainNoticeExtra) {
     let outcome = 'notAnswered';
     if (requestLimitWaitAnswerDeps) {
         try {
@@ -1261,8 +1284,79 @@ async function announceLimitWait(key, wait, texts, isPlainNoticeDue) {
             console.warn('[requests] limit answer failed:', e instanceof Error ? e.message : e);
         }
     }
-    if (outcome === 'notAnswered' && isPlainNoticeDue)
-        await replyToThread(key, texts.plainNotice);
+    if (outcome !== 'notAnswered' || !isPlainNoticeDue)
+        return { isPlainNoticePosted: false };
+    await replyToThread(key, texts.plainNotice, plainNoticeExtra);
+    return { isPlainNoticePosted: true };
+}
+/**
+ * @description A usage limit on a topic, with the fallback switch in front of the wait (`utils/fallbackChain.ts`):
+ * when a rung of the chain (or, without a chain, another signed-in Claude profile with room) can take the work
+ * over, auto-switch ON moves the topic there at once and the wait is never announced (the work continues — one
+ * line says so); OFF puts «switch to …» buttons on the wait notice (on a line of their own when an open request's
+ * answer replaced the notice). No rung available, or a backend without accounts: the wait is announced as before.
+ */
+async function announceUsageLimitOrSwitch(key, cls, episodeId, initialWait, attempt, isPlainNoticeDue) {
+    let wait = initialWait;
+    let plan = { action: 'none', from: null, earliest: null };
+    try {
+        plan = await planFallbackSwitch(key, cls, episodeId);
+    }
+    catch (e) {
+        console.warn(`[fallback] ${(0, sessionKey_1.keyToString)(key)}: the limit switch plan failed:`, e instanceof Error ? e.message : e);
+    }
+    if (plan.action === 'auto') {
+        const to = plan.to;
+        const outcome = await switchTopicToFallbackEntry(key, plan.from, to, { isAnnounced: true }).catch((e) => {
+            console.warn(`[fallback] ${(0, sessionKey_1.keyToString)(key)}: the auto-switch to ${formatFallbackEntry(to)} failed:`, e instanceof Error ? e.message : e);
+            return { isSwitched: false };
+        });
+        if (outcome.isSwitched)
+            return;
+    }
+    // Every rung is limited and another one comes back before this one: the wait (armed for this rung's reset)
+    // is re-targeted to that rung — the resume moves the topic there first.
+    let resumeOn;
+    if (plan.earliest && wait.kind !== 'autoResumeOff') {
+        const retargeted = retargetLimitWait(key, episodeId, plan.earliest);
+        if (retargeted) {
+            wait = retargeted;
+            resumeOn = plan.earliest.entry;
+        }
+    }
+    const texts = getLimitWaitTexts(key, wait, attempt, resumeOn);
+    const keyboard = plan.action === 'offer'
+        ? telegraf_1.Markup.inlineKeyboard(plan.candidates.map((entry, index) => [
+            telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.switchButton', { label: formatFallbackEntry(entry) }), (0, fallbackChain_1.buildFallbackSwitchCallbackData)(episodeId, index)),
+        ]))
+        : undefined;
+    const { isPlainNoticePosted } = await announceLimitWait(key, wait, texts, isPlainNoticeDue, keyboard);
+    if (keyboard && !isPlainNoticePosted)
+        await replyToThread(key, (0, i18n_1.t)('fallback.switchOffer'), keyboard);
+}
+/**
+ * @description Re-aim the ARMED usage-limit wait of `key` at the rung that comes back first: the timer moves to
+ * that rung's reset (+ the usual buffer), and the persisted retry record carries the rung (`resumeOn`), so the
+ * resume — also after a restart — moves the topic there before the continue nudge. `null` (nothing changed)
+ * when the wait the episode armed is gone or was replaced meanwhile.
+ */
+function retargetLimitWait(key, episodeId, earliest) {
+    const k = (0, sessionKey_1.keyToString)(key);
+    const entry = apiRetryTimers.get(k);
+    if (!entry || entry.timer === null || entry.fireAt !== episodeId || entry.kind !== 'usageLimit')
+        return null;
+    const fireAt = earliest.untilMs + apiErrorRetry_1.resetBufferMs;
+    clearTimeout(entry.timer);
+    entry.timer = setTimeout(() => { void fireApiRetry(key); }, Math.min(Math.max(fireAt - Date.now(), 0), engine_1.maxTimeoutMs));
+    entry.timer.unref?.();
+    entry.fireAt = fireAt;
+    entry.resumeOn = earliest.entry;
+    const wait = { kind: 'afterReset', resetAt: earliest.untilMs, fireAt };
+    entry.limitWait = wait;
+    void state
+        .setApiRetry(key, { kind: 'usageLimit', attempt: entry.attempt, fireAt, resumeOn: earliest.entry })
+        .catch((e) => console.error('[apiRetry] persist failed:', e));
+    return wait;
 }
 /**
  * @description A request opened during a usage-limit wait hears about it too
@@ -1280,7 +1374,7 @@ function announceLimitWaitToNewRequest(key) {
     });
     if (!wait)
         return;
-    void withThreadLocale(key, () => announceLimitWait(key, wait, getLimitWaitTexts(key, wait, armedLimit?.attempt ?? 0), false));
+    void withThreadLocale(key, () => announceLimitWait(key, wait, getLimitWaitTexts(key, wait, armedLimit?.attempt ?? 0, armedLimit?.resumeOn), false));
 }
 /**
  * @description Both texts of a limit wait, from ONE branch on how it ends, in the
@@ -1288,7 +1382,7 @@ function announceLimitWaitToNewRequest(key) {
  * `/auto_continue_limits` pointer names a Telegram command — elsewhere it would
  * be noise; the "auto-resume is off" text carries its own.
  */
-function getLimitWaitTexts(key, wait, attempt) {
+function getLimitWaitTexts(key, wait, attempt, resumeOn) {
     if (wait.kind === 'autoResumeOff') {
         const text = (0, i18n_1.t)('autoContinueLimits.limitReachedDisabled');
         // The topic text names a Telegram command; another surface's requester gets the neutral wording (Jira plan J6).
@@ -1298,12 +1392,15 @@ function getLimitWaitTexts(key, wait, attempt) {
     // R31: a tracker's requester may sit in another zone — the time names the instance's.
     const zoneSuffix = (0, sessionKeyCodec_1.checkIsTelegramKey)(key) ? '' : ` ${getCurrentTimezone()}`;
     const time = `${(0, localClock_1.formatLocalClockWithDateIfNotToday)(wait.kind === 'afterReset' ? wait.resetAt : wait.fireAt, nowMs)}${zoneSuffix}`;
-    const [noticeText, answerText] = wait.kind === 'afterReset'
-        ? [(0, i18n_1.t)('apiRetry.usageLimitResetNotice', { time }), (0, i18n_1.t)('requests.limit.answerAfterResetNotice', { time })]
-        : [
-            (0, i18n_1.t)('apiRetry.usageLimitDelayNotice', { minutes: Math.round((wait.fireAt - nowMs) / apiRetryMsPerMinute), attempt }),
-            (0, i18n_1.t)('requests.limit.answerNextAttemptNotice', { time }),
-        ];
+    const model = resumeOn ? formatFallbackEntry(resumeOn) : '';
+    const [noticeText, answerText] = wait.kind === 'afterReset' && resumeOn
+        ? [(0, i18n_1.t)('apiRetry.usageLimitResetOnRungNotice', { time, model }), (0, i18n_1.t)('requests.limit.answerAfterResetOnRungNotice', { time, model })]
+        : wait.kind === 'afterReset'
+            ? [(0, i18n_1.t)('apiRetry.usageLimitResetNotice', { time }), (0, i18n_1.t)('requests.limit.answerAfterResetNotice', { time })]
+            : [
+                (0, i18n_1.t)('apiRetry.usageLimitDelayNotice', { minutes: Math.round((wait.fireAt - nowMs) / apiRetryMsPerMinute), attempt }),
+                (0, i18n_1.t)('requests.limit.answerNextAttemptNotice', { time }),
+            ];
     const addHint = (text) => ((0, sessionKeyCodec_1.checkIsTelegramKey)(key) ? (0, autoContinueLimits_1.appendAutoContinueLimitsHint)(text) : text);
     return { plainNotice: addHint(noticeText), answerBody: addHint(answerText) };
 }
@@ -1331,6 +1428,7 @@ function cancelApiRetry(key) {
     // error — so neither can re-notify per message.
     clearLimitResumeNotice(key);
     autoContinueOffNoticedThreads.delete(k);
+    fallbackSwitchOffers.delete(k);
     // NOTE: intentionally does NOT touch the logged-out notice. `cancelApiRetry`
     // fires on EVERY inbound message (user takeover); clearing the auth notice here
     // would drop the one-notice guard so the user's next prompt (into the STILL
@@ -1516,12 +1614,18 @@ function clearLimitResumeNotice(key) {
     if (pinnedId !== pinnedNoticePendingSentinel)
         void unpinMessageQuiet(key, pinnedId);
 }
+/**
+ * Where a profile sign-in's final auth status goes: the `/account` module, built further down (it needs the
+ * sign-in driver built here), so the driver reaches it through this late-bound slot.
+ */
+let claudeProfileAuthStatusSink = null;
 // Out-of-band sign-in drivers (`/login`, `/connect` OAuth): `agentLogin/README.md`.
 const { cancelPendingLogin, checkIsAuthLoginAwaitingCode, cancelClaudeAuthLogin, startClaudeAuthLogin, submitClaudeAuthLoginCode, checkIsOpenCodeOAuthAwaitingReply, cancelOpenCodeOAuthLogin, startOpenCodeOAuthLogin, submitOpenCodeOAuthReply, } = (0, agentLogin_1.createAgentLogin)({
     replyToThread,
     deleteThreadMessage,
     clearAuthNotice,
     execFileAsync,
+    onClaudeProfileAuthStatus: (key, profile, status) => claudeProfileAuthStatusSink?.(key, profile, status) ?? Promise.resolve(),
 });
 /**
  * @description Buffers prompts typed while an agent session is still booting so
@@ -3436,6 +3540,26 @@ async function switchThreadAdapter(key, newName) {
         next.claudeSessionId = agent.claudeSessionId;
     if (newName === adapterNames_1.openCodeAdapterName && agent.opencodeSessionId)
         next.opencodeSessionId = agent.opencodeSessionId;
+    // The id of the family the thread LEAVES is parked, and the parked id of the family it RETURNS to is
+    // restored (`state.parkedSessions`): a cross-backend fallback switch — or a plain /claude ↔ /opencode — can
+    // come back to the conversation it left (L-D4: a sleeping conversation is woken, `/new` is the fresh start).
+    // The reattach loop never reads the parked slot, so the audit S12 bug (both ids on the live row) stays fixed.
+    const parked = state.getParkedSession(key);
+    const parkedAt = new Date().toISOString();
+    if (prevName && (0, createAdapter_1.checkIsClaudeBackend)(prevName) && !(0, createAdapter_1.checkIsClaudeBackend)(newName) && agent.claudeSessionId) {
+        await state.setParkedSession(key, { adapterName: prevName, claudeSessionId: agent.claudeSessionId, parkedAt });
+    }
+    else if (prevName === adapterNames_1.openCodeAdapterName && newName !== adapterNames_1.openCodeAdapterName && agent.opencodeSessionId) {
+        await state.setParkedSession(key, { adapterName: prevName, opencodeSessionId: agent.opencodeSessionId, parkedAt });
+    }
+    else if (parked && (0, createAdapter_1.checkIsClaudeBackend)(newName) && !next.claudeSessionId && parked.claudeSessionId) {
+        next.claudeSessionId = parked.claudeSessionId;
+        await state.setParkedSession(key, null);
+    }
+    else if (parked && newName === adapterNames_1.openCodeAdapterName && !next.opencodeSessionId && parked.opencodeSessionId) {
+        next.opencodeSessionId = parked.opencodeSessionId;
+        await state.setParkedSession(key, null);
+    }
     // Overwrite by removing the row first; setAgent then writes only the
     // fields we kept.
     await state.removeAgent(key);
@@ -4375,11 +4499,20 @@ command('status', async (_ctx, key) => {
         });
     }
     const timezone = getCurrentTimezone();
+    const nowMs = Date.now();
+    // A Claude topic runs on an account PROFILE: the live process's, which a deferred switch keeps apart from the
+    // topic's pick. An OpenCode topic gets no row — its `provider/model` label already names the provider.
+    let account = null;
+    if (adapterName && checkIsClaudeProfileBackend(key)) {
+        const live = resolveLiveClaudeProfileName(key);
+        const picked = state.resolveClaudeProfileName(key);
+        account = { current: readStatusAccountSource(live), pending: picked === live ? null : readStatusAccountSource(picked), nowMs };
+    }
     await replyToThread(key, (0, threadStatusReport_1.getThreadStatusReport)({
-        agentLine, subdir, isActive, isSleeping: !isActive && getResumableSessionId(key) !== null, workDir, model, effort, startedAt, runtime,
+        agentLine, subdir, isActive, isSleeping: !isActive && getResumableSessionId(key) !== null, workDir, model, effort, startedAt, runtime, account,
         view: (0, displayModes_1.formatTopicView)(state.getDisplayPrefs(key).view),
         timezone,
-        timezoneNow: (0, timezone_1.formatZoneNow)(timezone, Date.now()),
+        timezoneNow: (0, timezone_1.formatZoneNow)(timezone, nowMs),
     }));
 });
 /** The `/language` argument: the first token, lower-cased (locale codes are case-insensitive). */
@@ -5329,7 +5462,7 @@ async function handleAgentStart(key, adapterName, args) {
 function handleStartCommand(parsed, key, adapterName) {
     return handleAgentStart(key, adapterName, parsed.argsText || undefined);
 }
-const { handleProviderConnectKey, applyNumberedModelPick, registerProviderCommands, registerModelCommands, registerModelCallbacks, } = (0, modelProviders_1.createModelProviders)({
+const { showConnectMethodPicker, applyProviderDisconnect, handleProviderConnectKey, applyNumberedModelPick, registerProviderCommands, registerModelCommands, registerModelCallbacks, } = (0, modelProviders_1.createModelProviders)({
     ...botCore,
     awaitingModelSelection,
     awaitingSessionSelection,
@@ -5458,13 +5591,460 @@ command('rename_session', async (_ctx, key, parsed) => {
     await replyToThread(key, (0, i18n_1.t)('rename_session.success', { title }));
     await updatePinnedStatus(key).catch(() => { });
 });
-const { consumeAutoContinueLimitsPicker, registerAutoContinueLimitsCommands, registerAutoContinueLimitsCallbacks, } = (0, autoContinueLimits_1.createAutoContinueLimits)({
+const { applyAutoContinueLimits, consumeAutoContinueLimitsPicker, registerAutoContinueLimitsCommands, registerAutoContinueLimitsCallbacks, } = (0, autoContinueLimits_1.createAutoContinueLimits)({
     ...botCore,
+    openLimitsView: (key) => openLimitsView(key),
     getArmedLimitRetryFireAt,
     cancelApiRetry,
     getRequestWakeUpEngine: () => requestWakeUpEngine,
 });
 registerAutoContinueLimitsCommands();
+// ── Claude account profiles (`/account`): `utils/claudeProfiles.ts`, `commands/claudeAccounts.ts` ──
+/**
+ * @description The Claude config directory a conversation's NEXT process starts with: its resolved account
+ * profile's directory, `null` for the default profile. Registered as the adapters' reader at boot. A profile
+ * whose directory vanished (a hand-cleaned `DATA_DIR`) runs on the default rather than failing the spawn.
+ */
+function resolveThreadClaudeConfigDir(key) {
+    const name = state.resolveClaudeProfileName(key);
+    const dir = (0, claudeProfiles_1.resolveClaudeProfileDir)((0, state_1.resolveDataDir)(), name);
+    if (dir !== null && !fs.existsSync(dir)) {
+        console.warn(`[account] ${(0, sessionKey_1.keyToString)(key)}: the directory of profile ${name} is missing; its process runs on the default profile`);
+        return null;
+    }
+    return dir;
+}
+/** `claude auth status --json` under `configDir` (`null` = `~/.claude`), the subscription login only; `null` when the probe fails. */
+async function readClaudeAuthStatusUnder(configDir) {
+    const env = { ...process.env };
+    delete env.ANTHROPIC_API_KEY;
+    if (configDir !== null)
+        env[claudeProfiles_1.claudeConfigDirVariableName] = configDir;
+    try {
+        const { stdout } = await execFileAsync((0, resolveBinary_1.resolveClaudeBinary)(), ['auth', 'status', '--json'], { timeout: claudeAuthStatusProbeTimeoutMs, env });
+        return (0, claudeProfiles_1.parseClaudeAuthStatus)(stdout);
+    }
+    catch (e) {
+        // A logged-out directory makes the CLI exit non-zero WITH its JSON on stdout: that is the answer.
+        return (0, claudeProfiles_1.parseClaudeAuthStatus)((0, claudeProfiles_1.readProcessErrorStdout)(e));
+    }
+}
+const claudeAuthStatusProbeTimeoutMs = 5000;
+/**
+ * @description Bring ONE conversation's live Claude session onto the profile it resolves to now. json-stream
+ * re-spawns the process with `--resume` when idle and defers to turn end when it works (the adapter owns
+ * that); the tmux TUI is reopened under the new environment when idle (`resumeSession` kills and recreates the
+ * pane, same conversation) and left alone when busy — its next start or resume applies the pick. Any other
+ * backend has no Claude process to move.
+ */
+async function applyClaudeProfileToThread(key, options = {}) {
+    const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+    if (adapter instanceof claudeJsonStreamAdapter_1.ClaudeJsonStreamAdapter)
+        return adapter.applyClaudeConfigDir(key, options);
+    if (!(adapter instanceof claudeCliAdapter_1.ClaudeCliAdapter))
+        return 'inactive';
+    const current = adapter.getSessionClaudeConfigDir(key);
+    if (current === undefined)
+        return 'inactive';
+    if (current === resolveThreadClaudeConfigDir(key))
+        return 'unchanged';
+    // After a usage limit the turn is dead: the pane is reopened even though it looks busy.
+    if (!options.isAfterLimit && adapter.checkIsBusy(key))
+        return 'restartRequired';
+    const sessionId = state.getAgent(key)?.claudeSessionId;
+    const decision = getWorkDirStartDecision(key);
+    if (!sessionId || !decision.ok)
+        return 'restartRequired';
+    markNeedsNewMessage(key);
+    await adapter.resumeSession(key, decision.workDir, sessionId);
+    await persistSessionStart(key, adapter);
+    return 'respawned';
+}
+/** After a General pick, a removal or a sign-in: every served conversation follows its resolved profile. */
+async function applyClaudeProfileEverywhere() {
+    for (const { key } of getServedBindings()) {
+        try {
+            await applyClaudeProfileToThread(key);
+        }
+        catch (e) {
+            console.warn(`[account] ${(0, sessionKey_1.keyToString)(key)}: moving the session onto its profile failed:`, e instanceof Error ? e.message : e);
+        }
+    }
+}
+/**
+ * The per-profile usage cache (`utils/claudeUsageRefresher.ts`): every signed-in profile's windows off the
+ * OAuth usage endpoint on a 10-minute timer, on `/account` open and on a `claude_profiles` call, plus the
+ * `rate_limit_event` frames the json-stream sessions report. Snapshots live on the profile records.
+ */
+const claudeUsageRefresher = (0, claudeUsageRefresher_1.createClaudeUsageRefresher)({
+    listProfiles: () => [
+        { name: claudeProfiles_1.defaultClaudeProfileName, configDir: null, loggedIn: state.getClaudeProfileInfo(claudeProfiles_1.defaultClaudeProfileName)?.loggedIn },
+        ...Object.entries(state.getClaudeProfileRecords()).map(([name, record]) => ({
+            name, configDir: (0, claudeProfiles_1.resolveClaudeProfileDir)((0, state_1.resolveDataDir)(), name), loggedIn: record.loggedIn,
+        })),
+    ],
+    getSnapshot: (name) => state.getClaudeProfileInfo(name)?.usage,
+    saveSnapshot: (name, snapshot) => state.setClaudeProfileUsage(name, snapshot),
+    readToken: (configDir) => (0, claudeUsage_1.readClaudeOAuthToken)(configDir),
+    fetchUsage: (accessToken) => (0, claudeUsage_1.fetchClaudeUsage)(accessToken),
+});
+/** The profile that owns a config directory (`null` = default); `null` for a directory outside the profiles root. */
+function resolveClaudeProfileNameForDir(configDir) {
+    if (configDir === null)
+        return claudeProfiles_1.defaultClaudeProfileName;
+    const root = (0, claudeProfiles_1.resolveClaudeProfilesRoot)((0, state_1.resolveDataDir)());
+    if (path.dirname(configDir) !== root)
+        return null;
+    const name = path.basename(configDir);
+    return state.getClaudeProfileRecord(name) ? name : null;
+}
+/**
+ * A json-stream session's `rate_limit_event`: its windows refresh the owning profile's snapshot; a REJECTED
+ * request marks the profile limited until the window resets (the `claude_profiles` ranking skips it; the
+ * auto-switch phase will act on the same mark), an allowed one clears a stale mark.
+ */
+function onClaudeRateLimitEvent(configDir, event) {
+    const name = resolveClaudeProfileNameForDir(configDir);
+    if (name === null)
+        return;
+    claudeUsageRefresher.noteStreamWindows(name, event.windows);
+    if (event.status === 'rejected' && event.resetsAtMs !== null) {
+        state.setClaudeProfileLimitedUntil(name, new Date(event.resetsAtMs).toISOString());
+    }
+    else if (event.status === 'allowed' && state.getClaudeProfileInfo(name)?.limitedUntil) {
+        state.setClaudeProfileLimitedUntil(name, null);
+    }
+}
+/** The model a topic's Claude session runs (or last ran), for the usage ranking's choice of windows. */
+function getThreadClaudeModel(key) {
+    return (0, createAdapter_1.getThreadAdapter)(key).getCurrentModel?.(key) ?? state.getAgent(key)?.model ?? null;
+}
+/** What `/status` names of a Claude profile: its last probed sign-in and email, and its limit mark (none until probed). */
+function readStatusAccountSource(name) {
+    const info = state.getClaudeProfileInfo(name);
+    return { name, email: info?.email ?? null, loggedIn: info?.loggedIn, limitedUntil: info?.limitedUntil ?? null };
+}
+/** Whether the topic's agent is a Claude backend (a usage limit there is a limit of its account profile). */
+function checkIsClaudeProfileBackend(key) {
+    const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+    return adapter instanceof claudeJsonStreamAdapter_1.ClaudeJsonStreamAdapter || adapter instanceof claudeCliAdapter_1.ClaudeCliAdapter;
+}
+// ── the fallback chain (`/fallback`): `utils/fallbackChain.ts`, `utils/fallbackBridge.ts`, `commands/fallbackChain.ts` ──
+/** A chain rung for the topic's own language (the picker and the notices name it the same way). */
+function formatFallbackEntry(entry) {
+    return (0, fallbackChain_1.formatFallbackEntryLabel)(entry, { claude: (0, i18n_1.t)('fallback.backendClaude'), openCode: (0, i18n_1.t)('fallback.backendOpenCode'), topicModel: (0, i18n_1.t)('fallback.topicModel') });
+}
+/**
+ * @description What is connected NOW — the input of the chain draft, the picker rows and the ranking: every
+ * Claude profile with its usage view, the OpenCode models the server is authenticated for (its live catalog —
+ * `opencode models` lists only providers with credentials; an absent or failing CLI yields none), the models
+ * topics recently picked (newest first) and the OpenCode limit marks.
+ */
+async function detectFallbackOptions() {
+    let openCodeModels = [];
+    try {
+        openCodeModels = (await (0, createAdapter_1.getAdapter)(adapterNames_1.openCodeAdapterName).getAvailableModels?.()) ?? [];
+    }
+    catch (e) {
+        console.warn('[fallback] the OpenCode catalog is unavailable:', e instanceof Error ? e.message : e);
+    }
+    return {
+        claudeProfiles: (0, claudeUsage_1.buildClaudeProfileUsageViews)({ dataDir: (0, state_1.resolveDataDir)(), records: state.getAllClaudeProfileInfos() }),
+        openCodeModels,
+        recentOpenCodeModels: (0, openCodeAdapter_1.listSavedOpenCodeModelLabels)().reverse(),
+        openCodeLimits: state.getOpenCodeModelLimits(),
+    };
+}
+/**
+ * @description The profile the topic's LIVE Claude process runs on (the config directory it was spawned with),
+ * which differs from the topic's pick while a switch is deferred or the pick was never applied. The pick when
+ * there is no live process or its directory maps to no known profile.
+ */
+function resolveLiveClaudeProfileName(key) {
+    const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+    if (adapter instanceof claudeJsonStreamAdapter_1.ClaudeJsonStreamAdapter || adapter instanceof claudeCliAdapter_1.ClaudeCliAdapter) {
+        const dir = adapter.getSessionClaudeConfigDir(key);
+        if (dir !== undefined) {
+            const live = resolveClaudeProfileNameForDir(dir);
+            if (live !== null)
+                return live;
+        }
+    }
+    return state.resolveClaudeProfileName(key);
+}
+/**
+ * @description An `/account` pick on a topic: the plain apply, except while a usage-limit wait is armed and the
+ * pick moves the topic off the profile its process runs on. The process cannot work on the limited account, so
+ * the pick is applied NOW and the topic resumes like after a limit switch (wait cancelled, continue nudge).
+ */
+async function applyClaudePickToThread(key) {
+    const armed = getArmedApiRetry(key);
+    if (armed?.kind === 'usageLimit' && checkIsClaudeProfileBackend(key)) {
+        const from = getTopicFallbackPosition(key);
+        const to = state.resolveClaudeProfileName(key);
+        if (from !== null && from.backend === 'claude' && from.profile !== to) {
+            const { isSwitched } = await switchTopicToFallbackEntry(key, from, { backend: 'claude', profile: to, model: null }, { isAnnounced: true });
+            return isSwitched ? 'respawned' : 'deferred';
+        }
+    }
+    return applyClaudeProfileToThread(key);
+}
+/**
+ * @description The rung a topic runs on now: its Claude profile and model on a Claude backend, its
+ * `provider/model` on OpenCode (`null` while OpenCode runs the server default — nothing to mark or compare),
+ * `null` for a terminal or no agent.
+ */
+function getTopicFallbackPosition(key) {
+    if (checkIsClaudeProfileBackend(key))
+        return { backend: 'claude', profile: resolveLiveClaudeProfileName(key), model: getThreadClaudeModel(key) };
+    const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+    if (adapter.name !== adapterNames_1.openCodeAdapterName)
+        return null;
+    const label = adapter.getCurrentModel?.(key);
+    const parsed = label ? (0, fallbackChain_1.parseOpenCodeModelLabel)(label) : null;
+    return parsed ? { backend: 'opencode', ...parsed } : null;
+}
+/**
+ * @description What a usage limit on `key` leads to (`utils/fallbackChain.ts`): the rung the topic is on is
+ * marked limited until the reset the error named (a Claude profile: else its session window, else the retry's
+ * blind delay; an OpenCode model: else the blind delay), the usage snapshots are brought up to date, and the
+ * chain's AVAILABLE rungs are listed in priority order. Without a configured chain a Claude topic falls back to
+ * the within-Claude headroom ranking (`utils/claudeLimitSwitch.ts`) — the behaviour before the chain existed. An
+ * offer is remembered per thread under its episode so only ITS buttons can act on it. `none` for a non-Telegram
+ * conversation, a topic with no account to switch from, or when no rung can take over.
+ */
+async function planFallbackSwitch(key, cls, episodeId) {
+    const from = getTopicFallbackPosition(key);
+    if (!(0, sessionKeyCodec_1.checkIsTelegramKey)(key) || from === null)
+        return { action: 'none', from, earliest: null };
+    const k = (0, sessionKey_1.keyToString)(key);
+    const nowMs = Date.now();
+    const resetAtMs = cls.kind === 'usageLimit' ? cls.resetAt : undefined;
+    if (from.backend === 'claude') {
+        state.setClaudeProfileLimitedUntil(from.profile, (0, claudeLimitSwitch_1.resolveClaudeLimitedUntil)({
+            resetAtMs,
+            usage: state.getClaudeProfileInfo(from.profile)?.usage,
+            existingLimitedUntil: state.getClaudeProfileInfo(from.profile)?.limitedUntil ?? null,
+            nowMs,
+            fallbackMs: apiErrorRetry_1.usageLimitDefaultMs,
+        }));
+    }
+    else {
+        const label = (0, fallbackChain_1.buildOpenCodeModelLabel)(from);
+        state.setOpenCodeModelLimitedUntil(label, (0, fallbackChain_1.resolveOpenCodeLimitedUntil)({
+            resetAtMs,
+            existingLimitedUntil: state.getOpenCodeModelLimitedUntil(label),
+            nowMs,
+            fallbackMs: apiErrorRetry_1.usageLimitDefaultMs,
+        }));
+    }
+    // The Claude rungs are judged on fresh figures whatever backend hit the limit (a minute's cache).
+    await claudeUsageRefresher.refreshAll({ maxAgeMs: claudeUsageRefresher_1.claudeUsageOnDemandMaxAgeMs });
+    const detection = await detectFallbackOptions();
+    let chain = state.getFallbackChain();
+    if (chain.length === 0 && from.backend === 'claude') {
+        chain = (0, claudeLimitSwitch_1.pickClaudeLimitSwitchCandidates)({ profiles: detection.claudeProfiles, currentName: from.profile, model: from.model, nowMs: Date.now() })
+            .map((profile) => ({ backend: 'claude', profile, model: null }));
+    }
+    const candidates = (0, fallbackChain_1.pickFallbackCandidates)({ chain, current: from, detection, nowMs: Date.now() });
+    const plan = (0, fallbackChain_1.decideFallbackSwitch)({ candidates, isAutoSwitchEnabled: state.checkIsClaudeAutoSwitchOnLimitEnabled(key) });
+    if (plan.action === 'offer')
+        fallbackSwitchOffers.set(k, { episodeId, from, candidates: plan.candidates });
+    else
+        fallbackSwitchOffers.delete(k);
+    const detail = plan.action === 'auto' ? ` → ${formatFallbackEntry(plan.to)}` : plan.action === 'offer' ? ` [${plan.candidates.map(formatFallbackEntry).join(', ')}]` : '';
+    // Nothing has room: the wait should end on the rung whose limit resets EARLIEST, not necessarily this one.
+    let earliest = null;
+    if (plan.action === 'none') {
+        const explicit = state.getFallbackChain();
+        const rungs = explicit.length > 0 ? explicit : from.backend === 'claude'
+            ? detection.claudeProfiles.filter((profile) => profile.loggedIn !== false).map((profile) => ({ backend: 'claude', profile: profile.name, model: null }))
+            : [];
+        const found = (0, fallbackChain_1.pickEarliestResetRung)({ chain: rungs, current: from, detection, nowMs: Date.now() });
+        if (found && !found.isCurrent)
+            earliest = { entry: found.entry, untilMs: found.untilMs };
+    }
+    console.log(`[fallback] ${k}: usage limit on ${formatFallbackEntry(from)}; switch plan: ${plan.action}${detail}${earliest ? `; earliest reset: ${formatFallbackEntry(earliest.entry)} at ${new Date(earliest.untilMs).toISOString()}` : ''}`);
+    return { ...plan, from, earliest };
+}
+/** When the rung that hit the limit comes back, as a clock in the topic's zone; `null` when unknown or past. */
+function getFallbackResetTime(from) {
+    if (from === null)
+        return null;
+    const until = from.backend === 'claude'
+        ? state.getClaudeProfileInfo(from.profile)?.limitedUntil ?? null
+        : state.getOpenCodeModelLimitedUntil((0, fallbackChain_1.buildOpenCodeModelLabel)(from)) ?? null;
+    const untilMs = until === null ? Number.NaN : Date.parse(until);
+    if (!Number.isFinite(untilMs) || untilMs <= Date.now())
+        return null;
+    return (0, localClock_1.formatLocalClockWithDateIfNotToday)(untilMs, Date.now());
+}
+/** The one-line «switched» notice, with the reset of the exhausted rung when known (the topic is never moved back by itself). */
+function getFallbackSwitchedNotice(from, to) {
+    const fromLabel = from ? formatFallbackEntry(from) : '?';
+    const toLabel = formatFallbackEntry(to);
+    const time = getFallbackResetTime(from);
+    const reset = time === null ? '' : (0, i18n_1.t)('fallback.switchedReset', { from: fromLabel, to: toLabel, time });
+    return (0, i18n_1.t)('fallback.switched', { from: fromLabel, to: toLabel, reset });
+}
+/** Whether the topic's Claude session already runs the alias (`fable` against a reported `claude-fable-5-1`). */
+function checkThreadClaudeModelMatches(key, alias) {
+    const current = getThreadClaudeModel(key);
+    return current !== null && current.toLowerCase().includes(alias.toLowerCase());
+}
+/**
+ * @description The context bridge for a cross-backend switch (`utils/fallbackBridge.ts`), built BEFORE the old
+ * adapter is stopped: its last turns off its own transcript (an unreadable one yields a bridge without turns).
+ */
+async function buildFallbackBridge(key, from, to) {
+    const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+    const decision = getWorkDirStartDecision(key);
+    const sessionId = (0, ensureSessionPlan_1.getPersistedSessionIdForAdapter)(state.getAgent(key) ?? null, adapter.name, (0, createAdapter_1.checkIsClaudeBackend)(adapter.name));
+    let turns = [];
+    if (decision.ok && sessionId && adapter.getRecentTurns) {
+        try {
+            turns = await adapter.getRecentTurns(key, decision.workDir, sessionId, fallbackBridge_1.fallbackBridgeTurnLimit);
+        }
+        catch (e) {
+            console.warn(`[fallback] ${(0, sessionKey_1.keyToString)(key)}: the previous agent's turns are unreadable:`, e instanceof Error ? e.message : e);
+        }
+    }
+    return (0, fallbackBridge_1.buildFallbackBridgePrompt)({
+        fromLabel: from ? formatFallbackEntry(from) : (0, i18n_1.t)('fallback.backendClaude'),
+        toLabel: formatFallbackEntry(to),
+        turns,
+        resetsAtText: getFallbackResetTime(from),
+        replyLanguage: (0, i18n_1.getLocaleEndonym)((0, i18n_1.getActiveLang)()),
+    });
+}
+/**
+ * @description Move a limited topic onto rung `to` and continue the work there. WITHIN a backend the
+ * conversation is kept: a Claude rung sets the topic's profile (the `/account` apply path re-spawns the live
+ * session under the new directory, same transcript) and pins the rung's model when it names one; an OpenCode
+ * rung changes the session's per-prompt model. ACROSS backends the topic's adapter changes (the `/claude` /
+ * `/opencode` path: the old session is stopped and its id parked for a switch back), the new session is started
+ * or resumed, and its first prompt is the context bridge instead of the plain "continue" nudge. Either way the
+ * armed limit wait is disarmed and the prompt goes the way the wait's own resume would deliver it. A Claude
+ * session that works keeps its wait: the switch applies at turn end. Returns whether the work continues now and
+ * the notice that says so (posted here only when `isAnnounced` — the auto-switch has no other voice, while a
+ * tapped button's notice is edited into the same line by its handler).
+ */
+async function switchTopicToFallbackEntry(key, from, to, options) {
+    const k = (0, sessionKey_1.keyToString)(key);
+    const fromLabel = from ? formatFallbackEntry(from) : '?';
+    const toLabel = formatFallbackEntry(to);
+    const isSameFamily = from !== null && from.backend === to.backend;
+    const say = async (notice) => {
+        if (options.isAnnounced)
+            await replyToThread(key, notice);
+    };
+    const fail = async (error) => {
+        const notice = (0, i18n_1.t)('fallback.switchFailed', { to: toLabel, error });
+        await say(notice);
+        return { isSwitched: false, notice };
+    };
+    let firstPrompt = null;
+    let isStoppingBackground = false;
+    if (isSameFamily && to.backend === 'claude') {
+        await state.setClaudeProfileOverride(key, to.profile);
+        // The turn is dead after a limit: re-spawn now, even over background work (it is stopped; the notice says so).
+        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+        isStoppingBackground = adapter instanceof claudeJsonStreamAdapter_1.ClaudeJsonStreamAdapter && adapter.checkHasBackgroundWork(key);
+        const outcome = await applyClaudeProfileToThread(key, { isAfterLimit: true });
+        if (outcome === 'deferred' || outcome === 'restartRequired') {
+            fallbackSwitchOffers.delete(k);
+            const notice = (0, i18n_1.t)('fallback.switchedDeferred', { from: fromLabel, to: toLabel });
+            await say(notice);
+            return { isSwitched: false, notice };
+        }
+    }
+    else if (isSameFamily && to.backend === 'opencode') {
+        const error = await (0, createAdapter_1.getThreadAdapter)(key).setModel?.(key, (0, fallbackChain_1.buildOpenCodeModelLabel)(to));
+        if (error)
+            return fail(error);
+    }
+    else {
+        const bridge = await buildFallbackBridge(key, from, to);
+        const targetName = to.backend === 'claude' ? (0, createAdapter_1.resolveClaudeBackendName)(key) : adapterNames_1.openCodeAdapterName;
+        if (to.backend === 'claude')
+            await state.setClaudeProfileOverride(key, to.profile);
+        await switchThreadAdapter(key, targetName);
+        if (to.backend === 'opencode') {
+            const error = await (0, createAdapter_1.getThreadAdapter)(key).setModel?.(key, (0, fallbackChain_1.buildOpenCodeModelLabel)(to));
+            if (error)
+                return fail(error);
+        }
+        firstPrompt = { text: bridge, isRequestPrompt: false };
+    }
+    cancelApiRetry(key); // retires the offer too: the switch consumed it
+    const notice = `${getFallbackSwitchedNotice(from, to)}${isStoppingBackground ? ` ${(0, i18n_1.t)('fallback.backgroundStopped')}` : ''}`;
+    console.log(`[fallback] ${k}: switched from ${fromLabel} to ${toLabel} after a usage limit${firstPrompt ? ' (cross-backend, bridged)' : ''}; resuming`);
+    await say(notice);
+    const ensured = await ensureAgentSession(key);
+    if (!ensured.ok) {
+        await replyToThread(key, ensured.message);
+        return { isSwitched: true, notice };
+    }
+    if (ensured.message)
+        await replyToThread(key, ensured.message);
+    if (to.backend === 'claude' && to.model !== null && !checkThreadClaudeModelMatches(key, to.model)) {
+        const error = await (0, createAdapter_1.getThreadAdapter)(key).setModel?.(key, to.model);
+        if (error)
+            console.warn(`[fallback] ${k}: pinning the model ${to.model} failed: ${error}`);
+    }
+    const prompt = firstPrompt ?? (0, limitHeldPrompts_1.getLimitResumeMessage)({
+        continueNudge: (0, i18n_1.t)('apiRetry.continueNudge'),
+        untakenRequestPrompt: (0, requestHeader_1.joinPromptsNotTakenIn)(requestLimitWaitAnswerDeps?.ledger.listOpenRequestsOf(key) ?? []),
+    });
+    await deliverPromptOrBuffer(key, prompt.text, startupPromptBuffer.checkIsStarting(k));
+    await requestWakeUpEngine?.trackContinuationTurn(key, { isCountersReset: true, isRequestPrompt: prompt.isRequestPrompt });
+    return { isSwitched: true, notice };
+}
+/**
+ * @description A tap on a «switch to …» button of a limit notice: honoured only while the thread's open offer
+ * is the button's episode and the index is inside that offer (a stale notice changes nothing). The
+ * confirmation to edit the notice into, or `null` when the tap expired.
+ */
+async function takeFallbackSwitchOffer(key, episodeId, index) {
+    const offer = fallbackSwitchOffers.get((0, sessionKey_1.keyToString)(key)) ?? null;
+    const decision = (0, fallbackChain_1.getFallbackSwitchTapDecision)({ openOffer: offer, requestedEpisodeId: episodeId, index });
+    if (decision.kind === 'expired' || offer === null)
+        return null;
+    const { notice } = await switchTopicToFallbackEntry(key, offer.from, decision.to, { isAnnounced: false });
+    return notice;
+}
+/** The `claude_profiles` MCP tool's answer: snapshots refreshed on demand (a minute's cache), then the ranking. */
+async function listClaudeProfilesForAgent(model) {
+    await claudeUsageRefresher.refreshAll({ maxAgeMs: claudeUsageRefresher_1.claudeUsageOnDemandMaxAgeMs });
+    return (0, claudeUsage_1.buildClaudeProfilesReport)((0, claudeUsage_1.buildClaudeProfileUsageViews)({ dataDir: (0, state_1.resolveDataDir)(), records: state.getAllClaudeProfileInfos() }), model, Date.now());
+}
+const { registerFallbackChainCommands, registerFallbackChainCallbacks, openLimitsView, applyAutoSwitch } = (0, fallbackChain_2.createFallbackChain)({
+    ...botCore,
+    applyAutoContinue: applyAutoContinueLimits,
+    getArmedLimitRetryFireAt,
+    getInstanceTimezone: getCurrentTimezone,
+    refreshClaudeUsage: (options) => claudeUsageRefresher.refreshAll(options),
+    detectFallbackOptions,
+    getTopicPosition: getTopicFallbackPosition,
+    takeSwitchOffer: takeFallbackSwitchOffer,
+});
+const { registerClaudeAccountCommands, registerClaudeAccountCallbacks, checkIsAwaitingProfileName, cancelProfileNameCapture, submitProfileName, onClaudeProfileAuthStatus: recordClaudeProfileAuthStatus, } = (0, claudeAccounts_1.createClaudeAccounts)({
+    ...botCore,
+    getDataDir: state_1.resolveDataDir,
+    getInstanceTimezone: getCurrentTimezone,
+    refreshClaudeUsage: (options) => claudeUsageRefresher.refreshAll(options),
+    readClaudeAuthStatus: readClaudeAuthStatusUnder,
+    startClaudeProfileLogin: (key, profile) => startClaudeAuthLogin(key, profile),
+    applyClaudeProfile: applyClaudePickToThread,
+    applyClaudeProfileEverywhere,
+    detectOpenCodeProviders: async () => (0, fallbackChain_1.listOpenCodeProviders)((await (0, createAdapter_1.getAdapter)(adapterNames_1.openCodeAdapterName).getAvailableModels?.()) ?? []),
+    disconnectOpenCodeProvider: applyProviderDisconnect,
+    startOpenCodeConnect: showConnectMethodPicker,
+    applyAutoSwitch,
+});
+claudeProfileAuthStatusSink = recordClaudeProfileAuthStatus;
+registerClaudeAccountCommands();
+registerFallbackChainCommands();
 registerCompactionCommands();
 /**
  * @description Build the agent-picker keyboard.
@@ -5759,8 +6339,12 @@ command('tab', async (_ctx, key) => {
         await replyToThread(key, `Not supported for ${adapter.label}`);
 });
 command(['esc', 'escape'], async (_ctx, key) => {
-    // A pending sign-in (`/login`, `/connect` OAuth) takes priority: the first /esc
-    // only cancels it, so the topic stops waiting for a pasted code.
+    // A pending «Add account» name prompt, then a pending sign-in (`/login`, `/connect` OAuth) take
+    // priority: the first /esc only cancels it, so the topic stops waiting for typed input.
+    if (cancelProfileNameCapture(key)) {
+        await replyToThread(key, (0, i18n_1.t)('account.askNameCancelled'));
+        return;
+    }
     if (cancelPendingLogin(key)) {
         await replyToThread(key, (0, i18n_1.t)('login.cancelled'));
         return;
@@ -6043,8 +6627,8 @@ const botCommands = new Set([
     'start', 'claude', 'opencode', 'oc', 'terminal', 'agent', 'sessions', 'resume', 'cancel', 'model', 'connect',
     'disconnect', 'stop', 'stopall', 'stop-all', 'status', 'c', 'y', 'n', 'enter', 'up', 'down', 'tab', 'esc', 'escape', 'output', 'clear_messages',
     'bind', 'unbind', 'where', 'ls', 'list', 'new', 'clear_session', 'whoami', 'version', 'help', 'language', 'lang',
-    'doctor', 'mcp', 'rename_session', 'compact', 'compact_on_idle', 'compact_summary', 'auto_continue_limits', 'trace', 'timestamps', 'timezone', 'schedule', 'reminders', 'thinking', 'tool_results',
-    'subagent', 'claude_mode', 'effort', 'verbosity', 'quit', 'q', 'quit-all', 'quitall', 'pair',
+    'doctor', 'mcp', 'rename_session', 'compact', 'compact_on_idle', 'compact_summary', 'auto_continue_limits', 'limits', 'trace', 'timestamps', 'timezone', 'schedule', 'reminders', 'thinking', 'tool_results',
+    'subagent', 'claude_mode', 'effort', 'verbosity', 'quit', 'q', 'quit-all', 'quitall', 'pair', 'account', 'accounts', 'fallback',
 ]);
 /**
  * @description The bare `/clear` is no longer bot-owned (it was renamed to
@@ -6075,6 +6659,8 @@ bot.on((0, filters_1.message)('text'), async (ctx) => {
     // Slash commands we don't own → forward to the agent (e.g. `/context`, `/help`).
     if (text.startsWith('/')) {
         const cmd = text.slice(1).split(' ')[0].split('@')[0].toLowerCase();
+        // A slash command ends a pending «Add account» name prompt (the command itself runs normally).
+        cancelProfileNameCapture(key);
         if (botCommands.has(cmd))
             return;
         // `/login` on a json-stream Claude thread (idle or per-turn lifecycle) has no
@@ -6118,6 +6704,12 @@ bot.on((0, filters_1.message)('text'), async (ctx) => {
         await submitOpenCodeOAuthReply(key, text, ctx.message.message_id);
         return;
     }
+    // `/account` «Add» asked for the new profile's name → this message is it (a bad name keeps the prompt
+    // armed and says so; a slash command above already disarmed it).
+    if (checkIsAwaitingProfileName(key) && !text.startsWith('/')) {
+        await submitProfileName(key, text);
+        return;
+    }
     // Safety net: a pasted OAuth callback URL with NO flow in progress (e.g. a
     // stale one from a browser that timed out, or a re-paste after the flow ended)
     // must NOT be forwarded to the agent as a prompt — that both leaks the code
@@ -7220,6 +7812,8 @@ bot.action(timezonePicker_1.zonePickCallbackRe, async (ctx) => {
 registerModelCallbacks();
 registerCompactionCallbacks();
 registerAutoContinueLimitsCallbacks();
+registerClaudeAccountCallbacks();
+registerFallbackChainCallbacks();
 // «⏭ Skip once» in the `/auto_continue_limits` picker: drop THIS armed resume and
 // leave the on/off setting alone. The episode is identified by the `fireAt` baked
 // into the callback data, so an untouched older picker can never cancel a LATER
@@ -8873,8 +9467,6 @@ exports.COMMANDS_MENU = [
     { command: 'mcp', description: '🔌 List active MCP servers' },
     { command: 'claude', description: '▶️ Start Claude Code' },
     { command: 'opencode', description: '▶️ Start OpenCode' },
-    { command: 'connect', description: '🔑 Connect an OpenCode provider API key' },
-    { command: 'disconnect', description: '🔌 Disconnect an OpenCode provider' },
     { command: 'terminal', description: '🖥 Open a raw shell in the bound folder' },
     { command: 'claude_mode', description: '🔀 Claude backend: json-stream ⇄ per-turn ⇄ tmux-scrape' },
     { command: 'new', description: '🆕 Restart session (alias /clear_session)' },
@@ -8893,7 +9485,8 @@ exports.COMMANDS_MENU = [
     { command: 'compact', description: '🧹 Compact agent context' },
     { command: 'compact_on_idle', description: '🧹 Auto-compact after idle (toggle)' },
     { command: 'compact_summary', description: '📄 Post the compaction summary (toggle)' },
-    { command: 'auto_continue_limits', description: '🚧 Auto-resume after a usage limit (toggle)' },
+    { command: 'accounts', description: '👤 Claude accounts and OpenCode providers (pick, add, re-login, remove, connect, disconnect)' },
+    { command: 'limits', description: '🚧 What happens when an agent hits a usage limit' },
     { command: 'schedule', description: '⏰ Schedule a prompt (agent does the work)' },
     { command: 'reminders', description: '🔔 Reminders — add, list, delete (no agent)' },
     { command: 'status', description: '📊 Show status' },
@@ -9084,6 +9677,13 @@ async function reattachExistingSessions(opts = { quietReattach: false }) {
                     const preAdoptWatermark = state.getAgent(key)?.seenWatermark ?? null;
                     if (await claudeAdapter.adoptExistingTmuxSession(key, sessionName, workDir, agent.claudeSessionId)) {
                         adopted += 1;
+                        // The pane keeps the account it was started with; a changed pick reopens it (idle) or waits for the next start.
+                        const spawnedConfigDir = claudeAdapter.getSessionClaudeConfigDir(key);
+                        if (spawnedConfigDir !== undefined && spawnedConfigDir !== resolveThreadClaudeConfigDir(key)) {
+                            void applyClaudeProfileToThread(key)
+                                .then((outcome) => console.log(`[reattach] ${(0, sessionKey_1.keyToString)(key)}: the pane's account profile differs from the topic's pick: ${outcome}`))
+                                .catch((e) => console.warn(`[reattach] ${(0, sessionKey_1.keyToString)(key)}: moving the pane onto its profile failed:`, e instanceof Error ? e.message : e));
+                        }
                         // Fire-and-forget: the body (a Claude fs read) must not serialize the
                         // reattach scan. postReattachRecap swallows its own errors; the `.catch`
                         // is defensive.
@@ -9201,6 +9801,14 @@ async function reattachExistingSessions(opts = { quietReattach: false }) {
                             if (ownerAdapter.lifecycle !== 'perTurn')
                                 stopAdoptedSessionWhenIdle(key, ownerAdapter, 'the stale tool list');
                         }
+                        // The surviving process keeps the account it was spawned with; a topic whose pick changed while the
+                        // bot was down gets it at the next idle point (the resume reads the current profile).
+                        const spawnedConfigDir = ownerAdapter.getSessionClaudeConfigDir(key);
+                        if (spawnedConfigDir !== undefined && spawnedConfigDir !== resolveThreadClaudeConfigDir(key)) {
+                            console.log(`[reattach] ${(0, sessionKey_1.keyToString)(key)}: adopted under profile dir ${spawnedConfigDir ?? 'default'}, the topic now resolves to ${resolveThreadClaudeConfigDir(key) ?? 'default'}`);
+                            if (ownerAdapter.lifecycle !== 'perTurn')
+                                stopAdoptedSessionWhenIdle(key, ownerAdapter, 'the account profile');
+                        }
                     }
                     else {
                         // Dead/zombie — adopt cleaned it up itself; the thread sleeps (below)
@@ -9854,6 +10462,7 @@ function wireScheduler(wiring) {
         },
         sendMessagesToThread,
         compactConversation: (threadKeyStr) => armDeferredCompaction((0, sessionKey_1.keyFromString)(threadKeyStr)),
+        listClaudeProfiles: listClaudeProfilesForAgent,
         ...(jiraConnector
             ? { fetchJiraAttachment: (threadKeyStr, attachmentId) => jiraConnector.fetchAttachment((0, sessionKey_1.keyFromString)(threadKeyStr), attachmentId) }
             : {}),
@@ -10063,6 +10672,12 @@ async function startBot() {
     //     phase: its launch defaults (R15) must apply to a session resumed during
     //     reattach, and a broken setup stops the start with every reason at once.
     //     It starts polling once the sessions are restored.
+    // Every Claude spawn from here on reads the conversation's account profile (`/account`).
+    (0, createAdapter_1.registerClaudeConfigDirReader)(resolveThreadClaudeConfigDir);
+    (0, createAdapter_1.registerClaudeRateLimitSink)(onClaudeRateLimitEvent);
+    // The usage cache: a first poll now (off the boot path), then the timer.
+    claudeUsageRefresher.start();
+    void claudeUsageRefresher.refreshAll();
     const jiraConnector = ENV.servedPlatforms.has('jira') ? await prepareJiraConnectorOrExit() : null;
     if (jiraConnector) {
         const { launchDefaults } = jiraConnector;