charness 0.0.0-stage → 3.0.0

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

@@ -0,0 +1,624 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReminders = createReminders;
+/**
+ * `/reminders` — bot-LOCAL reminders (buttons only, zero agent involvement): the hub, the four-step wizard, the
+ * list, the card and delete. See README.md in this folder.
+ */
+const telegraf_1 = require("telegraf");
+const sessionKey_1 = require("../../../sessionKey");
+const i18n_1 = require("../../../i18n");
+const sendErrorClassifier_1 = require("../../../sendErrorClassifier");
+const deliveryKind_1 = require("../../../scheduler/deliveryKind");
+const store_1 = require("../../../scheduler/store");
+const reminderWizard_1 = require("../../../utils/reminderWizard");
+const reminderScheduleText_1 = require("../../../utils/reminderScheduleText");
+const reminderFlow_1 = require("../../../utils/reminderFlow");
+const callbackMessage_1 = require("./callbackMessage");
+/** Width of the `HH` field in the minute step's `21:__` header. */
+const reminderHourFieldWidth = 2;
+/** Error code → the line the wizard prints above the step it re-renders. */
+const reminderWizardErrorKeys = {
+    pastTime: 'reminders.errorPastTime',
+    invalidDate: 'reminders.errorInvalidDate',
+    invalidTime: 'reminders.errorInvalidTime',
+    textTooLong: 'reminders.errorTextTooLong',
+};
+/**
+ * @description Resolve a wizard error into its localized line. One choke point so
+ * the `textTooLong` wording names the bound it rejected from the SINGLE constant
+ * instead of having the number spelled out in 12 translations; the other codes
+ * carry no `{limit}` and simply ignore it.
+ */
+function getReminderWizardErrorText(errorCode) {
+    return (0, i18n_1.t)(reminderWizardErrorKeys[errorCode], { limit: reminderWizard_1.reminderTextMaxLength });
+}
+/**
+ * Resolve one planned button caption: a locale-neutral literal, an i18n key, or a
+ * list row — whose caption is composed HERE because its schedule half is itself a
+ * localized lookup the pure planner cannot make.
+ */
+function renderReminderButtonLabel(label) {
+    switch (label.kind) {
+        case 'literal':
+            return label.text;
+        case 'key':
+            return (0, i18n_1.t)(label.key, label.vars);
+        case 'listRow':
+            return (0, reminderScheduleText_1.getReminderRowLabel)(label.name, label.descriptor);
+    }
+}
+/** Turn a keyboard PLAN from the pure module into telegraf button rows. */
+function renderReminderButtonRows(plan) {
+    return plan.map((row) => row.map((button) => telegraf_1.Markup.button.callback(renderReminderButtonLabel(button.label), button.callbackData)));
+}
+function buildReminderKeyboard(plan) {
+    return telegraf_1.Markup.inlineKeyboard(renderReminderButtonRows(plan));
+}
+/**
+ * The «close» button. Composed HERE rather than inside `buildReminderHubKeyboard`
+ * because that builder owns the rows whose PRESENCE is a decision (add at the
+ * cap, list when empty), whereas «close» is an unconditional dismissal that both
+ * the hub and the created card carry.
+ */
+function buildReminderCloseButton() {
+    return telegraf_1.Markup.button.callback((0, i18n_1.t)('reminders.closeButton'), reminderWizard_1.reminderCloseCallback);
+}
+/** Records → the rows the pure list/card plans consume. */
+function toReminderListRows(records) {
+    return records.map((record) => ({
+        id: record.id,
+        name: record.name,
+        descriptor: (0, reminderWizard_1.getReminderScheduleDescriptor)(record.spec),
+    }));
+}
+/**
+ * The three detail lines a reminder is described by. Shared by the card opened
+ * from the list and by the created-screen, so the two can never describe the same
+ * reminder differently.
+ */
+function buildReminderDetailLines(record, descriptor) {
+    return [
+        (0, i18n_1.t)('reminders.cardWhen', { schedule: (0, reminderScheduleText_1.getReminderScheduleDescriptorText)(descriptor) }),
+        (0, i18n_1.t)('reminders.cardText', { text: record.prompt }),
+        (0, i18n_1.t)('reminders.cardNext', { next: (0, reminderScheduleText_1.getReminderNextRunText)(record.nextRunAt, Date.now()) }),
+    ];
+}
+/** The done screen: what was created, plus delete / list / close. */
+function buildReminderCreatedScreen(record) {
+    return {
+        text: [
+            (0, i18n_1.t)('reminders.createdTitle'),
+            ...buildReminderDetailLines(record, (0, reminderWizard_1.getReminderScheduleDescriptor)(record.spec)),
+        ].join('\n'),
+        keyboard: telegraf_1.Markup.inlineKeyboard([
+            [
+                telegraf_1.Markup.button.callback((0, i18n_1.t)(reminderWizard_1.reminderLabelKeys.cardDelete), (0, reminderWizard_1.buildReminderDeleteCallback)(record.id)),
+                telegraf_1.Markup.button.callback((0, i18n_1.t)('reminders.doneListButton'), (0, reminderWizard_1.buildReminderListPageCallback)(0)),
+                buildReminderCloseButton(),
+            ],
+        ]),
+    };
+}
+/** The question the wizard's CURRENT step asks. */
+function getReminderStepQuestion(wizardState) {
+    switch (wizardState.step) {
+        case 'repeat':
+            return (0, i18n_1.t)('reminders.stepRepeatQuestion');
+        case 'date':
+            return (0, i18n_1.t)('reminders.stepDateQuestion');
+        case 'dateGrid':
+            return (0, i18n_1.t)('reminders.stepDateGridQuestion');
+        case 'weekday':
+            return (0, i18n_1.t)('reminders.stepWeekdayQuestion');
+        case 'dayOfMonth':
+            return (0, i18n_1.t)('reminders.stepDayOfMonthQuestion');
+        case 'dayOfMonthGrid':
+            return (0, i18n_1.t)('reminders.stepDayOfMonthGridQuestion');
+        case 'time':
+            return (0, i18n_1.t)('reminders.stepTimeQuestion');
+        case 'hour':
+            return (0, i18n_1.t)('reminders.stepHourQuestion');
+        case 'minute':
+            // The hour is committed before this screen renders; `?? 0` only narrows the
+            // optional field (a minute step with no hour is refused by the pure module).
+            return (0, i18n_1.t)('reminders.stepMinuteQuestion', {
+                hour: (wizardState.hour ?? 0).toString().padStart(reminderHourFieldWidth, '0'),
+            });
+        case 'text':
+            return (0, i18n_1.t)('reminders.stepTextQuestion');
+    }
+}
+/**
+ * @description The wizard screen for a state: the title, the running summary of
+ * everything already picked, then the current step's question (preceded by an
+ * error line when a pick could not be applied). The summary is what makes a
+ * single re-rendered message readable as a flow — each tap appends its value.
+ */
+function buildReminderWizardScreen(wizardState, errorCode) {
+    const lines = [(0, i18n_1.t)('reminders.wizardTitle')];
+    if (wizardState.repeatKind !== null) {
+        lines.push((0, i18n_1.t)('reminders.pickRepeat', { value: (0, i18n_1.t)(reminderWizard_1.reminderRepeatLabelKeys[wizardState.repeatKind]) }));
+    }
+    if (wizardState.dateIso !== null) {
+        lines.push((0, i18n_1.t)('reminders.pickDate', { value: wizardState.dateIso }));
+    }
+    if (wizardState.weekday !== null) {
+        lines.push((0, i18n_1.t)('reminders.pickWeekday', { value: (0, i18n_1.t)(reminderWizard_1.reminderWeekdayLabelKeys[wizardState.weekday]) }));
+    }
+    if (wizardState.dayOfMonth !== null) {
+        lines.push((0, i18n_1.t)('reminders.pickDayOfMonth', { value: wizardState.dayOfMonth }));
+    }
+    if (wizardState.hour !== null && wizardState.minute !== null) {
+        lines.push((0, i18n_1.t)('reminders.pickTime', {
+            value: (0, reminderWizard_1.formatReminderTime)({ hour: wizardState.hour, minute: wizardState.minute }),
+        }));
+    }
+    if (wizardState.text !== null) {
+        // Only a stale-instant retry holds text. The line is what tells the operator it
+        // was KEPT — without it they retype the reminder, and a retyped message is no
+        // longer captured by the (now disarmed) text wait: it reaches the agent instead.
+        lines.push((0, i18n_1.t)('reminders.pickText', {
+            value: (0, reminderWizard_1.getShortenedText)(wizardState.text, reminderWizard_1.reminderSummaryTextMaxLength),
+        }));
+    }
+    const question = getReminderStepQuestion(wizardState);
+    const body = errorCode === null ? question : `${getReminderWizardErrorText(errorCode)}\n\n${question}`;
+    return {
+        text: `${lines.join('\n')}\n\n${body}`,
+        keyboard: buildReminderKeyboard((0, reminderWizard_1.buildReminderStepKeyboard)({ state: wizardState, nowMs: Date.now() })),
+    };
+}
+/** Drop the keyboard of a tapped DEAD screen, swallowing a benign no-op edit. */
+async function stripReminderKeyboard(ctx) {
+    try {
+        await ctx.editMessageReplyMarkup(undefined);
+    }
+    catch (e) {
+        const desc = (0, sendErrorClassifier_1.checkIsApiError)(e) ? (0, sendErrorClassifier_1.getErrorDescription)(e) : '';
+        if (!/message is not modified/i.test(desc)) {
+            console.warn('[reminders] keyboard strip failed:', desc || e);
+        }
+    }
+}
+/**
+ * @description Build the `/reminders` flow over its ports. It returns what the bot reaches into from outside
+ * the flow — the text-capture hooks of the wizard's last step and its cancel — and the two `register…()` calls.
+ */
+function createReminders(ports) {
+    const { reminderWizards, getSchedulerEngine, bot, command, getState, replyToThread, editThreadMessage, authoriseContext } = ports;
+    /** The thread's reminders — its agent-prompt schedules filtered out. */
+    function getThreadReminders(key) {
+        return getState().getThreadSchedules(key).filter(deliveryKind_1.checkIsReminderSchedule);
+    }
+    /** Screen 0: the count (or why «add» is missing) plus the add/list/close rows. */
+    function buildReminderHubScreen(key) {
+        const records = getThreadReminders(key);
+        const plan = (0, reminderFlow_1.getReminderHubPlan)({
+            // The reminder cap is the comparison `createScheduleForThread` makes for a
+            // reminder, so «add» is never drawn for a create the store would reject four
+            // steps later.
+            reminderCount: records.length,
+            maxReminders: store_1.maxRemindersPerThread,
+        });
+        const bodyLine = plan.body === 'empty'
+            ? (0, i18n_1.t)('reminders.hubEmptyLine')
+            : plan.body === 'atLimit'
+                ? (0, i18n_1.t)('reminders.hubLimitLine', { count: records.length, limit: store_1.maxRemindersPerThread })
+                : (0, i18n_1.t)('reminders.hubActiveLine', { count: records.length });
+        const rows = (0, reminderWizard_1.buildReminderHubKeyboard)(records.length, { isAddOffered: plan.isAddOffered });
+        return {
+            text: `${(0, i18n_1.t)('reminders.hubTitle')}\n${bodyLine}`,
+            keyboard: telegraf_1.Markup.inlineKeyboard([...renderReminderButtonRows(rows), [buildReminderCloseButton()]]),
+        };
+    }
+    /**
+     * @description One list page, or `null` when the thread has no reminders (the
+     * caller falls back to the hub — a list screen with no rows is a dead end).
+     *
+     * Each row BUTTON carries «🔔 name · localized schedule», so the message text is
+     * only a header — printing the same rows in the body as well would show the list
+     * twice.
+     */
+    function buildReminderListScreen(key, page) {
+        const rows = toReminderListRows(getThreadReminders(key));
+        if (rows.length === 0)
+            return null;
+        const plan = (0, reminderWizard_1.buildReminderListPlan)(rows, page);
+        const lines = [(0, i18n_1.t)('reminders.listTitle', { count: rows.length })];
+        if (plan.totalPages > 1) {
+            lines.push((0, i18n_1.t)('reminders.listPageLine', { page: plan.currentPage + 1, total: plan.totalPages }));
+        }
+        return { text: lines.join('\n'), keyboard: buildReminderKeyboard(plan.keyboard) };
+    }
+    /** One reminder's card, or `null` for a stale row index / a record already gone. */
+    function buildReminderCardScreen(key, reminderIndex) {
+        const records = getThreadReminders(key);
+        const plan = (0, reminderWizard_1.buildReminderCardPlan)(toReminderListRows(records), reminderIndex);
+        if (plan === null)
+            return null;
+        const record = records.find((candidate) => candidate.id === plan.row.id);
+        if (record === undefined)
+            return null;
+        return {
+            text: [
+                (0, i18n_1.t)('reminders.cardTitle', { name: plan.row.name }),
+                ...buildReminderDetailLines(record, plan.row.descriptor),
+            ].join('\n'),
+            keyboard: buildReminderKeyboard(plan.keyboard),
+        };
+    }
+    /** Replace a reminder screen in place (the flow never creates a second message). */
+    async function renderReminderScreen(key, messageId, screen) {
+        await editThreadMessage(key, messageId, screen.text, screen.keyboard);
+    }
+    /**
+     * Relabel a reminder screen into a final notice and DROP its keyboard (an edit
+     * with no `reply_markup` removes it), so a finished screen can't be acted on.
+     */
+    async function retireReminderScreen(key, messageId, text) {
+        await editThreadMessage(key, messageId, text);
+    }
+    /**
+     * @description Retire the topic's in-flight wizard, if any: drop the session and
+     * relabel its message so no dead keyboard is left tappable.
+     *
+     * Called by EVERY command (a command always wins over the step-4 text wait),
+     * which is also what makes a repeat `/reminders` retire the previous wizard
+     * before opening a new one — exactly one wizard is live per topic.
+     */
+    async function cancelReminderWizard(key) {
+        const kStr = (0, sessionKey_1.keyToString)(key);
+        const session = reminderWizards.get(kStr);
+        if (!session)
+            return;
+        reminderWizards.delete(kStr);
+        await retireReminderScreen(key, session.messageId, (0, i18n_1.t)('reminders.cancelledNotice'));
+    }
+    /**
+     * @description Retire a wizard whose step-4 text wait ran out. The triggering
+     * message is NOT consumed by the caller — it falls through to normal handling,
+     * because swallowing it would lose a prompt the operator meant for the agent.
+     */
+    async function expireReminderWizard(key) {
+        const kStr = (0, sessionKey_1.keyToString)(key);
+        const session = reminderWizards.get(kStr);
+        if (!session)
+            return;
+        reminderWizards.delete(kStr);
+        await retireReminderScreen(key, session.messageId, (0, i18n_1.t)('reminders.expiredNotice'));
+    }
+    /**
+     * @description Route an inbound message against the topic's step-4 text wait and,
+     * when it IS the reminder text, CLAIM that wait — synchronously, before the caller
+     * reaches its first `await`.
+     *
+     * The claim is the mutual exclusion: telegraf handles updates concurrently, so two
+     * messages arriving together both pass an unclaimed wait and would each create a
+     * reminder from the one wizard. A single-threaded event loop needs nothing heavier
+     * than this flag — no lock, no timer — provided it is taken in the same synchronous
+     * run as the decision, which is why claiming and routing are one function. Both the
+     * typed and the voice path call it, so they cannot claim differently.
+     */
+    function claimReminderTextCapture(key) {
+        const textWait = reminderWizards.get((0, sessionKey_1.keyToString)(key))?.textWait;
+        const route = (0, reminderFlow_1.getReminderTextCaptureRoute)({
+            armedAtMs: textWait?.armedAtMs ?? null,
+            isClaimed: textWait?.isClaimed === true,
+            nowMs: Date.now(),
+        });
+        if (route === 'capture' && textWait)
+            textWait.isClaimed = true;
+        return route;
+    }
+    /**
+     * @description Persist a finished wizard's reminder, retire the wizard and turn its
+     * message into the created card. The SINGLE creation path — shared by the text
+     * capture and by the `createNow` retry after a stale instant — so the two can never
+     * create reminders differently.
+     */
+    async function createReminderFromWizard(input) {
+        const { key, session, text } = input;
+        reminderWizards.delete((0, sessionKey_1.keyToString)(key));
+        const created = await (0, store_1.createScheduleForThread)(getState(), {
+            threadKey: key,
+            // The wizard never ASKS for a name — one less typing step; the list rows and
+            // the card show the first words of the reminder itself.
+            name: (0, reminderWizard_1.getReminderNameFromText)(text),
+            spec: input.spec,
+            prompt: text,
+            createdBy: 'user',
+            nowMs: input.nowMs,
+            deliveryKind: 'reminder',
+        });
+        if (!created.ok) {
+            await retireReminderScreen(key, session.messageId, (0, i18n_1.t)('reminders.capReachedNotice', { limit: created.limit }));
+            return;
+        }
+        getSchedulerEngine()?.armJob(created.record);
+        await renderReminderScreen(key, session.messageId, buildReminderCreatedScreen(created.record));
+    }
+    /**
+     * @description Turn the wizard's picks plus the operator's text into a reminder —
+     * the entry point shared by the typed message and the transcribed voice note.
+     *
+     * The spec is rebuilt at THIS instant rather than reused from the time step:
+     * minutes pass while the operator types, so a `once` reminder for «today» may have
+     * gone by. That is reported on the time screen — and the text they just sent is
+     * KEPT on the wizard, so the next time pick creates the reminder without asking for
+     * it again. Re-typing the reminder is the one thing this all-buttons flow exists to
+     * avoid.
+     */
+    async function finishReminderWizard(key, text) {
+        const session = reminderWizards.get((0, sessionKey_1.keyToString)(key));
+        const textWait = session?.textWait;
+        if (!session || !textWait)
+            return;
+        // An over-long text is refused outright — it is never truncated, because the
+        // words are the operator's own. The wizard therefore STAYS on step 4 (the error
+        // rides the same screen) and the claim is released first, so the shorter retry is
+        // captured instead of reaching the agent as a prompt.
+        if ((0, reminderFlow_1.getReminderTextAcceptance)(text) === 'tooLong') {
+            textWait.isClaimed = false;
+            await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(session.state, 'textTooLong'));
+            return;
+        }
+        const nowMs = Date.now();
+        const built = (0, reminderWizard_1.buildReminderSpec)({ picks: textWait.picks, nowMs });
+        if (!built.ok) {
+            const retimeStep = (0, reminderWizard_1.getReminderStateForRetime)(session.state, text);
+            session.state = retimeStep;
+            // Disarmed on purpose: the screen now asks for a TIME, not for text.
+            session.textWait = null;
+            await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(retimeStep, built.code));
+            return;
+        }
+        await createReminderFromWizard({ key, session, spec: built.spec, text, nowMs });
+    }
+    function registerReminderCommands() {
+        // `/reminders` — the reminder hub. Deliberately NOT gated on a binding or a
+        // session: the bot itself posts and pins a reminder, so it needs neither a folder
+        // nor an agent and works in every topic, General included.
+        command('reminders', async (_ctx, key) => {
+            const screen = buildReminderHubScreen(key);
+            await replyToThread(key, screen.text, screen.keyboard);
+        });
+    }
+    function registerReminderCallbacks() {
+        /**
+         * @description `/reminders` callbacks. Every one of them EDITS the tapped message
+         * — the hub, the list, a card, the wizard and the created screen are all the same
+         * message re-rendered, so a reminder session never litters the topic.
+         *
+         * The flat ids (`rmadd` / `rmhub` / `rmclose`) are registered before the prefixed
+         * matchers, following the ordering rule the `/timezone` and `/model` pickers rely
+         * on (Telegraf dispatches action patterns first-match-wins).
+         */
+        // «➕ Add» → open the wizard IN the hub message.
+        bot.action(reminderWizard_1.reminderAddCallback, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const messageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+            if (messageId === null) {
+                await ctx.answerCbQuery((0, i18n_1.t)('reminders.wizardExpiredCbAnswer'));
+                return;
+            }
+            // At the cap the hub draws no «add», so a tap can only come from a keyboard
+            // rendered before the cap was reached: say why and refresh the screen.
+            const hubPlan = (0, reminderFlow_1.getReminderHubPlan)({
+                reminderCount: getThreadReminders(key).length,
+                maxReminders: store_1.maxRemindersPerThread,
+            });
+            if (!hubPlan.isAddOffered) {
+                await ctx.answerCbQuery((0, i18n_1.t)('reminders.capReachedNotice', { limit: store_1.maxRemindersPerThread }));
+                await renderReminderScreen(key, messageId, buildReminderHubScreen(key));
+                return;
+            }
+            // An older hub message can still open a wizard while one is live; retire that
+            // one first so only ever one wizard belongs to the topic.
+            await cancelReminderWizard(key);
+            const wizardState = (0, reminderWizard_1.createReminderWizardState)((0, reminderWizard_1.createReminderWizardId)(Date.now()));
+            reminderWizards.set((0, sessionKey_1.keyToString)(key), { state: wizardState, messageId, textWait: null });
+            await ctx.answerCbQuery();
+            await renderReminderScreen(key, messageId, buildReminderWizardScreen(wizardState, null));
+        });
+        // «‹ Back» from the list → the hub.
+        bot.action(reminderWizard_1.reminderHubCallback, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const messageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+            await ctx.answerCbQuery();
+            if (messageId !== null)
+                await renderReminderScreen(key, messageId, buildReminderHubScreen(key));
+        });
+        // «✕ Close» → relabel the screen and drop its keyboard.
+        bot.action(reminderWizard_1.reminderCloseCallback, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const messageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+            await ctx.answerCbQuery();
+            if (messageId !== null)
+                await retireReminderScreen(key, messageId, (0, i18n_1.t)('reminders.closedNotice'));
+        });
+        // A list page (or a prev/next arrow). A now-empty list falls back to the hub.
+        bot.action(reminderWizard_1.reminderListPageCallbackRe, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const messageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+            const page = (0, reminderWizard_1.parseReminderListPageCallback)(ctx.match[0]);
+            await ctx.answerCbQuery();
+            if (messageId === null || page === null)
+                return;
+            await renderReminderScreen(key, messageId, buildReminderListScreen(key, page) ?? buildReminderHubScreen(key));
+        });
+        // A list row → its card. A stale index (the list shrank since it was rendered)
+        // says so and reopens the list rather than opening a NEIGHBOURING reminder.
+        bot.action(reminderWizard_1.reminderCardCallbackRe, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const messageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+            const reminderIndex = (0, reminderWizard_1.parseReminderCardCallback)(ctx.match[0]);
+            if (messageId === null || reminderIndex === null) {
+                await ctx.answerCbQuery();
+                return;
+            }
+            const screen = buildReminderCardScreen(key, reminderIndex);
+            if (screen === null) {
+                await ctx.answerCbQuery((0, i18n_1.t)('reminders.cardExpiredCbAnswer'));
+                await renderReminderScreen(key, messageId, buildReminderListScreen(key, 0) ?? buildReminderHubScreen(key));
+                return;
+            }
+            await ctx.answerCbQuery();
+            await renderReminderScreen(key, messageId, screen);
+        });
+        // «🗑 Delete» — there is deliberately NO extra confirmation step: the card the
+        // button sits on shows exactly what is about to go, so the card IS the
+        // confirmation. The reminder's own id is baked into the callback (never a
+        // positional index), so an old card can't delete whatever now occupies its row.
+        bot.action(reminderWizard_1.reminderDeleteCallbackRe, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const messageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+            const reminderId = (0, reminderWizard_1.parseReminderDeleteCallback)(ctx.match[0]);
+            if (messageId === null || reminderId === null) {
+                await ctx.answerCbQuery();
+                return;
+            }
+            const rows = toReminderListRows(getThreadReminders(key));
+            const target = (0, reminderWizard_1.getReminderDeleteTarget)(rows, reminderId);
+            if (target.kind === 'notFound') {
+                await ctx.answerCbQuery((0, i18n_1.t)('reminders.deleteGoneCbAnswer'));
+                await renderReminderScreen(key, messageId, buildReminderListScreen(key, 0) ?? buildReminderHubScreen(key));
+                return;
+            }
+            // Return to the page the deleted row was on (a shrunk list clamps the page).
+            const listPage = (0, reminderWizard_1.getReminderCardBackPage)(rows.findIndex((row) => row.id === target.row.id));
+            await getState().removeSchedule(target.row.id);
+            getSchedulerEngine()?.disarmJob(target.row.id);
+            await ctx.answerCbQuery((0, i18n_1.t)('reminders.deletedCbAnswer'));
+            await renderReminderScreen(key, messageId, buildReminderListScreen(key, listPage) ?? buildReminderHubScreen(key));
+        });
+        // Every wizard button. The wizard id baked into the callback is what makes an
+        // abandoned keyboard inert: a tap from a dead screen changes NO state.
+        bot.action(reminderWizard_1.reminderWizardCallbackRe, async (ctx) => {
+            const key = await authoriseContext(ctx);
+            if (!key) {
+                await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+                return;
+            }
+            const kStr = (0, sessionKey_1.keyToString)(key);
+            const session = reminderWizards.get(kStr);
+            const callbackData = ctx.match[0];
+            // A tap from a DEAD screen (no wizard live, or a different wizard's id): say so
+            // and strip THAT message's keyboard, because it can never be finished.
+            if (session === undefined ||
+                (0, reminderFlow_1.getReminderWizardTapRoute)({ liveWizardId: session.state.wizardId, callbackData }) === 'foreign') {
+                await ctx.answerCbQuery((0, i18n_1.t)('reminders.wizardExpiredCbAnswer'));
+                await stripReminderKeyboard(ctx);
+                return;
+            }
+            const nowMs = Date.now();
+            const transition = (0, reminderWizard_1.applyReminderWizardCallback)({ state: session.state, callbackData, nowMs });
+            // ONE choke point for the step-4 wait: any outcome that moves the wizard off the
+            // text step disarms it here. «‹ Back» out of step 4 is the reachable case — the
+            // screen goes back to asking for a TIME, and a wait left armed would swallow the
+            // operator's next ordinary message and create the reminder from the picks they
+            // went back to change.
+            if (!(0, reminderFlow_1.checkIsReminderTextWaitKept)(transition.kind))
+                session.textWait = null;
+            switch (transition.kind) {
+                case 'expired':
+                    // The live wizard, but an action from a step it has already left (a tap on a
+                    // stale VIEW of this same message). Re-render the current step instead of
+                    // stripping the keyboard — the wizard is alive and must stay finishable.
+                    await ctx.answerCbQuery((0, i18n_1.t)('reminders.wizardExpiredCbAnswer'));
+                    await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(session.state, null));
+                    return;
+                case 'cancelled':
+                    reminderWizards.delete(kStr);
+                    await ctx.answerCbQuery();
+                    await retireReminderScreen(key, session.messageId, (0, i18n_1.t)('reminders.cancelledNotice'));
+                    return;
+                case 'backToHub':
+                    reminderWizards.delete(kStr);
+                    await ctx.answerCbQuery();
+                    await renderReminderScreen(key, session.messageId, buildReminderHubScreen(key));
+                    return;
+                case 'error':
+                    // The time was not committed: the screen re-renders WITH the reason, so
+                    // «today» plus a time that has gone by is said out loud rather than silently
+                    // rolled to tomorrow. The returned state is written back because it is not
+                    // always the one that came in — a DST-skipped time hands back the TIME step,
+                    // and a screen the session disagreed with would treat the next tap as stale.
+                    session.state = transition.state;
+                    await ctx.answerCbQuery(getReminderWizardErrorText(transition.code));
+                    await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(transition.state, transition.code));
+                    return;
+                case 'render':
+                    session.state = transition.state;
+                    await ctx.answerCbQuery();
+                    await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(session.state, null));
+                    return;
+                case 'awaitText': {
+                    const picks = (0, reminderWizard_1.getReminderPicksFromState)(transition.state);
+                    if (picks === null) {
+                        // Unreachable through the keyboards (`awaitText` is returned only after a
+                        // spec built cleanly from these very picks). Park the wizard back on the
+                        // time step rather than arming a wait that could not create anything.
+                        const timeStep = (0, reminderWizard_1.getReminderStateForStep)(session.state, 'time');
+                        session.state = timeStep;
+                        await ctx.answerCbQuery((0, i18n_1.t)('reminders.wizardExpiredCbAnswer'));
+                        await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(timeStep, null));
+                        return;
+                    }
+                    session.state = transition.state;
+                    session.textWait = { picks, armedAtMs: nowMs, isClaimed: false };
+                    await ctx.answerCbQuery();
+                    await renderReminderScreen(key, session.messageId, buildReminderWizardScreen(session.state, null));
+                    return;
+                }
+                case 'createNow':
+                    // The text is already in hand — it arrived before the picked instant went
+                    // stale — so this replacement time pick finishes the reminder outright
+                    // instead of sending the operator back through step 4. The session is
+                    // retired by the create, so there is no state left to write back.
+                    await ctx.answerCbQuery();
+                    await createReminderFromWizard({
+                        key,
+                        session,
+                        spec: transition.spec,
+                        text: transition.text,
+                        nowMs,
+                    });
+                    return;
+            }
+        });
+    }
+    return {
+        cancelReminderWizard,
+        claimReminderTextCapture,
+        expireReminderWizard,
+        finishReminderWizard,
+        registerReminderCommands,
+        registerReminderCallbacks,
+    };
+}
+//# sourceMappingURL=reminders.js.map