charness 3.2.0 → 3.3.0

package/dist/connectors/telegram/commands/fallbackChain.js

@@ -1,35 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.limitsUsageRefreshBudgetMs = void 0;
 exports.createFallbackChain = createFallbackChain;
 /**
- * `/limits` — everything about a usage limit on one screen: the instance-wide priority chain of backend +
- * account / provider + model a topic continues on (reorder, include / exclude, remove, add through a two-step
- * sub-picker, rebuild a draft, clear — from EVERY topic, one instance-wide list), the two settings that decide what a
- * limit does (auto switch to a fallback model, wait for the reset and continue — instance defaults in General,
+ * `/limits_autoswitch` — the setup of automatic switching on a usage limit, on one screen: the instance-wide priority
+ * chain of backend + account / provider + model a topic continues on (reorder, include / exclude, remove, add through
+ * a two-step sub-picker, rebuild a draft, clear — from EVERY topic, one instance-wide list), the two settings that decide
+ * what a limit does (auto switch to a fallback model, wait for the reset and continue — instance defaults in General,
  * on / off / same-as-General overrides in a topic, chosen in a per-setting sub-menu) — and the «🔁 Switch to …»
- * buttons a usage-limit notice carries. The message text is deliberately short: the Claude accounts' usage block
- * on top (the `/accounts` renderer), then the topic's position and where its settings come from — the list and
- * the settings' values are on the buttons. `/fallback` and `/auto_continue_limits` are hidden aliases of this
- * screen. See README.md in this folder and `utils/fallbackChain.ts`.
+ * buttons a usage-limit notice carries. The message text is deliberately short: a title, the topic's position and
+ * where its settings come from — the list and the settings' values are on the buttons. `/fallback` and
+ * `/auto_continue_limits` are hidden aliases of this screen. `/limits` itself is the switch board
+ * (`limitsBoard.ts`). See README.md in this folder and `utils/fallbackChain.ts`.
  */
 const telegraf_1 = require("telegraf");
 const i18n_1 = require("../../../i18n");
-const paginateList_1 = require("../../../utils/paginateList");
+const modelPickerPlan_1 = require("../../../utils/modelPickerPlan");
 const claudeUsage_1 = require("../../../utils/claudeUsage");
-const claudeProfileUsageLines_1 = require("../../../utils/claudeProfileUsageLines");
-const claudeUsageRefresher_1 = require("../../../utils/claudeUsageRefresher");
 const autoContinueOnLimit_1 = require("../../../utils/autoContinueOnLimit");
+const usageRefreshBudget_1 = require("../../../utils/usageRefreshBudget");
 const fallbackChain_1 = require("../../../utils/fallbackChain");
+const limitSettings_1 = require("../../../utils/limitSettings");
 const callbackMessage_1 = require("./callbackMessage");
-/** Models per page in the «add an OpenCode model» step (the `/model` picker's density). */
-const addModelPageSize = 8;
-/**
- * How long opening the screen waits for the usage refresh (one poll is ~0.5 s). A slower one — a hung endpoint
- * runs into the fetch's own 15 s timeout — keeps going in the background and the next render shows its result.
- */
-exports.limitsUsageRefreshBudgetMs = 2_000;
-const settingIds = ['switch', 'wait'];
+const callbackToast_1 = require("./callbackToast");
+const modelPage_1 = require("./modelPage");
 const settingCallbacks = {
     switch: { open: fallbackChain_1.fallbackAutoSwitchOpenCallback, on: fallbackChain_1.fallbackAutoSwitchOnCallback, off: fallbackChain_1.fallbackAutoSwitchOffCallback, same: fallbackChain_1.fallbackAutoSwitchSameCallback },
     wait: { open: fallbackChain_1.fallbackWaitOpenCallback, on: fallbackChain_1.fallbackWaitOnCallback, off: fallbackChain_1.fallbackWaitOffCallback, same: fallbackChain_1.fallbackWaitSameCallback },
@@ -39,10 +32,14 @@ const settingTextKeys = {
     switch: { button: 'limits.switchButton', menuTitle: 'limits.switchMenuTitle' },
     wait: { button: 'limits.waitButton', menuTitle: 'limits.waitMenuTitle' },
 };
-/** @description Build the `/limits` feature over its ports: the command (+ the hidden aliases), its buttons, the limit-notice switch button. */
+/** @description Build the `/limits_autoswitch` feature over its ports: the command (+ the hidden aliases), its buttons, the limit-notice switch button. */
 function createFallbackChain(ports) {
     const { bot, command, getState, replyToThread, editThreadMessage, authoriseContext, withThreadLocale, checkIsGeneral, getInstanceTimezone, refreshClaudeUsage, detectFallbackOptions, getTopicPosition, takeSwitchOffer, applyAutoContinue, getArmedLimitRetryFireAt, } = ports;
+    const answerWithWholeText = (0, callbackToast_1.createWholeTextAnswerer)(replyToThread);
+    // Both per MESSAGE, keyed by chat + message id (`buildMessageSnapshotKey`): a message id is unique only within one chat.
     const addSnapshots = new Map();
+    /** The rung each «add it?» question waits to add; the revision of the list it was asked about rides in its button. */
+    const pendingAdds = new Map();
     function getLabelWords() {
         return { claude: (0, i18n_1.t)('fallback.backendClaude'), openCode: (0, i18n_1.t)('fallback.backendOpenCode'), topicModel: (0, i18n_1.t)('fallback.topicModel') };
     }
@@ -51,15 +48,17 @@ function createFallbackChain(ports) {
         return (0, fallbackChain_1.formatFallbackEntryLabel)(entry, getLabelWords());
     }
     /**
-     * A rung on its label button: `3. Claude · work ⛔ 14:00` / `1. openai / gpt-6.1 🚫` — the FULL name (Telegram
-     * sizes and truncates the button as it sees fit). The rung's state rides as a suffix (⛔ limited until, 🔒 not
-     * signed in, ❓ not offered any more, 🚫 left out of switching, ✓ where the topic runs now). The one place the
-     * label is built: a two-row layout (label on its own row) only changes how `buildPicker` assembles the row.
+     * A rung on its label button: `✓ 1. Claude · work · opus` / `3. OpenCode · openai · gpt-6.1 🚫` — the program, then
+     * the account or provider and the model when the rung names one (Telegram sizes and truncates the button as it sees
+     * fit). The rung's state rides as a suffix (⛔ limited until, 🔒 not signed in, ❓ not offered any more, 🚫 left out
+     * of switching) and ✓ at the start marks where the topic runs now. The one place the label is built: a two-row
+     * layout (label on its own row) only changes how `buildPicker` assembles the row.
      */
     function formatRowButtonLabel(index, entry, detection, current, nowMs) {
+        const words = getLabelWords();
         const base = entry.backend === 'claude'
-            ? formatEntry(entry)
-            : `${entry.providerId} / ${entry.modelId}`;
+            ? `${words.claude} · ${entry.profile}${entry.model === null ? '' : ` · ${entry.model}`}`
+            : `${words.openCode} · ${entry.providerId} · ${entry.modelId}`;
         const availability = (0, fallbackChain_1.getFallbackEntryAvailability)(entry, detection, nowMs);
         let suffix = '';
         if (availability.status === 'limited')
@@ -70,9 +69,8 @@ function createFallbackChain(ports) {
             suffix += ' ❓';
         if ((0, fallbackChain_1.checkIsFallbackEntryDisabled)(entry))
             suffix += ' 🚫';
-        if (current && (0, fallbackChain_1.checkIsSameFallbackAccount)(entry, current))
-            suffix += ' ✓';
-        return `${index + 1}. ${base}${suffix}`;
+        const here = current && (0, fallbackChain_1.checkIsSameFallbackAccount)(entry, current) ? '✓ ' : '';
+        return `${here}${index + 1}. ${base}${suffix}`;
     }
     /**
      * A rung's detail view, in the message the list sits in: its name and state, then ⬆️ Up / ⬇️ Down (hidden at
@@ -121,28 +119,7 @@ function createFallbackChain(ports) {
         ];
         await editThreadMessage(key, messageId, lines.join('\n'), telegraf_1.Markup.inlineKeyboard(rows));
     }
-    /** A setting's value for the topic (General: the instance default, where there is no override). */
-    function readSetting(id, key, isGeneral) {
-        if (id === 'switch') {
-            return {
-                effective: isGeneral ? getState().getClaudeAutoSwitchOnLimitGlobalDefault() : getState().checkIsClaudeAutoSwitchOnLimitEnabled(key),
-                override: isGeneral ? undefined : getState().getClaudeAutoSwitchOnLimitOverride(key),
-                generalValue: getState().getClaudeAutoSwitchOnLimitGlobalDefault(),
-            };
-        }
-        return {
-            effective: isGeneral ? getState().getAutoContinueOnLimitGlobalDefault() : getState().checkIsAutoContinueOnLimitEnabled(key),
-            override: isGeneral ? undefined : getState().getAutoContinueOnLimitOverride(key),
-            generalValue: getState().getAutoContinueOnLimitGlobalDefault(),
-        };
-    }
-    function formatState(enabled) {
-        return enabled ? (0, i18n_1.t)('autoContinueLimits.on') : (0, i18n_1.t)('autoContinueLimits.off');
-    }
-    /** Where a topic's setting value comes from: General, or the topic's own override. */
-    function formatSettingSource(setting) {
-        return setting.override === undefined ? (0, i18n_1.t)('limits.sourceGeneral') : (0, i18n_1.t)('limits.sourceTopic');
-    }
+    const readSetting = (id, key, isGeneral) => (0, limitSettings_1.readLimitSetting)(getState(), id, key, isGeneral);
     /**
      * One setting's button on the main screen: one full-width button with the setting's name and its effective value
      * (`🔁 Auto switch: ON`). Where a topic's value comes from is in the message text above and in the sub-menu
@@ -153,7 +130,7 @@ function createFallbackChain(ports) {
     function buildSettingRow(id, setting, isGeneral) {
         const callbacks = settingCallbacks[id];
         const tapData = isGeneral ? (setting.effective ? callbacks.off : callbacks.on) : callbacks.open;
-        return [telegraf_1.Markup.button.callback((0, i18n_1.t)(settingTextKeys[id].button, { state: formatState(setting.effective) }), tapData)];
+        return [telegraf_1.Markup.button.callback((0, i18n_1.t)(settingTextKeys[id].button, { state: (0, limitSettings_1.formatLimitSettingState)(setting.effective) }), tapData)];
     }
     /**
      * A topic's setting sub-menu, in the message the screen sits in: the setting's name, then ON / OFF / As in
@@ -168,41 +145,17 @@ function createFallbackChain(ports) {
         const callbacks = settingCallbacks[id];
         const mark = (isCurrent) => (isCurrent ? ' ✓' : '');
         const rows = [
-            [telegraf_1.Markup.button.callback(`${formatState(true)}${mark(setting.override === true)}`, callbacks.on)],
-            [telegraf_1.Markup.button.callback(`${formatState(false)}${mark(setting.override === false)}`, callbacks.off)],
-            [telegraf_1.Markup.button.callback(`${(0, i18n_1.t)('limits.settingSameButton', { state: formatState(setting.generalValue) })}${mark(setting.override === undefined)}`, callbacks.same)],
+            [telegraf_1.Markup.button.callback(`${(0, limitSettings_1.formatLimitSettingState)(true)}${mark(setting.override === true)}`, callbacks.on)],
+            [telegraf_1.Markup.button.callback(`${(0, limitSettings_1.formatLimitSettingState)(false)}${mark(setting.override === false)}`, callbacks.off)],
+            [telegraf_1.Markup.button.callback(`${(0, i18n_1.t)('limits.settingSameButton', { state: (0, limitSettings_1.formatLimitSettingState)(setting.generalValue) })}${mark(setting.override === undefined)}`, callbacks.same)],
             buildBackRow(),
         ];
         await editThreadMessage(key, messageId, (0, i18n_1.t)(settingTextKeys[id].menuTitle), telegraf_1.Markup.inlineKeyboard(rows));
     }
     /**
-     * The usage block at the top of the screen: a heading that says the percentages are USED, then each Claude
-     * profile's windows as `/accounts` shows them under its row (`formatClaudeProfileUsageLines`), one row per
-     * profile — the name, then its windows (a limit mark on the next row). A signed-out profile is named as such;
-     * one never polled has nothing to show and is left out (no rows → no heading either). OpenCode's limit marks
-     * are not repeated here: they are on the rung buttons (`⛔ until`).
-     */
-    function formatUsageBlock(detection, nowMs) {
-        const timezone = getInstanceTimezone();
-        const rows = [];
-        for (const profile of detection.claudeProfiles) {
-            if (profile.loggedIn === false) {
-                rows.push(`• ${profile.name} — ${(0, i18n_1.t)('account.row.loggedOut')}`);
-                continue;
-            }
-            // The first line hangs under a row in `/accounts` (the locale indents it); here it sits after the name.
-            const [first, ...rest] = (0, claudeProfileUsageLines_1.formatClaudeProfileUsageLines)(profile, timezone, nowMs);
-            if (first === undefined)
-                continue;
-            rows.push([`• ${profile.name} — ${first.trimStart()}`, ...rest].join('\n'));
-        }
-        return rows.length === 0 ? '' : [(0, i18n_1.t)('limits.usageHeading'), ...rows].join('\n');
-    }
-    /**
-     * The `/limits` screen. Text: the Claude accounts' usage, then what the topic runs on and where its two
-     * settings come from (General: just that these are defaults) and the list's heading — the list itself, its
-     * marks and the two settings' values are on the buttons. A topic also gets «skip once» while a limit wait is
-     * armed for it.
+     * The `/limits_autoswitch` screen. Text: its title, what the topic runs on and where its two settings come from
+     * (General: just that these are defaults), then the list's heading — the list itself, its marks and the two
+     * settings' values are on the buttons. A topic also gets «skip once» while a limit wait is armed for it.
      */
     async function buildPicker(key, isGeneral) {
         const chain = getState().getFallbackChain();
@@ -212,18 +165,13 @@ function createFallbackChain(ports) {
         const switchSetting = readSetting('switch', key, isGeneral);
         const waitSetting = readSetting('wait', key, isGeneral);
         const parts = [];
-        const usageBlock = formatUsageBlock(detection, nowMs);
-        if (usageBlock !== '')
-            parts.push(usageBlock);
-        if (isGeneral) {
-            parts.push((0, i18n_1.t)('limits.settingsGeneral'));
-        }
-        else {
-            parts.push([
+        parts.push(isGeneral
+            ? [(0, i18n_1.t)('limits.autoswitchTitle'), (0, i18n_1.t)('limits.settingsGeneral')].join('\n')
+            : [
+                (0, i18n_1.t)('limits.autoswitchTitle'),
                 (0, i18n_1.t)('limits.topicRuns', { current: current ? formatEntry(current) : (0, i18n_1.t)('fallback.noAgent') }),
-                (0, i18n_1.t)('limits.sourceLine', { switch: formatSettingSource(switchSetting), wait: formatSettingSource(waitSetting) }),
+                (0, i18n_1.t)('limits.sourceLine', { switch: (0, limitSettings_1.formatLimitSettingSource)(switchSetting), wait: (0, limitSettings_1.formatLimitSettingSource)(waitSetting) }),
             ].join('\n'));
-        }
         parts.push(chain.length === 0 ? (0, i18n_1.t)('limits.listNoteEmpty') : (0, i18n_1.t)('limits.listNote'));
         const rows = [];
         const revision = (0, fallbackChain_1.getFallbackChainRevision)(chain);
@@ -249,7 +197,9 @@ function createFallbackChain(ports) {
     async function rerenderPicker(key, messageId, isGeneral) {
         if (messageId === null)
             return;
-        addSnapshots.delete(messageId);
+        const snapshotKey = (0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId);
+        addSnapshots.delete(snapshotKey);
+        pendingAdds.delete(snapshotKey);
         const picker = await buildPicker(key, isGeneral);
         await editThreadMessage(key, messageId, picker.text, picker.keyboard);
     }
@@ -274,7 +224,7 @@ function createFallbackChain(ports) {
             await replyToThread(key, (0, i18n_1.t)('fallback.nothingDetected'));
             return;
         }
-        addSnapshots.set(messageId, { providers, providerId: null, models: [] });
+        addSnapshots.set((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId), { providers, providerId: null, models: [] });
         rows.push(buildBackRow());
         await editThreadMessage(key, messageId, (0, i18n_1.t)('fallback.pickAccount'), telegraf_1.Markup.inlineKeyboard(rows));
     }
@@ -285,22 +235,25 @@ function createFallbackChain(ports) {
         rows.push(buildBackRow());
         await editThreadMessage(key, messageId, (0, i18n_1.t)('fallback.pickModel', { account: `${getLabelWords().claude} · ${profile}` }), telegraf_1.Markup.inlineKeyboard(rows));
     }
-    /** Step 2 for an OpenCode provider: one page of its models (absolute indexes into the snapshot). */
-    async function renderAddModelPage(key, messageId, snapshot, page) {
-        const { slice, currentPage, totalPages } = (0, paginateList_1.paginateList)(snapshot.models, page, addModelPageSize);
-        const offset = currentPage * addModelPageSize;
-        const rows = slice.map((modelId, index) => [telegraf_1.Markup.button.callback(modelId, (0, fallbackChain_1.buildFallbackAddModelCallback)(offset + index))]);
-        if (totalPages > 1) {
-            const nav = [];
-            if (currentPage > 0)
-                nav.push(telegraf_1.Markup.button.callback('◀️', (0, fallbackChain_1.buildFallbackAddModelPageCallback)(currentPage - 1)));
-            nav.push(telegraf_1.Markup.button.callback(`${currentPage + 1}/${totalPages}`, (0, fallbackChain_1.buildFallbackAddModelPageCallback)(currentPage)));
-            if (currentPage < totalPages - 1)
-                nav.push(telegraf_1.Markup.button.callback('▶️', (0, fallbackChain_1.buildFallbackAddModelPageCallback)(currentPage + 1)));
-            rows.push(nav);
-        }
-        rows.push(buildBackRow());
-        await editThreadMessage(key, messageId, (0, i18n_1.t)('fallback.pickModel', { account: `${getLabelWords().openCode} · ${snapshot.providerId}` }), telegraf_1.Markup.inlineKeyboard(rows));
+    /** Step 2 for an OpenCode provider: one page of its models (absolute indexes into the snapshot), limit marks on the limited ones. */
+    async function showAddModelPage(key, messageId, snapshot, page) {
+        const providerId = snapshot.providerId ?? '';
+        const { openCodeLimits } = await detectFallbackOptions();
+        const nowMs = Date.now();
+        const { rows } = (0, modelPage_1.buildModelPageButtons)({
+            provider: providerId,
+            models: snapshot.models,
+            page,
+            current: null,
+            callbacks: {
+                buildPage: fallbackChain_1.buildFallbackAddModelPageCallback,
+                buildPick: fallbackChain_1.buildFallbackAddModelCallback,
+                noop: modelPickerPlan_1.modelPickerNoopCallback,
+                back: { label: (0, i18n_1.t)('fallback.backButton'), data: fallbackChain_1.fallbackBackCallback },
+            },
+            getSuffix: (modelId) => (0, fallbackChain_1.formatOpenCodeModelLimitSuffix)(`${providerId}/${modelId}`, openCodeLimits, getInstanceTimezone(), nowMs),
+        });
+        await editThreadMessage(key, messageId, (0, i18n_1.t)('fallback.pickModel', { account: `${getLabelWords().openCode} · ${providerId}` }), telegraf_1.Markup.inlineKeyboard(rows));
     }
     /** Append an entry to the chain and RETURN the confirmation (the one write path behind both add steps). */
     async function applyAdd(entry) {
@@ -311,6 +264,33 @@ function createFallbackChain(ports) {
         await getState().setFallbackChain(result.chain);
         return (0, i18n_1.t)('fallback.added', { label: formatEntry(entry) });
     }
+    /**
+     * The question before a rung of a NEW backend joins automatic switching, in the message the tap came from: the
+     * rung, the shared line about the hand-over, ✅ Continue (the revision of the list is baked in) and ✖️ Cancel
+     * (`cancelData`: back to the list, or to the rung's detail view). A tap that comes late finds the list changed.
+     */
+    async function askAboutNewBackend(key, messageId, questionKey, entry, continueData, cancelData) {
+        const text = `${(0, i18n_1.t)(questionKey, { label: formatEntry(entry) })}\n${(0, i18n_1.t)('handover.note')}`;
+        await editThreadMessage(key, messageId, text, telegraf_1.Markup.inlineKeyboard([[
+                telegraf_1.Markup.button.callback((0, i18n_1.t)('handover.continueButton'), continueData),
+                telegraf_1.Markup.button.callback((0, i18n_1.t)('handover.cancelButton'), cancelData),
+            ]]));
+    }
+    /**
+     * An «add» that finished its steps. A rung of a backend the list does not use yet asks first (the question
+     * replaces the picker in the same message); any other add goes ahead and the screen is re-rendered.
+     */
+    async function takeAdd(ctx, key, isGeneral, messageId, entry) {
+        const chain = getState().getFallbackChain();
+        if (messageId !== null && (0, fallbackChain_1.addFallbackEntry)(chain, entry).ok && (0, fallbackChain_1.checkIsNewBackendForChain)(chain, entry)) {
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
+            pendingAdds.set((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId), entry);
+            await askAboutNewBackend(key, messageId, 'limits.addConfirm', entry, (0, fallbackChain_1.buildFallbackAddConfirmCallback)((0, fallbackChain_1.getFallbackChainRevision)(chain)), fallbackChain_1.fallbackBackCallback);
+            return;
+        }
+        await answerWithWholeText(ctx, key, await applyAdd(entry));
+        await rerenderPicker(key, messageId, isGeneral);
+    }
     /** Replace the chain with the draft and RETURN the confirmation. */
     async function applyPropose() {
         const chain = (0, fallbackChain_1.proposeFallbackChain)(await detectFallbackOptions(), getState().getFallbackChain());
@@ -332,55 +312,42 @@ function createFallbackChain(ports) {
         const what = (0, i18n_1.t)('limits.whatSwitch');
         if (isGeneral) {
             await getState().setClaudeAutoSwitchOnLimitGlobalDefault(enabled ?? false);
-            return (0, i18n_1.t)('limits.setGlobal', { what, state: formatState(enabled ?? false) });
+            return (0, i18n_1.t)('limits.setGlobal', { what, state: (0, limitSettings_1.formatLimitSettingState)(enabled ?? false) });
         }
         await getState().setClaudeAutoSwitchOnLimitOverride(key, enabled);
         return enabled === null
-            ? (0, i18n_1.t)('limits.setSame', { what, state: formatState(getState().getClaudeAutoSwitchOnLimitGlobalDefault()) })
-            : (0, i18n_1.t)('limits.setThisTopic', { what, state: formatState(enabled) });
+            ? (0, i18n_1.t)('limits.setSame', { what, state: (0, limitSettings_1.formatLimitSettingState)(getState().getClaudeAutoSwitchOnLimitGlobalDefault()) })
+            : (0, i18n_1.t)('limits.setThisTopic', { what, state: (0, limitSettings_1.formatLimitSettingState)(enabled) });
     }
     /** The «wait for the reset» twin of {@link applyAutoSwitch}; the write (and the armed-wait cleanup) is `autoContinueLimits.ts`'s. */
     async function applyWait(key, isGeneral, enabled) {
         const what = (0, i18n_1.t)('limits.whatWait');
         await applyAutoContinue(key, isGeneral, isGeneral ? (enabled ?? true) : enabled);
         if (isGeneral)
-            return (0, i18n_1.t)('limits.setGlobal', { what, state: formatState(enabled ?? true) });
+            return (0, i18n_1.t)('limits.setGlobal', { what, state: (0, limitSettings_1.formatLimitSettingState)(enabled ?? true) });
         return enabled === null
-            ? (0, i18n_1.t)('limits.setSame', { what, state: formatState(getState().getAutoContinueOnLimitGlobalDefault()) })
-            : (0, i18n_1.t)('limits.setThisTopic', { what, state: formatState(enabled) });
+            ? (0, i18n_1.t)('limits.setSame', { what, state: (0, limitSettings_1.formatLimitSettingState)(getState().getAutoContinueOnLimitGlobalDefault()) })
+            : (0, i18n_1.t)('limits.setThisTopic', { what, state: (0, limitSettings_1.formatLimitSettingState)(enabled) });
     }
     // ── the command ──
     function registerFallbackChainCommands() {
-        // `/limits` — bare: the screen (the chain is edited from every topic). `propose` / `rebuild`
+        // `/limits_autoswitch` — bare: the screen (the chain is edited from every topic). `propose` / `rebuild`
         // drafts the chain, `clear` empties it, `switch|autoswitch on|off|same` and `wait on|off|same` flip the two
-        // settings. `/fallback` is the same command under its old name (hidden alias). Not gated on a session:
-        // the chain must be settable before any limit hits.
-        command(['limits', 'fallback'], async (_ctx, key, parsed) => {
+        // settings; `/limits` takes the same verbs (`limitsBoard.ts` hands them to {@link runAutoSwitchCommand}).
+        // `/fallback` is the same command under its old name (hidden alias). Not gated on a session: the chain must
+        // be settable before any limit hits.
+        command(['limits_autoswitch', 'fallback'], async (_ctx, key, parsed) => {
             const [verb = '', value = ''] = parsed.args;
-            await runLimitsCommand(key, verb, value);
+            await runAutoSwitchCommand(key, verb, value);
         });
     }
-    /**
-     * Refresh the usage snapshots (a snapshot younger than a minute is kept — the `/accounts` freshness), waiting at
-     * most {@link limitsUsageRefreshBudgetMs}: the screen is never held by a slow usage endpoint.
-     */
-    async function refreshUsageWithinBudget() {
-        let timer;
-        const budget = new Promise((resolve) => { timer = setTimeout(resolve, exports.limitsUsageRefreshBudgetMs); });
-        try {
-            await Promise.race([refreshClaudeUsage({ maxAgeMs: claudeUsageRefresher_1.claudeUsageOnDemandMaxAgeMs }), budget]);
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
     /** Open the screen as a fresh message (the `/auto_continue_limits` alias lands here); the usage is refreshed first. */
-    async function openLimitsView(key) {
-        await refreshUsageWithinBudget();
+    async function openAutoSwitchView(key) {
+        await (0, usageRefreshBudget_1.refreshUsageWithinBudget)(refreshClaudeUsage);
         const picker = await buildPicker(key, checkIsGeneral(key));
         await replyToThread(key, picker.text, picker.keyboard);
     }
-    async function runLimitsCommand(key, verb, value) {
+    async function runAutoSwitchCommand(key, verb, value, usageKey = 'limits.autoswitchUsage') {
         const isGeneral = checkIsGeneral(key);
         const word = value.toLowerCase();
         const parseState = () => {
@@ -394,12 +361,12 @@ function createFallbackChain(ports) {
         };
         switch (verb.toLowerCase()) {
             case '':
-                await openLimitsView(key);
+                await openAutoSwitchView(key);
                 return;
             case 'propose':
             case 'rebuild': {
                 await replyToThread(key, await applyPropose());
-                await openLimitsView(key);
+                await openAutoSwitchView(key);
                 return;
             }
             case 'clear': {
@@ -410,7 +377,7 @@ function createFallbackChain(ports) {
             case 'autoswitch': {
                 const enabled = parseState();
                 if (enabled === undefined) {
-                    await replyToThread(key, (0, i18n_1.t)('limits.usage'));
+                    await replyToThread(key, (0, i18n_1.t)(usageKey));
                     return;
                 }
                 await replyToThread(key, await applyAutoSwitch(key, isGeneral, enabled));
@@ -419,14 +386,14 @@ function createFallbackChain(ports) {
             case 'wait': {
                 const enabled = parseState();
                 if (enabled === undefined) {
-                    await replyToThread(key, (0, i18n_1.t)('limits.usage'));
+                    await replyToThread(key, (0, i18n_1.t)(usageKey));
                     return;
                 }
                 await replyToThread(key, await applyWait(key, isGeneral, enabled));
                 return;
             }
             default:
-                await replyToThread(key, (0, i18n_1.t)('limits.usage'));
+                await replyToThread(key, (0, i18n_1.t)(usageKey));
         }
     }
     /** The shared tap prologue: authorise, resolve the topic, run under its locale. */
@@ -438,39 +405,39 @@ function createFallbackChain(ports) {
         }
         await withThreadLocale(key, () => run(key, checkIsGeneral(key), (0, callbackMessage_1.getCallbackMessageId)(ctx)));
     }
-    /** `answerCbQuery` is capped at 200 characters: a long confirmation goes to the topic instead. */
-    async function answerTap(ctx, key, text) {
-        if (text.length <= 180) {
-            await ctx.answerCbQuery(text);
-            return;
-        }
-        await ctx.answerCbQuery();
-        await replyToThread(key, text);
-    }
     /** An edit tap: a stale revision only re-renders. */
     function registerEdit(re, edit, confirm, 
     /** Where the rung sits after the edit (the detail view follows it); `null` = back to the list. */
-    nextIndex) {
+    nextIndex, 
+    /** An edit that must ask first answers with the data of the question's two buttons; `null` = go ahead. */
+    gate) {
         bot.action(re, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
             const chain = getState().getFallbackChain();
-            const parsed = (0, fallbackChain_1.parseFallbackEditCallback)(ctx.match[0], re, (0, fallbackChain_1.getFallbackChainRevision)(chain));
+            const revision = (0, fallbackChain_1.getFallbackChainRevision)(chain);
+            const parsed = (0, fallbackChain_1.parseFallbackEditCallback)(ctx.match[0], re, revision);
             if (parsed === null) {
-                await ctx.answerCbQuery();
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
                 return;
             }
             if (!parsed.isCurrent) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
+            const question = gate?.(chain, parsed.index, revision);
+            if (question && messageId !== null && chain[parsed.index]) {
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
+                await askAboutNewBackend(key, messageId, 'limits.enableConfirm', chain[parsed.index], question.continueData, question.cancelData);
+                return;
+            }
             const result = edit(chain, parsed.index);
             if (!result.ok) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
             await getState().setFallbackChain(result.chain);
-            await answerTap(ctx, key, confirm(chain, parsed.index));
+            await answerWithWholeText(ctx, key, confirm(chain, parsed.index));
             const next = nextIndex(parsed.index);
             if (next === null)
                 await rerenderPicker(key, messageId, isGeneral);
@@ -481,106 +448,129 @@ function createFallbackChain(ports) {
     function registerFallbackChainCallbacks() {
         registerEdit(fallbackChain_1.fallbackMoveUpCallbackRe, (chain, index) => (0, fallbackChain_1.moveFallbackEntry)(chain, index, -1), () => (0, i18n_1.t)('fallback.moved'), (index) => Math.max(0, index - 1));
         registerEdit(fallbackChain_1.fallbackMoveDownCallbackRe, (chain, index) => (0, fallbackChain_1.moveFallbackEntry)(chain, index, 1), () => (0, i18n_1.t)('fallback.moved'), (index) => index + 1);
-        registerEdit(fallbackChain_1.fallbackToggleCallbackRe, fallbackChain_1.toggleFallbackEntryDisabled, (chain, index) => (0, i18n_1.t)((0, fallbackChain_1.checkIsFallbackEntryDisabled)(chain[index]) ? 'limits.entryEnabled' : 'limits.entryDisabled', { label: formatEntry(chain[index]) }), (index) => index);
+        const confirmToggle = (chain, index) => (0, i18n_1.t)((0, fallbackChain_1.checkIsFallbackEntryDisabled)(chain[index]) ? 'limits.entryEnabled' : 'limits.entryDisabled', { label: formatEntry(chain[index]) });
+        // Using a rung that is left out is a question when its backend is not in automatic switching yet.
+        registerEdit(fallbackChain_1.fallbackToggleCallbackRe, fallbackChain_1.toggleFallbackEntryDisabled, confirmToggle, (index) => index, (chain, index, revision) => {
+            const entry = chain[index];
+            if (!entry || !(0, fallbackChain_1.checkIsFallbackEntryDisabled)(entry) || !(0, fallbackChain_1.checkIsNewBackendForChain)(chain.filter((_, i) => i !== index), entry))
+                return null;
+            return { continueData: (0, fallbackChain_1.buildFallbackToggleConfirmCallback)(index, revision), cancelData: (0, fallbackChain_1.buildFallbackOpenCallback)(index, revision) };
+        });
+        registerEdit(fallbackChain_1.fallbackToggleConfirmCallbackRe, fallbackChain_1.toggleFallbackEntryDisabled, confirmToggle, (index) => index);
         registerEdit(fallbackChain_1.fallbackRemoveCallbackRe, fallbackChain_1.removeFallbackEntry, (chain, index) => (0, i18n_1.t)('fallback.removed', { label: formatEntry(chain[index]) }), () => null);
         // A rung's button on the list: open its detail view (a stale revision only re-renders the list).
         bot.action(fallbackChain_1.fallbackOpenCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
             const chain = getState().getFallbackChain();
             const parsed = (0, fallbackChain_1.parseFallbackEditCallback)(ctx.match[0], fallbackChain_1.fallbackOpenCallbackRe, (0, fallbackChain_1.getFallbackChainRevision)(chain));
             if (parsed === null) {
-                await ctx.answerCbQuery();
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
                 return;
             }
             if (!parsed.isCurrent || parsed.index >= chain.length) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             await renderRungDetail(key, messageId, parsed.index, isGeneral);
         }));
         bot.action(fallbackChain_1.fallbackAddCallback, (ctx) => handleTap(ctx, async (key, _isGeneral, messageId) => {
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             if (messageId !== null)
                 await renderAddAccountStep(key, messageId);
         }));
         bot.action(fallbackChain_1.fallbackAddClaudeCallbackRe, (ctx) => handleTap(ctx, async (key, _isGeneral, messageId) => {
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             if (messageId !== null)
                 await renderAddClaudeModelStep(key, messageId, ctx.match[1]);
         }));
         bot.action(fallbackChain_1.fallbackAddClaudeModelCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
             const model = ctx.match[2] === '-' ? null : ctx.match[2];
-            await answerTap(ctx, key, await applyAdd({ backend: 'claude', profile: ctx.match[1], model }));
-            await rerenderPicker(key, messageId, isGeneral);
+            await takeAdd(ctx, key, isGeneral, messageId, { backend: 'claude', profile: ctx.match[1], model });
         }));
         bot.action(fallbackChain_1.fallbackAddProviderCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-            const snapshot = messageId === null ? undefined : addSnapshots.get(messageId);
+            const snapshot = messageId === null ? undefined : addSnapshots.get((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId));
             const providerId = snapshot?.providers[Number(ctx.match[1])];
             if (messageId === null || !snapshot || providerId === undefined) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             const detection = await detectFallbackOptions();
             const models = (0, fallbackChain_1.listOpenCodeModelsOfProvider)(detection.openCodeModels, providerId);
             const next = { ...snapshot, providerId, models };
-            addSnapshots.set(messageId, next);
-            await renderAddModelPage(key, messageId, next, 0);
+            addSnapshots.set((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId), next);
+            await showAddModelPage(key, messageId, next, 0);
         }));
         bot.action(fallbackChain_1.fallbackAddModelPageCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-            const snapshot = messageId === null ? undefined : addSnapshots.get(messageId);
+            const snapshot = messageId === null ? undefined : addSnapshots.get((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId));
             if (messageId === null || !snapshot || snapshot.providerId === null) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
-            await ctx.answerCbQuery();
-            await renderAddModelPage(key, messageId, snapshot, Number(ctx.match[1]));
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
+            await showAddModelPage(key, messageId, snapshot, Number(ctx.match[1]));
         }));
         bot.action(fallbackChain_1.fallbackAddModelCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-            const snapshot = messageId === null ? undefined : addSnapshots.get(messageId);
+            const snapshot = messageId === null ? undefined : addSnapshots.get((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId));
             const modelId = snapshot?.models[Number(ctx.match[1])];
             if (!snapshot || snapshot.providerId === null || modelId === undefined) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
+                await rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            await takeAdd(ctx, key, isGeneral, messageId, { backend: 'opencode', providerId: snapshot.providerId, modelId });
+        }));
+        // «✅ Continue» of the question before a rung of a new backend is added: only while the list is the one the
+        // question was asked about; a stale tap re-renders the list and adds nothing.
+        bot.action(fallbackChain_1.fallbackAddConfirmCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
+            const entry = messageId === null ? undefined : pendingAdds.get((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId));
+            if (!entry || ctx.match[1] !== (0, fallbackChain_1.getFallbackChainRevision)(getState().getFallbackChain())) {
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.stale'));
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
-            await answerTap(ctx, key, await applyAdd({ backend: 'opencode', providerId: snapshot.providerId, modelId }));
+            if (messageId !== null)
+                pendingAdds.delete((0, callbackMessage_1.buildMessageSnapshotKey)(key, messageId));
+            await answerWithWholeText(ctx, key, await applyAdd(entry));
             await rerenderPicker(key, messageId, isGeneral);
         }));
         bot.action(fallbackChain_1.fallbackProposeCallback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
             if (getState().getFallbackChain().length === 0) {
-                await answerTap(ctx, key, await applyPropose());
+                await answerWithWholeText(ctx, key, await applyPropose());
                 await rerenderPicker(key, messageId, isGeneral);
                 return;
             }
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             if (messageId !== null) {
-                await editThreadMessage(key, messageId, (0, i18n_1.t)('limits.rebuildConfirm'), telegraf_1.Markup.inlineKeyboard([
+                // A draft that holds both backends hands conversations over when a limit moves a topic along it: say so.
+                const draft = (0, fallbackChain_1.proposeFallbackChain)(await detectFallbackOptions(), getState().getFallbackChain());
+                const text = (0, fallbackChain_1.checkIsMixedFallbackChain)(draft) ? `${(0, i18n_1.t)('limits.rebuildConfirm')}\n${(0, i18n_1.t)('handover.note')}` : (0, i18n_1.t)('limits.rebuildConfirm');
+                await editThreadMessage(key, messageId, text, telegraf_1.Markup.inlineKeyboard([
                     [telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.proposeConfirmButton'), fallbackChain_1.fallbackProposeConfirmCallback)],
                     buildBackRow(),
                 ]));
             }
         }));
         bot.action(fallbackChain_1.fallbackProposeConfirmCallback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-            await answerTap(ctx, key, await applyPropose());
+            await answerWithWholeText(ctx, key, await applyPropose());
             await rerenderPicker(key, messageId, isGeneral);
         }));
         bot.action(fallbackChain_1.fallbackClearCallback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-            await answerTap(ctx, key, await applyClear());
+            await answerWithWholeText(ctx, key, await applyClear());
             await rerenderPicker(key, messageId, isGeneral);
         }));
         bot.action(fallbackChain_1.fallbackBackCallback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             await rerenderPicker(key, messageId, isGeneral);
         }));
         // A topic's setting button: open its sub-menu. General has no sub-menu (its button flips the value), so a tap
         // that still arrives there only re-renders the screen.
-        for (const id of settingIds) {
+        for (const id of limitSettings_1.limitSettingIds) {
             bot.action(settingCallbacks[id].open, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
-                await ctx.answerCbQuery();
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
                 if (isGeneral)
                     await rerenderPicker(key, messageId, isGeneral);
                 else
@@ -594,10 +584,10 @@ function createFallbackChain(ports) {
         for (const [callback, apply, enabled] of settingTaps) {
             bot.action(callback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
                 if (enabled === null && isGeneral) {
-                    await ctx.answerCbQuery();
+                    await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
                     return;
                 }
-                await answerTap(ctx, key, await apply(key, isGeneral, enabled));
+                await answerWithWholeText(ctx, key, await apply(key, isGeneral, enabled));
                 await rerenderPicker(key, messageId, isGeneral);
             }));
         }
@@ -606,19 +596,19 @@ function createFallbackChain(ports) {
         bot.action(fallbackChain_1.fallbackSwitchCallbackRe, (ctx) => handleTap(ctx, async (key, _isGeneral, messageId) => {
             const parsed = (0, fallbackChain_1.parseFallbackSwitchCallbackData)(ctx.match[0]);
             if (parsed === null) {
-                await ctx.answerCbQuery();
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
                 return;
             }
             const confirmation = await takeSwitchOffer(key, parsed.episodeId, parsed.index);
             if (confirmation === null) {
-                await ctx.answerCbQuery((0, i18n_1.t)('fallback.switchExpired'));
+                await (0, callbackToast_1.answerCallbackQuerySafely)(ctx, (0, i18n_1.t)('fallback.switchExpired'));
                 return;
             }
-            await ctx.answerCbQuery();
+            await (0, callbackToast_1.answerCallbackQuerySafely)(ctx);
             if (messageId !== null)
                 await editThreadMessage(key, messageId, confirmation);
         }));
     }
-    return { registerFallbackChainCommands, registerFallbackChainCallbacks, openLimitsView, applyAutoSwitch, formatFallbackEntry: formatEntry };
+    return { registerFallbackChainCommands, registerFallbackChainCallbacks, openAutoSwitchView, runAutoSwitchCommand, applyAutoSwitch, formatFallbackEntry: formatEntry };
 }
 //# sourceMappingURL=fallbackChain.js.map