charness 3.0.0 → 3.2.0

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

@@ -0,0 +1,624 @@
+"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,
+ * 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`.
+ */
+const telegraf_1 = require("telegraf");
+const i18n_1 = require("../../../i18n");
+const paginateList_1 = require("../../../utils/paginateList");
+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 fallbackChain_1 = require("../../../utils/fallbackChain");
+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 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 },
+};
+/** A setting's texts: its main-screen button (the name with the value, `{state}`) and the title of its sub-menu. */
+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. */
+function createFallbackChain(ports) {
+    const { bot, command, getState, replyToThread, editThreadMessage, authoriseContext, withThreadLocale, checkIsGeneral, getInstanceTimezone, refreshClaudeUsage, detectFallbackOptions, getTopicPosition, takeSwitchOffer, applyAutoContinue, getArmedLimitRetryFireAt, } = ports;
+    const addSnapshots = 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') };
+    }
+    /** The entry for a row or a button. */
+    function formatEntry(entry) {
+        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.
+     */
+    function formatRowButtonLabel(index, entry, detection, current, nowMs) {
+        const base = entry.backend === 'claude'
+            ? formatEntry(entry)
+            : `${entry.providerId} / ${entry.modelId}`;
+        const availability = (0, fallbackChain_1.getFallbackEntryAvailability)(entry, detection, nowMs);
+        let suffix = '';
+        if (availability.status === 'limited')
+            suffix += ` ⛔ ${(0, claudeUsage_1.formatClaudeUsageResetAt)(availability.until, getInstanceTimezone(), nowMs)}`;
+        else if (availability.status === 'signedOut')
+            suffix += ' 🔒';
+        else if (availability.status === 'missing')
+            suffix += ' ❓';
+        if ((0, fallbackChain_1.checkIsFallbackEntryDisabled)(entry))
+            suffix += ' 🚫';
+        if (current && (0, fallbackChain_1.checkIsSameFallbackAccount)(entry, current))
+            suffix += ' ✓';
+        return `${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
+     * the ends), Use / Don't use, Remove and Back. Every edit button bakes the chain revision and the index, so a
+     * stale tap re-renders the list instead of acting.
+     */
+    async function renderRungDetail(key, messageId, index, isGeneral) {
+        if (messageId === null)
+            return;
+        const chain = getState().getFallbackChain();
+        const entry = chain[index];
+        if (!entry) {
+            await rerenderPicker(key, messageId, isGeneral);
+            return;
+        }
+        const detection = await detectFallbackOptions();
+        const current = isGeneral ? null : getTopicPosition(key);
+        const nowMs = Date.now();
+        const availability = (0, fallbackChain_1.getFallbackEntryAvailability)(entry, detection, nowMs);
+        const lines = [(0, i18n_1.t)('limits.rungTitle', { n: index + 1, total: chain.length, label: formatEntry(entry) })];
+        if (availability.status === 'limited')
+            lines.push((0, i18n_1.t)('limits.rungLimited', { until: (0, claudeUsage_1.formatClaudeUsageResetAt)(availability.until, getInstanceTimezone(), nowMs) }));
+        else if (availability.status === 'signedOut')
+            lines.push((0, i18n_1.t)('limits.rungSignedOut'));
+        else if (availability.status === 'missing')
+            lines.push((0, i18n_1.t)('limits.rungMissing'));
+        else
+            lines.push((0, i18n_1.t)('limits.rungReady'));
+        if ((0, fallbackChain_1.checkIsFallbackEntryDisabled)(entry))
+            lines.push((0, i18n_1.t)('limits.rungDisabled'));
+        if (current && (0, fallbackChain_1.checkIsSameFallbackAccount)(entry, current))
+            lines.push((0, i18n_1.t)('limits.rungHere'));
+        const revision = (0, fallbackChain_1.getFallbackChainRevision)(chain);
+        const move = [];
+        if (index > 0)
+            move.push(telegraf_1.Markup.button.callback((0, i18n_1.t)('limits.btnUp'), (0, fallbackChain_1.buildFallbackMoveUpCallback)(index, revision)));
+        if (index < chain.length - 1)
+            move.push(telegraf_1.Markup.button.callback((0, i18n_1.t)('limits.btnDown'), (0, fallbackChain_1.buildFallbackMoveDownCallback)(index, revision)));
+        const rows = [
+            ...(move.length > 0 ? [move] : []),
+            [
+                telegraf_1.Markup.button.callback((0, i18n_1.t)((0, fallbackChain_1.checkIsFallbackEntryDisabled)(entry) ? 'limits.btnUse' : 'limits.btnDontUse'), (0, fallbackChain_1.buildFallbackToggleCallback)(index, revision)),
+                telegraf_1.Markup.button.callback((0, i18n_1.t)('account.removeButton'), (0, fallbackChain_1.buildFallbackRemoveCallback)(index, revision)),
+            ],
+            buildBackRow(),
+        ];
+        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');
+    }
+    /**
+     * 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
+     * (the ✓), not on the button — the worded source made it too long for a phone and cut it again. General: a tap
+     * flips the value. A topic: a tap opens the setting's sub-menu ({@link renderSettingMenu}) in the same message —
+     * three choices on one row would split the width evenly and cut every label.
+     */
+    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)];
+    }
+    /**
+     * A topic's setting sub-menu, in the message the screen sits in: the setting's name, then ON / OFF / As in
+     * General (with the General value it would give) as full-width buttons — the current choice marked `✓`, which
+     * is also where the value comes from — and Back. The options are the setting's own callbacks, which apply the
+     * choice and return to the main screen.
+     */
+    async function renderSettingMenu(key, messageId, id) {
+        if (messageId === null)
+            return;
+        const setting = readSetting(id, key, false);
+        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)],
+            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.
+     */
+    async function buildPicker(key, isGeneral) {
+        const chain = getState().getFallbackChain();
+        const detection = await detectFallbackOptions();
+        const current = isGeneral ? null : getTopicPosition(key);
+        const nowMs = Date.now();
+        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([
+                (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) }),
+            ].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);
+        // One full-width button per rung; a tap opens the rung's detail view in the same message.
+        chain.forEach((entry, index) => {
+            rows.push([telegraf_1.Markup.button.callback(formatRowButtonLabel(index, entry, detection, current, nowMs), (0, fallbackChain_1.buildFallbackOpenCallback)(index, revision))]);
+        });
+        const actions = [
+            telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.addButton'), fallbackChain_1.fallbackAddCallback),
+            telegraf_1.Markup.button.callback((0, i18n_1.t)('limits.rebuildButton'), fallbackChain_1.fallbackProposeCallback),
+        ];
+        if (chain.length > 0)
+            actions.push(telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.clearButton'), fallbackChain_1.fallbackClearCallback));
+        rows.push(actions);
+        rows.push(buildSettingRow('switch', switchSetting, isGeneral));
+        rows.push(buildSettingRow('wait', waitSetting, isGeneral));
+        const armedFireAt = isGeneral ? null : getArmedLimitRetryFireAt(key);
+        if (armedFireAt !== null)
+            rows.push([telegraf_1.Markup.button.callback((0, i18n_1.t)('autoContinueLimits.skipButton'), (0, autoContinueOnLimit_1.buildSkipArmedRetryCallbackData)(armedFireAt))]);
+        return { text: parts.join('\n\n'), keyboard: telegraf_1.Markup.inlineKeyboard(rows) };
+    }
+    /** Re-render the picker IN PLACE (it is meant for repeated use, like `/account`) off the cached usage; best-effort. */
+    async function rerenderPicker(key, messageId, isGeneral) {
+        if (messageId === null)
+            return;
+        addSnapshots.delete(messageId);
+        const picker = await buildPicker(key, isGeneral);
+        await editThreadMessage(key, messageId, picker.text, picker.keyboard);
+    }
+    function buildBackRow() {
+        return [telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.backButton'), fallbackChain_1.fallbackBackCallback)];
+    }
+    /** Step 1 of «add»: the signed-in Claude profiles and the OpenCode providers the server is authenticated for. */
+    async function renderAddAccountStep(key, messageId) {
+        const detection = await detectFallbackOptions();
+        const words = getLabelWords();
+        const rows = [];
+        for (const profile of detection.claudeProfiles) {
+            if (profile.loggedIn === false)
+                continue;
+            rows.push([telegraf_1.Markup.button.callback(`${words.claude} · ${profile.name}`, (0, fallbackChain_1.buildFallbackAddClaudeCallback)(profile.name))]);
+        }
+        const providers = (0, fallbackChain_1.listOpenCodeProviders)(detection.openCodeModels);
+        providers.forEach((providerId, index) => {
+            rows.push([telegraf_1.Markup.button.callback(`${words.openCode} · ${providerId}`, (0, fallbackChain_1.buildFallbackAddProviderCallback)(index))]);
+        });
+        if (rows.length === 0) {
+            await replyToThread(key, (0, i18n_1.t)('fallback.nothingDetected'));
+            return;
+        }
+        addSnapshots.set(messageId, { providers, providerId: null, models: [] });
+        rows.push(buildBackRow());
+        await editThreadMessage(key, messageId, (0, i18n_1.t)('fallback.pickAccount'), telegraf_1.Markup.inlineKeyboard(rows));
+    }
+    /** Step 2 for a Claude profile: keep the topic's model, or pin one of the CLI aliases. */
+    async function renderAddClaudeModelStep(key, messageId, profile) {
+        const rows = [[telegraf_1.Markup.button.callback((0, i18n_1.t)('fallback.topicModelButton'), (0, fallbackChain_1.buildFallbackAddClaudeModelCallback)(profile, null))]];
+        rows.push(fallbackChain_1.fallbackClaudeModelAliases.map((model) => telegraf_1.Markup.button.callback(model, (0, fallbackChain_1.buildFallbackAddClaudeModelCallback)(profile, model))));
+        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));
+    }
+    /** Append an entry to the chain and RETURN the confirmation (the one write path behind both add steps). */
+    async function applyAdd(entry) {
+        const result = (0, fallbackChain_1.addFallbackEntry)(getState().getFallbackChain(), entry);
+        if (!result.ok) {
+            return result.reason === 'full' ? (0, i18n_1.t)('fallback.full', { max: fallbackChain_1.fallbackChainMaxLength }) : (0, i18n_1.t)('fallback.alreadyInChain', { label: formatEntry(entry) });
+        }
+        await getState().setFallbackChain(result.chain);
+        return (0, i18n_1.t)('fallback.added', { label: formatEntry(entry) });
+    }
+    /** Replace the chain with the draft and RETURN the confirmation. */
+    async function applyPropose() {
+        const chain = (0, fallbackChain_1.proposeFallbackChain)(await detectFallbackOptions(), getState().getFallbackChain());
+        if (chain.length === 0)
+            return (0, i18n_1.t)('fallback.proposeNothing');
+        await getState().setFallbackChain(chain);
+        return (0, i18n_1.t)('fallback.proposed', { count: chain.length });
+    }
+    async function applyClear() {
+        await getState().setFallbackChain([]);
+        return (0, i18n_1.t)('fallback.cleared');
+    }
+    /**
+     * @description Set whether the bot moves a limited topic to the next rung by itself (OFF by default: moving
+     * work between accounts and providers is an operator decision) and RETURN the confirmation. General sets the
+     * instance default, a topic its override (`null` = follow General again).
+     */
+    async function applyAutoSwitch(key, isGeneral, enabled) {
+        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) });
+        }
+        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) });
+    }
+    /** 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 enabled === null
+            ? (0, i18n_1.t)('limits.setSame', { what, state: formatState(getState().getAutoContinueOnLimitGlobalDefault()) })
+            : (0, i18n_1.t)('limits.setThisTopic', { what, state: formatState(enabled) });
+    }
+    // ── the command ──
+    function registerFallbackChainCommands() {
+        // `/limits` — 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) => {
+            const [verb = '', value = ''] = parsed.args;
+            await runLimitsCommand(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();
+        const picker = await buildPicker(key, checkIsGeneral(key));
+        await replyToThread(key, picker.text, picker.keyboard);
+    }
+    async function runLimitsCommand(key, verb, value) {
+        const isGeneral = checkIsGeneral(key);
+        const word = value.toLowerCase();
+        const parseState = () => {
+            if (word === 'on')
+                return true;
+            if (word === 'off')
+                return false;
+            if (word === 'same' && !isGeneral)
+                return null;
+            return undefined;
+        };
+        switch (verb.toLowerCase()) {
+            case '':
+                await openLimitsView(key);
+                return;
+            case 'propose':
+            case 'rebuild': {
+                await replyToThread(key, await applyPropose());
+                await openLimitsView(key);
+                return;
+            }
+            case 'clear': {
+                await replyToThread(key, await applyClear());
+                return;
+            }
+            case 'switch':
+            case 'autoswitch': {
+                const enabled = parseState();
+                if (enabled === undefined) {
+                    await replyToThread(key, (0, i18n_1.t)('limits.usage'));
+                    return;
+                }
+                await replyToThread(key, await applyAutoSwitch(key, isGeneral, enabled));
+                return;
+            }
+            case 'wait': {
+                const enabled = parseState();
+                if (enabled === undefined) {
+                    await replyToThread(key, (0, i18n_1.t)('limits.usage'));
+                    return;
+                }
+                await replyToThread(key, await applyWait(key, isGeneral, enabled));
+                return;
+            }
+            default:
+                await replyToThread(key, (0, i18n_1.t)('limits.usage'));
+        }
+    }
+    /** The shared tap prologue: authorise, resolve the topic, run under its locale. */
+    async function handleTap(ctx, run) {
+        const key = await authoriseContext(ctx);
+        if (!key) {
+            await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+            return;
+        }
+        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) {
+        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));
+            if (parsed === null) {
+                await ctx.answerCbQuery();
+                return;
+            }
+            if (!parsed.isCurrent) {
+                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            const result = edit(chain, parsed.index);
+            if (!result.ok) {
+                await ctx.answerCbQuery((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));
+            const next = nextIndex(parsed.index);
+            if (next === null)
+                await rerenderPicker(key, messageId, isGeneral);
+            else
+                await renderRungDetail(key, messageId, next, isGeneral);
+        }));
+    }
+    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);
+        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();
+                return;
+            }
+            if (!parsed.isCurrent || parsed.index >= chain.length) {
+                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            await ctx.answerCbQuery();
+            await renderRungDetail(key, messageId, parsed.index, isGeneral);
+        }));
+        bot.action(fallbackChain_1.fallbackAddCallback, (ctx) => handleTap(ctx, async (key, _isGeneral, messageId) => {
+            await ctx.answerCbQuery();
+            if (messageId !== null)
+                await renderAddAccountStep(key, messageId);
+        }));
+        bot.action(fallbackChain_1.fallbackAddClaudeCallbackRe, (ctx) => handleTap(ctx, async (key, _isGeneral, messageId) => {
+            await ctx.answerCbQuery();
+            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);
+        }));
+        bot.action(fallbackChain_1.fallbackAddProviderCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
+            const snapshot = messageId === null ? undefined : addSnapshots.get(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 rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            await ctx.answerCbQuery();
+            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);
+        }));
+        bot.action(fallbackChain_1.fallbackAddModelPageCallbackRe, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
+            const snapshot = messageId === null ? undefined : addSnapshots.get(messageId);
+            if (messageId === null || !snapshot || snapshot.providerId === null) {
+                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            await ctx.answerCbQuery();
+            await renderAddModelPage(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 modelId = snapshot?.models[Number(ctx.match[1])];
+            if (!snapshot || snapshot.providerId === null || modelId === undefined) {
+                await ctx.answerCbQuery((0, i18n_1.t)('fallback.stale'));
+                await rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            await answerTap(ctx, key, await applyAdd({ backend: 'opencode', providerId: snapshot.providerId, modelId }));
+            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 rerenderPicker(key, messageId, isGeneral);
+                return;
+            }
+            await ctx.answerCbQuery();
+            if (messageId !== null) {
+                await editThreadMessage(key, messageId, (0, i18n_1.t)('limits.rebuildConfirm'), 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 rerenderPicker(key, messageId, isGeneral);
+        }));
+        bot.action(fallbackChain_1.fallbackClearCallback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
+            await answerTap(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 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) {
+            bot.action(settingCallbacks[id].open, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
+                await ctx.answerCbQuery();
+                if (isGeneral)
+                    await rerenderPicker(key, messageId, isGeneral);
+                else
+                    await renderSettingMenu(key, messageId, id);
+            }));
+        }
+        const settingTaps = [
+            [fallbackChain_1.fallbackAutoSwitchOnCallback, applyAutoSwitch, true], [fallbackChain_1.fallbackAutoSwitchOffCallback, applyAutoSwitch, false], [fallbackChain_1.fallbackAutoSwitchSameCallback, applyAutoSwitch, null],
+            [fallbackChain_1.fallbackWaitOnCallback, applyWait, true], [fallbackChain_1.fallbackWaitOffCallback, applyWait, false], [fallbackChain_1.fallbackWaitSameCallback, applyWait, null],
+        ];
+        for (const [callback, apply, enabled] of settingTaps) {
+            bot.action(callback, (ctx) => handleTap(ctx, async (key, isGeneral, messageId) => {
+                if (enabled === null && isGeneral) {
+                    await ctx.answerCbQuery();
+                    return;
+                }
+                await answerTap(ctx, key, await apply(key, isGeneral, enabled));
+                await rerenderPicker(key, messageId, isGeneral);
+            }));
+        }
+        // «🔁 Switch to <entry>» on a usage-limit notice: a one-shot button — the notice is edited into the
+        // confirmation (keyboard dropped); a stale tap (the episode is over) only says so.
+        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();
+                return;
+            }
+            const confirmation = await takeSwitchOffer(key, parsed.episodeId, parsed.index);
+            if (confirmation === null) {
+                await ctx.answerCbQuery((0, i18n_1.t)('fallback.switchExpired'));
+                return;
+            }
+            await ctx.answerCbQuery();
+            if (messageId !== null)
+                await editThreadMessage(key, messageId, confirmation);
+        }));
+    }
+    return { registerFallbackChainCommands, registerFallbackChainCallbacks, openLimitsView, applyAutoSwitch, formatFallbackEntry: formatEntry };
+}
+//# sourceMappingURL=fallbackChain.js.map