charness 3.6.1 → 3.8.0

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

@@ -2,38 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCompaction = createCompaction;
 const telegraf_1 = require("telegraf");
-const createAdapter_1 = require("../../../adapters/createAdapter");
 // Decides whether the D3 summary guidance rides the compaction instruction: OpenCode bakes it into its fork
 // compaction prompt (covering auto/overflow compaction too), the Claude backends need it every time.
 const adapterNames_1 = require("../../../adapters/adapterNames");
 const sessionKey_1 = require("../../../sessionKey");
 const sessionKeyCodec_1 = require("../sessionKeyCodec");
-const rateLimiter_1 = require("../../../rateLimiter");
 const i18n_1 = require("../../../i18n");
-const sendErrorClassifier_1 = require("../../../sendErrorClassifier");
 const compactCommandRoute_1 = require("../../../utils/compactCommandRoute");
 const compactOnIdle_1 = require("../../../utils/compactOnIdle");
 const questionKeyboards_1 = require("../questionKeyboards");
 const messageSplit_1 = require("../messageSplit");
+const openCodeQuestionFlow_1 = require("../../../openCodeQuestionFlow");
+const callbackMessage_1 = require("./callbackMessage");
+const callbackToast_1 = require("./callbackToast");
 /** The literal slash command forwarded to backends whose own CLI parses it. */
 const compactCommandText = '/compact';
 /** `adapter.name` of the raw-shell backend (see the `terminal` adapter). */
 const terminalAdapterName = 'terminal';
 /**
  * @description Compose the per-invocation compaction instruction for a thread's
- * backend (D3 summary guidance + the loaded-skills guidance + the optional F2
- * closing section). The general guidance is skipped for OpenCode (baked in its
- * fork prompt) and appended for the Claude backends; the skills guidance is
- * skipped when the backend's own compaction prompt already gets it (an OpenCode
- * server running the bot's compaction plugin); the closing-section directive
- * rides only when requested.
+ * backend (D3 summary guidance + the resume guidance — loaded skills and the
+ * next-steps checklist — + the optional F2 closing section). The general guidance
+ * is skipped for OpenCode (baked in its fork prompt) and appended for the Claude
+ * backends; the resume guidance is skipped when the backend's own compaction
+ * prompt already gets it (an OpenCode server running the bot's compaction
+ * plugin); the closing-section directive rides only when requested.
  */
 async function getCompactionInstruction(adapter, key, opts) {
     return (0, compactOnIdle_1.buildCompactionInstruction)({
         bakesSummaryGuidance: adapter.name === adapterNames_1.openCodeAdapterName,
         summaryGuidance: compactOnIdle_1.compactionSummaryGuidance,
-        bakesSkillsGuidance: (await adapter.checkHasCompactionSkillsHook?.(key)) ?? false,
-        skillsGuidance: compactOnIdle_1.compactionSkillsGuidance,
+        bakesResumeGuidance: (await adapter.checkHasCompactionResumeHook?.(key)) ?? false,
+        resumeGuidance: compactOnIdle_1.compactionResumeGuidance,
         closingSectionInstruction: opts.withClosingSection
             ? (0, i18n_1.t)('compact.closingSectionInstruction', {
                 startMarker: compactOnIdle_1.compactionClosingStartMarker,
@@ -50,21 +50,6 @@ async function getCompactionInstruction(adapter, key, opts) {
 // ONE compaction path (plan 2026-09-14-self-compact-and-compact-on-idle).
 /** F1 poll cadence while waiting for the current turn to finish before draining. */
 const deferredCompactionPollMs = 3_000;
-/**
- * @description Resolve the `/compact` route for a thread's current backend — the
- * pure {@link getCompactCommandRoute} wrapped with the live adapter reading.
- * Every compaction entry point (the command, the seam, the F1 arm + drain, the
- * `/compact_on_idle` gate) asks the same question, so the three-line lookup lives
- * in ONE place rather than being spelled out at each of them.
- */
-function getThreadCompactRoute(key) {
-    const adapter = (0, createAdapter_1.getThreadAdapter)(key);
-    return (0, compactCommandRoute_1.getCompactCommandRoute)({
-        hasCompactContext: Boolean(adapter.compactContext),
-        adapterName: adapter.name,
-        terminalAdapterName,
-    });
-}
 /**
  * Build the `/compact_on_idle` picker keyboard: Enable / Disable, then Show / Hide
  * summary, ✓ on the current value of each.
@@ -87,7 +72,22 @@ function buildCompactOnIdleKeyboard(picker) {
  * state the typing loop and the request probe read, and the `register…()` calls.
  */
 function createCompaction(ports) {
-    const { startTypingLoader, forwardPromptToAgent, pendingQuestions, clearPendingQuestion, idleWindowMs, checkIsLimitWaitArmed, suspendThreadSession, resumeSleepingSessionForCompaction, bot, command, getState, replyToThread, deleteThreadMessage, authoriseContext, withThreadLocale, checkIsGeneral, wakeSleepingSession } = ports;
+    const { startTypingLoader, forwardPromptToAgent, pendingQuestions, clearPendingQuestion, closeQuestionMessage, idleWindowMs, checkIsLimitWaitArmed, suspendThreadSession, resumeSleepingSessionForCompaction, getThreadAdapter, deliverLabel, resumeSleepingSessionForPrompt, checkIsStarting, closeOrphanQuestionMessage, notePersonActivity, bot, command, getState, replyToThread, editThreadKeyboard, authoriseContext, withThreadLocale, checkIsGeneral, wakeSleepingSession } = ports;
+    /**
+     * @description Resolve the `/compact` route for a thread's current backend — the
+     * pure {@link getCompactCommandRoute} wrapped with the live adapter reading.
+     * Every compaction entry point (the command, the seam, the F1 arm + drain, the
+     * `/compact_on_idle` gate) asks the same question, so the three-line lookup lives
+     * in ONE place rather than being spelled out at each of them.
+     */
+    function getThreadCompactRoute(key) {
+        const adapter = getThreadAdapter(key);
+        return (0, compactCommandRoute_1.getCompactCommandRoute)({
+            hasCompactContext: Boolean(adapter.compactContext),
+            adapterName: adapter.name,
+            terminalAdapterName,
+        });
+    }
     /**
      * Threads with a compaction IN FLIGHT (via {@link runThreadCompaction}). While a
      * key is here, the compaction's OWN output (some backends stream the summary
@@ -122,7 +122,7 @@ function createCompaction(ports) {
      * stop here could kill a loader a CONCURRENT prompt had armed.
      */
     async function runThreadCompaction(key, opts) {
-        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+        const adapter = getThreadAdapter(key);
         if (!adapter.checkIsActive(key))
             return { ok: false, error: (0, i18n_1.t)('compact.start_agent_first') };
         const route = getThreadCompactRoute(key);
@@ -202,7 +202,7 @@ function createCompaction(ports) {
         // a dead session as its first act, and a "compacting…" ahead of that refusal is a
         // promise the very next message retracts. The seam still re-checks, so a session
         // lost right afterwards just reports the failure as before.
-        if (isInTopic && (0, compactOnIdle_1.checkShouldAnnounceCompactionStart)({ route, isSessionActive: (0, createAdapter_1.getThreadAdapter)(key).checkIsActive(key) })) {
+        if (isInTopic && (0, compactOnIdle_1.checkShouldAnnounceCompactionStart)({ route, isSessionActive: getThreadAdapter(key).checkIsActive(key) })) {
             await replyToThread(key, (0, i18n_1.t)('compact.started'));
         }
         // No closing section: the operator is right here, so there is nothing to recap
@@ -320,7 +320,7 @@ function createCompaction(ports) {
         if (threadsCompacting.has(kStr))
             return;
         clearIdleFireTimer(kStr);
-        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+        const adapter = getThreadAdapter(key);
         const isSuspendable = typeof adapter.suspendSession === 'function';
         if (!isSuspendable && !getState().checkIsCompactOnIdleEnabled(key))
             return;
@@ -414,7 +414,7 @@ function createCompaction(ports) {
         if (pollTimer)
             clearTimeout(pollTimer);
         deferredCompactionPollTimers.delete(kStr);
-        reAskedQuestionOptions.delete(kStr);
+        closeReAskedQuestion(key);
     }
     /**
      * @description Whether the topic's process is WORKING right now (L-D2). The
@@ -448,7 +448,7 @@ function createCompaction(ports) {
     }
     async function onIdleCompactionTimerFired(key) {
         const kStr = (0, sessionKey_1.keyToString)(key);
-        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+        const adapter = getThreadAdapter(key);
         // L-D7: a sleeping per-turn session is resumed for its compaction; the stop below puts it back to sleep.
         if (!adapter.checkIsActive(key) && adapter.name === adapterNames_1.claudePerTurnAdapterName && checkIsCompactionDue(key)) {
             if (!(await resumeSleepingSessionForCompaction(key))) {
@@ -532,17 +532,26 @@ function createCompaction(ports) {
         await getState().setCompactIdleCompactedAt(key);
         // D1: a pending question at idle → reject it server-side to UNBLOCK the turn
         // (reusing each backend's abort-error swallow via rejectQuestion + SIGINT),
-        // remember it, drop the bot-side pending state + its now-stale buttons, then
-        // RE-ASK it after the compaction with real buttons that feed a fresh prompt.
-        let savedQuestion = null;
+        // remember it, drop the bot-side pending state (and its pin), then RE-ASK it after the compaction with real buttons
+        // that feed a fresh prompt. The old message stays as the record, but is edited only once the re-ask is there
+        // ({@link postIdleCompactionResult}): the compaction can take minutes, and «asked again below» would be untrue.
+        let reAsked = null;
         if (hasPendingQuestion) {
-            savedQuestion = pendingQuestions.get(kStr) ?? null;
-            const staleQuestionMessageId = savedQuestion?.messageId ?? null;
+            const savedQuestion = pendingQuestions.get(kStr) ?? null;
             adapter.rejectQuestion?.(key);
             adapter.sendSignal(key, 'SIGINT');
             clearPendingQuestion(key);
-            if (staleQuestionMessageId !== null) {
-                await deleteThreadMessage(key, staleQuestionMessageId).catch(() => { });
+            const question = savedQuestion?.data.questions[savedQuestion.currentIndex];
+            if (savedQuestion && question) {
+                // From here the question lives in a record of its own, SAVED (a restart during the compaction asks it again at boot,
+                // or ends the old message as unanswered when the conversation is gone, instead of forgetting it), and a person who
+                // writes, a conversation that ends or a number typed
+                // reach it like they reach any re-asked question — so someone who writes meanwhile also stops the re-ask.
+                reAsked = startReAskedQuestion(key, question, savedQuestion.messageId);
+                // Its buttons are dead from here (the question is no longer pending) and the compaction can take minutes: they come
+                // off at once. The text waits for the re-ask's outcome.
+                if (savedQuestion.messageId !== null)
+                    void editThreadKeyboard(key, savedQuestion.messageId, null, 'idleReask');
             }
         }
         const result = await runThreadCompaction(key, { withClosingSection: true });
@@ -551,31 +560,290 @@ function createCompaction(ports) {
             // The compaction failed but the question is already rejected — re-ask it so
             // the user isn't left without the pending decision (no notice: nothing was
             // compacted).
-            await postIdleCompactionResult(key, { noticeText: null, summary: null }, savedQuestion);
+            await postIdleCompactionResult(key, { noticeText: null, summary: null }, reAsked);
             return;
         }
         await postIdleCompactionResult(key, {
             noticeText: (0, i18n_1.t)('compactOnIdle.notice'),
             summary: result.summary ?? null,
-        }, savedQuestion);
+        }, reAsked);
+    }
+    /**
+     * @description Per-thread idle-compaction RE-ASKED question (D1), keyed by {@link SessionKey} string — the record of
+     * {@link ReAskedQuestion}, from the start of the compaction on. A `reask_<idx>` tap, or an option NUMBER typed, forwards the
+     * label of its option to the (now compacted) session as a FRESH prompt — the original question request was rejected
+     * server-side, so it cannot be answered any more — and writes the answer under the question. When the conversation ends
+     * instead ({@link closeReAskedQuestion}), or a person writes something else, the message is closed as unanswered, so its
+     * buttons never sit there dead nor get tapped later onto whatever the agent asks next. The record is also kept in the saved
+     * state, so a restart finds it: its buttons keep working while the conversation sleeps ({@link restoreReAskedQuestion}),
+     * and a restart during the compaction asks the question again ({@link reAskInterruptedQuestion}) while the conversation can
+     * still be resumed, or closes the old message as unanswered when it is gone.
+     */
+    const reAskedQuestions = new Map();
+    /**
+     * The record as the saved state keeps it: the posted re-ask's message, or — before it is posted — the message the question
+     * waited in, flagged as such. `null` when there is no message to remember.
+     */
+    function buildSavedReAskedQuestion(reAsked) {
+        if (reAsked.messageId !== null) {
+            // The old message goes with it, and whether its result has landed: a restart between the post and that edit finishes it.
+            return reAsked.predecessorMessageId === null
+                ? { messageId: reAsked.messageId, question: reAsked.question }
+                : { messageId: reAsked.messageId, question: reAsked.question, predecessorMessageId: reAsked.predecessorMessageId, isPredecessorClosed: reAsked.isPredecessorEditLanded };
+        }
+        if (reAsked.predecessorMessageId !== null)
+            return { messageId: reAsked.predecessorMessageId, question: reAsked.question, isPosted: false };
+        return null;
+    }
+    /**
+     * The messages of a topic that already carry a result of a re-asked question — an answer a tap or a number took, or a close that
+     * landed — most recent last. A button can still be tapped on such a message from a stale view (a second tap on the spinner the first
+     * one left): it must not be taken for a message the bot knows nothing about, whose own text would be rewritten over the result.
+     */
+    const endedMessageIds = new Map();
+    const endedMessageLimit = 100;
+    function rememberEndedMessage(key, messageId) {
+        if (messageId === null)
+            return;
+        const kStr = (0, sessionKey_1.keyToString)(key);
+        const messageIds = endedMessageIds.get(kStr) ?? new Set();
+        messageIds.delete(messageId);
+        messageIds.add(messageId);
+        if (messageIds.size > endedMessageLimit) {
+            const oldest = messageIds.values().next().value;
+            if (oldest !== undefined)
+                messageIds.delete(oldest);
+        }
+        endedMessageIds.set(kStr, messageIds);
+    }
+    function forgetEndedMessage(key, messageId) {
+        if (messageId !== null)
+            endedMessageIds.get((0, sessionKey_1.keyToString)(key))?.delete(messageId);
+    }
+    function checkIsEndedMessage(key, messageId) {
+        return endedMessageIds.get((0, sessionKey_1.keyToString)(key))?.has(messageId) ?? false;
+    }
+    /** Give a message of the re-asked question its result through the bot's close; one that landed is remembered as ended. */
+    async function closeReAskedMessage(key, messageId, question, ending) {
+        const isEdited = await closeQuestionMessage(key, messageId, question, ending);
+        if (isEdited)
+            rememberEndedMessage(key, messageId);
+        return isEdited;
+    }
+    /** Keep the record in the saved state; a failed write is logged, the in-memory record is what a tap reads. */
+    function saveReAskedQuestion(key, reAsked) {
+        const record = buildSavedReAskedQuestion(reAsked);
+        if (record === null)
+            return;
+        getState().setReAskedQuestion(key, record).catch((e) => console.error('[reAskedQuestion] persist failed:', e));
+    }
+    /** Drop the re-asked question from the saved state; a failed write is logged. */
+    function forgetSavedReAskedQuestion(key) {
+        getState().clearReAskedQuestion(key).catch((e) => console.error('[reAskedQuestion] clear failed:', e));
+    }
+    /**
+     * The idle compaction takes a pending question over: the record starts in its COMPACTING phase, saved at once. The old
+     * message is the predecessor (`null` when it never got an id).
+     */
+    function startReAskedQuestion(key, question, predecessorMessageId) {
+        const reAsked = {
+            question,
+            messageId: null,
+            predecessorMessageId,
+            isPredecessorClosed: false,
+            isPredecessorEditLanded: false,
+            ending: null,
+            isAnswerPending: false,
+            sendPhase: 'notStarted',
+            hasIdleResultRun: false,
+        };
+        reAskedQuestions.set((0, sessionKey_1.keyToString)(key), reAsked);
+        saveReAskedQuestion(key, reAsked);
+        return reAsked;
+    }
+    /** The record is over without a result to write (its send failed): out of memory and of the saved state. */
+    function dropReAskedQuestion(key) {
+        reAskedQuestions.delete((0, sessionKey_1.keyToString)(key));
+        forgetSavedReAskedQuestion(key);
+    }
+    /** The re-asked question a `reask_<idx>` tap or a typed number works on, still kept. */
+    function peekReAskedQuestion(key) {
+        return reAskedQuestions.get((0, sessionKey_1.keyToString)(key));
+    }
+    /**
+     * @description A tap takes the re-asked question out of memory and of the saved state: it is used now, so nothing closes
+     * its message as unanswered any more (the tap writes the answer there), and a restart does not bring it back. An `ending`
+     * is what a re-ask still being sent writes on its message when it lands (the end of the conversation).
+     */
+    function takeReAskedQuestion(key, ending = null) {
+        const kStr = (0, sessionKey_1.keyToString)(key);
+        const reAsked = reAskedQuestions.get(kStr);
+        if (!reAsked)
+            return undefined;
+        reAskedQuestions.delete(kStr);
+        reAsked.ending = ending;
+        forgetSavedReAskedQuestion(key);
+        return reAsked;
+    }
+    /**
+     * @description A number typed answers the question: the record is taken like a tap's, with no ending yet and
+     * {@link ReAskedQuestion.isAnswerPending} set. The label may still reach no session, and then the question is open again, so
+     * the answer is written by {@link answerReAskedQuestion} once the delivery is known.
+     */
+    function takeReAskedQuestionForAnswer(key) {
+        const reAsked = takeReAskedQuestion(key);
+        if (!reAsked)
+            return undefined;
+        reAsked.isAnswerPending = true;
+        rememberAnsweredMessages(key, reAsked, reAsked.messageId);
+        return reAsked;
+    }
+    /**
+     * A tap or a number took the question to answer it: the copy (`copyMessageId`, which a tap may know before the record does) and
+     * the old message are going to carry that answer, so a second tap on either — from a stale view, while the first is still being
+     * delivered — answers nothing and rewrites nothing.
+     */
+    function rememberAnsweredMessages(key, reAsked, copyMessageId) {
+        rememberEndedMessage(key, copyMessageId);
+        rememberEndedMessage(key, reAsked.predecessorMessageId);
+    }
+    /**
+     * @description The label of a taken question reached the agent: write `answer` as its result on its messages — the re-ask's
+     * own if it is known (one that lands later ends the same way), and the predecessor if it has no result yet.
+     */
+    async function answerReAskedQuestion(key, reAsked, answer) {
+        reAsked.isAnswerPending = false;
+        reAsked.ending = { answer };
+        await endReAskedQuestion(key, reAsked);
+    }
+    /**
+     * A tap whose label reached no session leaves the question open: the record goes back, unless a newer one took its place.
+     * Resolves whether it went back — when not, the tapped message is no longer the question that waits.
+     */
+    function putBackReAskedQuestion(key, reAsked) {
+        if (reAskedQuestions.has((0, sessionKey_1.keyToString)(key)))
+            return false;
+        reAsked.ending = null;
+        reAsked.isAnswerPending = false;
+        reAskedQuestions.set((0, sessionKey_1.keyToString)(key), reAsked);
+        saveReAskedQuestion(key, reAsked);
+        return true;
+    }
+    /**
+     * Boot: a saved re-asked question whose conversation can still be resumed gets its buttons back (memory only, it is saved already).
+     * A restart between the post of the copy and the edit of the old message leaves the old message without a note: it gets it now.
+     */
+    function restoreReAskedQuestion(key, saved) {
+        const isPredecessorSettled = saved.predecessorMessageId === undefined || saved.predecessorMessageId === null || saved.isPredecessorClosed !== false;
+        const reAsked = {
+            question: saved.question,
+            messageId: saved.messageId,
+            predecessorMessageId: saved.predecessorMessageId ?? null,
+            isPredecessorClosed: isPredecessorSettled,
+            isPredecessorEditLanded: isPredecessorSettled,
+            ending: null,
+            isAnswerPending: false,
+            sendPhase: 'finished',
+            hasIdleResultRun: true,
+        };
+        reAskedQuestions.set((0, sessionKey_1.keyToString)(key), reAsked);
+        settleReAskedPredecessor(key, reAsked).catch((e) => console.error('[reAskedQuestion] settling the old message at boot failed:', e));
+    }
+    /**
+     * Boot: a saved re-asked question that cannot be brought back (its conversation is gone, or a question waits beside it) ends:
+     * its message — and the old message, if the restart left that without a note — is closed as unanswered, never left with buttons that
+     * do nothing or would answer the wrong question, and the saved record is dropped. An unposted record names the old message itself.
+     */
+    function closeSavedReAskedQuestion(key, saved) {
+        forgetSavedReAskedQuestion(key);
+        const messageIds = [saved.messageId];
+        if (saved.isPosted !== false && saved.predecessorMessageId != null && saved.isPredecessorClosed === false)
+            messageIds.push(saved.predecessorMessageId);
+        for (const messageId of messageIds) {
+            closeReAskedMessage(key, messageId, saved.question, 'unanswered')
+                .catch((e) => console.error('[reAskedQuestion] closing the saved question failed:', e));
+        }
+    }
+    /**
+     * @description Write the record's `ending` on its messages: the re-ask's own, if it is known, and the predecessor, if it has
+     * no result yet (a re-ask that ends before it is posted ends the question where it waited). A copy that lands later is closed
+     * by {@link postReAskedQuestion} with the same ending.
+     */
+    async function endReAskedQuestion(key, reAsked) {
+        const ending = reAsked.ending;
+        if (ending === null)
+            return;
+        if (reAsked.messageId !== null)
+            await closeReAskedMessage(key, reAsked.messageId, reAsked.question, ending);
+        if (reAsked.predecessorMessageId !== null && !reAsked.isPredecessorClosed) {
+            reAsked.isPredecessorClosed = true;
+            await closeReAskedMessage(key, reAsked.predecessorMessageId, reAsked.question, ending);
+        }
     }
     /**
-     * @description Per-thread option labels of an idle-compaction RE-ASKED question
-     * (D1), keyed by {@link SessionKey} string. A `reask_<idx>` tap forwards the
-     * matching label to the (now compacted) session as a FRESH prompt — the original
-     * question request was rejected server-side, so it cannot be answered any more.
-     * In-memory only: after a restart the buttons are simply inert ("no pending
-     * question"), which is safe.
+     * @description The re-asked question will not be tapped any more — its conversation ended (session closed or stopped,
+     * `/quit`, `/quitall`, `/new`, leaving the folder, another conversation picked), a person wrote something else, or the
+     * agent asked a newer question: forget it and close its message as unanswered — the question stays, the buttons go. In
+     * the compaction's own phase the message that closes is the one the question waited in. A re-ask whose send is still in
+     * flight has no message id yet: its ending is set, and the send closes the message when it lands. A question used by a
+     * tap is no longer here, so its answer is never overwritten.
      */
-    const reAskedQuestionOptions = new Map();
+    function closeReAskedQuestion(key) {
+        const reAsked = takeReAskedQuestion(key, 'unanswered');
+        if (!reAsked)
+            return;
+        endReAskedQuestion(key, reAsked).catch((e) => console.error('[reAskedQuestion] close failed:', e));
+    }
     /**
-     * @description Build the RE-ASK inline keyboard for an idle-compaction pending
-     * question (D1) and record its option labels so a `reask_<idx>` tap can forward
-     * the chosen label as a fresh prompt.
+     * @description Post the RE-ASKED question (D1) with its option buttons — the record is in the map already, in its COMPACTING
+     * phase, so a `reask_<idx>` tap that lands right after the send finds it and can forward the chosen label as a fresh
+     * prompt. Its message id is recorded once the send resolves (and the record saved, unless a tap or an ending took it
+     * meanwhile). Resolves that id — `null` when the send failed, and then there is no record either: nothing was posted that
+     * a tap could be on.
      */
-    function buildReAskKeyboard(key, question) {
-        reAskedQuestionOptions.set((0, sessionKey_1.keyToString)(key), question.options.map((opt) => opt.label));
-        return (0, questionKeyboards_1.buildQuestionOptionsKeyboard)(question, (optionIndex) => `reask_${optionIndex}`);
+    async function postReAskedQuestion(key, text, reAsked) {
+        const keyboard = (0, questionKeyboards_1.buildQuestionOptionsKeyboard)(reAsked.question, (optionIndex) => `reask_${optionIndex}`);
+        reAsked.sendPhase = 'inFlight';
+        const sentMessageId = await replyToThread(key, text, (0, questionKeyboards_1.buildKeyboardExtra)(keyboard));
+        reAsked.sendPhase = 'finished';
+        const isStillKept = reAskedQuestions.get((0, sessionKey_1.keyToString)(key)) === reAsked;
+        if (sentMessageId === null) {
+            if (isStillKept)
+                dropReAskedQuestion(key);
+            return null;
+        }
+        reAsked.messageId = sentMessageId;
+        // The conversation ended (or a number answered) while the send was in flight: the message that landed ends the same way.
+        if (reAsked.ending !== null)
+            await endReAskedQuestion(key, reAsked);
+        else if (isStillKept)
+            saveReAskedQuestion(key, reAsked);
+        // Taken to be answered (a tap or a number): the copy that landed is going to carry the answer.
+        else
+            rememberEndedMessage(key, sentMessageId);
+        return sentMessageId;
+    }
+    /** The text of the re-asked question's message: the sentence that says it is asked again, then the question (its options are the buttons). */
+    function buildReAskedQuestionText(question) {
+        return [
+            (0, i18n_1.t)('compactOnIdle.pendingQuestionReask'),
+            question.header ? `${question.header}\n${question.question}` : question.question,
+        ].join('\n\n');
+    }
+    /**
+     * @description Boot: the bot stopped between the start of an idle compaction and the re-ask of its question, so `saved` names
+     * the message the question waited in (its buttons off, no result yet). The question was rejected on the agent's side, and
+     * nobody has had the chance to answer it — so, when the conversation can still be resumed, it is asked again NOW, by the very
+     * post the idle fire makes, and the old message says so. A re-ask that cannot be sent ends the old message as unanswered, as
+     * in the idle fire.
+     */
+    async function reAskInterruptedQuestion(key, saved) {
+        await withThreadLocale(key, async () => {
+            const reAsked = startReAskedQuestion(key, saved.question, saved.messageId);
+            reAsked.hasIdleResultRun = true;
+            await postReAskedQuestion(key, buildReAskedQuestionText(saved.question), reAsked);
+            await settleReAskedPredecessor(key, reAsked);
+        });
     }
     /**
      * @description Post the idle-compaction outcome (D1/D2) as SEPARATE messages in
@@ -590,15 +858,12 @@ function createCompaction(ports) {
      *
      * `parts.noticeText` is `null` on a compaction failure (re-ask only, no notice).
      * No-op when there is nothing at all to say.
+     *
+     * The re-ask is posted only if its record is still kept: someone who wrote while the compaction ran, a conversation that
+     * ended, or a number typed has ended it already, and then the old message has its result.
      */
-    async function postIdleCompactionResult(key, parts, savedQuestion) {
-        const question = savedQuestion?.data.questions[savedQuestion.currentIndex];
-        const questionText = question
-            ? [
-                (0, i18n_1.t)('compactOnIdle.pendingQuestionReask'),
-                question.header ? `${question.header}\n${question.question}` : question.question,
-            ].join('\n\n')
-            : null;
+    async function postIdleCompactionResult(key, parts, reAsked) {
+        const questionText = reAsked ? buildReAskedQuestionText(reAsked.question) : null;
         // A tracker issue has no topic to narrate into (R6): the compaction and the stop stay silent there.
         if (!(0, sessionKeyCodec_1.checkIsTelegramKey)(key))
             return;
@@ -607,11 +872,175 @@ function createCompaction(ports) {
             await replyToThread(key, plan.notice);
         if (plan.summary)
             await postCompactionSummary(key, plan.summary);
-        // The keyboard is built HERE (not while planning): it also records the option
-        // labels a `reask_<idx>` tap resolves against, which must not happen for a
-        // question that is never posted.
-        if (plan.question && question)
-            await replyToThread(key, plan.question, (0, questionKeyboards_1.buildKeyboardExtra)(buildReAskKeyboard(key, question)));
+        if (!reAsked)
+            return;
+        // From here the re-ask is decided: a record taken meanwhile (a number typed) is not posted, and whoever puts it back finishes it.
+        reAsked.hasIdleResultRun = true;
+        if (plan.question && peekReAskedQuestion(key) === reAsked)
+            await postReAskedQuestion(key, plan.question, reAsked);
+        await settleReAskedPredecessor(key, reAsked);
+    }
+    /**
+     * @description The old question message stays as the record. It says "asked again below" only once there IS a copy below — if
+     * the re-ask could not be sent, nobody answered it and nobody will be asked again. An ending written on it already (a person
+     * wrote, the conversation ended) stands, and so does the result of a number whose delivery is under way: that answer
+     * writes it, or puts the question back and settles the predecessor again.
+     */
+    async function settleReAskedPredecessor(key, reAsked) {
+        if (reAsked.ending !== null || reAsked.isAnswerPending || reAsked.predecessorMessageId === null || reAsked.isPredecessorClosed)
+            return;
+        reAsked.isPredecessorClosed = true;
+        const isEdited = await closeReAskedMessage(key, reAsked.predecessorMessageId, reAsked.question, reAsked.messageId !== null ? 'askedAgain' : 'unanswered');
+        if (!isEdited)
+            return;
+        // Saved only now, so a restart before the edit landed finds the old message unsettled and finishes it.
+        reAsked.isPredecessorEditLanded = true;
+        if (reAskedQuestions.get((0, sessionKey_1.keyToString)(key)) === reAsked)
+            saveReAskedQuestion(key, reAsked);
+    }
+    /**
+     * @description A tap on a button of the question the idle compaction asked again (D1). The original request was rejected
+     * on the agent's side during the compaction, so the chosen option's label is delivered to the (now compacted) conversation
+     * as a FRESH prompt, not answered. Once it is delivered the re-asked message stays as the record: the question as asked,
+     * the chosen answer in place of the buttons.
+     */
+    async function handleReAskedQuestionTap(ctx, optionIndex) {
+        const key = await authoriseContext(ctx);
+        if (!key) {
+            await ctx.answerCbQuery((0, i18n_1.t)('cb.access_denied'));
+            return;
+        }
+        const tappedMessageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+        const reAsked = peekReAskedQuestion(key);
+        // A re-ask whose send has not returned has no message id, and when the old message has none either there is nothing to tell
+        // the tapped message from an older copy by: no tap is taken until the id is known, and none is rewritten.
+        if (reAsked !== undefined && reAsked.messageId === null && reAsked.predecessorMessageId === null) {
+            await ctx.answerCbQuery((0, i18n_1.t)('cb.no_pending_question'));
+            return;
+        }
+        // The tap must be on the message of the question that waits now. A button left on an OLDER re-asked message (its close
+        // failed, or it predates a restart) would answer the newer question with that question's own label: it answers nothing,
+        // and its buttons come off. A re-ask whose send has not returned has no message id yet — the tap is on that message if
+        // it is NEWER than the one the question waited in before (the re-ask is always posted after it); older ones are the stale ones.
+        const isTappedMessageCurrent = reAsked !== undefined && (reAsked.messageId !== null
+            ? reAsked.messageId === tappedMessageId
+            : tappedMessageId !== null && reAsked.predecessorMessageId !== null && tappedMessageId > reAsked.predecessorMessageId);
+        if (!isTappedMessageCurrent) {
+            await ctx.answerCbQuery((0, i18n_1.t)('cb.no_pending_question'));
+            // A message that already carries a result (an answer a first tap is still delivering, a close that landed) is left as it is:
+            // a second tap from a stale view must not rewrite it. Only a message the bot knows nothing about is closed here.
+            if (tappedMessageId === null || checkIsEndedMessage(key, tappedMessageId))
+                return;
+            rememberEndedMessage(key, tappedMessageId);
+            // Not awaited: the edit waits its turn in the send pacer, and the next update of the topic waits for this handler. Marked
+            // first, so two quick taps do not both close it; a close that did not land leaves live buttons that do nothing, so the
+            // mark is taken back and the next tap tries again.
+            closeOrphanQuestionMessage(key, tappedMessageId, (0, callbackMessage_1.getCallbackMessageText)(ctx))
+                .then((isClosed) => { if (!isClosed)
+                forgetEndedMessage(key, tappedMessageId); })
+                .catch((e) => {
+                forgetEndedMessage(key, tappedMessageId);
+                console.error('[reask] closing the tapped orphan failed:', e);
+            });
+            return;
+        }
+        const label = reAsked.question.options[optionIndex]?.label;
+        if (!label) {
+            await ctx.answerCbQuery((0, i18n_1.t)('cb.invalid_option'));
+            return;
+        }
+        // The question is taken before anything is awaited and put back if the label reaches no one: from here on it is this
+        // tap's, so no other path can use it or close it under the answer.
+        takeReAskedQuestion(key);
+        const reAskedMessageId = reAsked.messageId ?? tappedMessageId;
+        rememberAnsweredMessages(key, reAsked, reAskedMessageId);
+        // The idle fire posts the re-asked question just BEFORE it stops the process, and a stopping process still reads as
+        // active: a tap inside that window (or inside a start) is buffered like a typed prompt and replayed once a session is up.
+        // The answer to a re-asked question wakes a sleeping conversation (L-D4) — the question is its own.
+        if (!checkIsStarting(key) && !getThreadAdapter(key).checkIsActive(key) && !(await resumeSleepingSessionForPrompt(key))) {
+            await returnReAskedQuestionAfterTap(key, reAsked, reAskedMessageId);
+            await ctx.answerCbQuery((0, i18n_1.t)('agent.no_session'));
+            return;
+        }
+        // The closed question carries the whole label, so the toast may cut it; it is posted whole only if that close fails.
+        const isLabelCut = await (0, callbackToast_1.answerCallbackWithFittedText)(ctx, label);
+        // An answer to the agent's own question is never a request (S7), even delivered as a prompt. Routed at delivery,
+        // not on the `checkIsStarting` read above: the stop may have ended during the toast, and a label buffered into its closed
+        // window was never replayed.
+        const outcome = await deliverLabel(key, label);
+        // The label reached no session (the topic was told why): the question is still open, so are its buttons.
+        if (outcome === 'noSession') {
+            await returnReAskedQuestionAfterTap(key, reAsked, reAskedMessageId);
+            return;
+        }
+        const isAnswerShown = reAskedMessageId !== null && await closeReAskedMessage(key, reAskedMessageId, reAsked.question, { answer: label });
+        if (!isAnswerShown && isLabelCut)
+            await replyToThread(key, label);
+    }
+    /**
+     * @description A bare option NUMBER typed while the question the idle compaction asks again waits — for its re-ask (the
+     * compaction runs: the buttons are off, the numbered options are still on screen) or for a tap — answers it, like a tap on
+     * that option: the label goes to the agent as a fresh prompt and the answer is written under the question. Without this the
+     * number would count as the person writing something else: the question would end «not answered» and the agent would get a
+     * bare «2». Resolves whether the text was such a number (and was handled).
+     */
+    async function answerReAskedQuestionByNumber(key, text) {
+        const reAsked = peekReAskedQuestion(key);
+        if (!reAsked)
+            return false;
+        const route = (0, openCodeQuestionFlow_1.getQuestionReplyRoute)(text, reAsked.question);
+        if (route.kind !== 'answer')
+            return false;
+        const label = route.labels[0];
+        // Taken before anything is awaited, so no other path uses or closes it, but with no result written yet: the label may reach no
+        // session, and a re-ask that lands meanwhile is left as it is until that is known.
+        takeReAskedQuestionForAnswer(key);
+        // A person wrote — the latch clears like for any message; the record is gone, so nothing is closed as «not answered».
+        notePersonActivity(key);
+        const outcome = await deliverLabel(key, label);
+        if (outcome === 'noSession') {
+            const isPutBack = await returnReAskedQuestionAfterTap(key, reAsked, reAsked.messageId ?? reAsked.predecessorMessageId);
+            if (isPutBack)
+                await finishReAskAfterNumberFoundNoSession(key, reAsked);
+            return true;
+        }
+        await answerReAskedQuestion(key, reAsked, label);
+        return true;
+    }
+    /**
+     * @description A typed number found no session and the question is open again. The idle fire decides about the re-ask once, and
+     * it skips a record a number has taken (an answer was on its way): so what the fire left undone is done here, once it has run.
+     *  - the fire has not run yet — it will post the re-ask itself, now that the record is back;
+     *  - its send is in flight — the fire settles the old message when the copy lands;
+     *  - the fire ran and sent nothing — the re-ask is posted now, and the old message points at it (or ends «not answered» if the
+     *    send fails);
+     *  - the copy is there already, the old message waiting for the answer's outcome — it says where the question went.
+     */
+    async function finishReAskAfterNumberFoundNoSession(key, reAsked) {
+        if (!reAsked.hasIdleResultRun || reAsked.sendPhase === 'inFlight')
+            return;
+        if (reAsked.sendPhase === 'notStarted') {
+            await withThreadLocale(key, () => postReAskedQuestion(key, buildReAskedQuestionText(reAsked.question), reAsked));
+        }
+        await settleReAskedPredecessor(key, reAsked);
+        // A send that failed leaves nothing to answer: the question ended on the old message.
+        if (reAsked.messageId === null && peekReAskedQuestion(key) === reAsked)
+            dropReAskedQuestion(key);
+    }
+    /**
+     * @description A tap on a re-asked question whose label reached no session leaves the question open: its record goes back.
+     * Not when a newer re-ask has taken its place meanwhile — the tapped message is not the question that waits any more,
+     * so it is closed as unanswered instead of keeping buttons that would answer the wrong question. Resolves whether it went back.
+     */
+    async function returnReAskedQuestionAfterTap(key, reAsked, messageId) {
+        if (putBackReAskedQuestion(key, reAsked)) {
+            // The answer did not happen: the message is an open question again, not one that carries a result.
+            forgetEndedMessage(key, messageId);
+            return true;
+        }
+        if (messageId !== null)
+            await closeReAskedMessage(key, messageId, reAsked.question, 'unanswered');
+        return false;
     }
     /**
      * @description F1: arm a "compact when the current turn finishes" request from
@@ -620,7 +1049,7 @@ function createCompaction(ports) {
      * compact). The drain (below) runs the plain compaction once the session idles.
      */
     function armDeferredCompaction(key) {
-        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+        const adapter = getThreadAdapter(key);
         if (!adapter.checkIsActive(key)) {
             return { ok: false, message: 'No active agent session in this topic — nothing to compact.' };
         }
@@ -648,7 +1077,7 @@ function createCompaction(ports) {
         const kStr = (0, sessionKey_1.keyToString)(key);
         if (!deferredCompactionArmed.has(kStr))
             return;
-        const adapter = (0, createAdapter_1.getThreadAdapter)(key);
+        const adapter = getThreadAdapter(key);
         if (!adapter.checkIsActive(key)) {
             deferredCompactionArmed.delete(kStr);
             return;
@@ -716,17 +1145,10 @@ function createCompaction(ports) {
         await ctx.answerCbQuery();
         await withThreadLocale(key, () => apply(key, isGeneral));
         // Re-render the picker keyboard so the ✓ follows the new state.
-        const cbMsg = ctx.callbackQuery?.message;
-        if (cbMsg) {
+        const pickerMessageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+        if (pickerMessageId !== null) {
             const keyboard = withThreadLocale(key, () => buildCompactOnIdleKeyboard(getCompactOnIdlePickerState(key, isGeneral)));
-            try {
-                await (0, rateLimiter_1.enqueueSend)(key, () => bot.telegram.editMessageReplyMarkup((0, sessionKeyCodec_1.getTelegramChatId)(key), cbMsg.message_id, undefined, keyboard.reply_markup));
-            }
-            catch (e) {
-                const desc = (0, sendErrorClassifier_1.checkIsApiError)(e) ? (0, sendErrorClassifier_1.getErrorDescription)(e) : '';
-                if (!/message is not modified/i.test(desc))
-                    console.warn('[coi_cb] keyboard re-render failed:', desc || e);
-            }
+            await editThreadKeyboard(key, pickerMessageId, keyboard.reply_markup, 'coi_cb');
         }
     }
     /**
@@ -771,18 +1193,9 @@ function createCompaction(ports) {
         await withThreadLocale(key, async () => {
             await replyToThread(key, await applyCompactSummary(key, isGeneral, enabled));
         });
-        const cbMsg = ctx.callbackQuery?.message;
-        if (cbMsg) {
-            const keyboard = buildCompactSummaryKeyboard(enabled);
-            try {
-                await (0, rateLimiter_1.enqueueSend)(key, () => bot.telegram.editMessageReplyMarkup((0, sessionKeyCodec_1.getTelegramChatId)(key), cbMsg.message_id, undefined, keyboard.reply_markup));
-            }
-            catch (e) {
-                const desc = (0, sendErrorClassifier_1.checkIsApiError)(e) ? (0, sendErrorClassifier_1.getErrorDescription)(e) : '';
-                if (!/message is not modified/i.test(desc))
-                    console.warn('[csum_cb] keyboard re-render failed:', desc || e);
-            }
-        }
+        const pickerMessageId = (0, callbackMessage_1.getCallbackMessageId)(ctx);
+        if (pickerMessageId !== null)
+            await editThreadKeyboard(key, pickerMessageId, buildCompactSummaryKeyboard(enabled).reply_markup, 'csum_cb');
     }
     function registerCompactionCommands() {
         // `/compact` — shrink the agent's context. BOT-OWNED, because "forward the text
@@ -798,7 +1211,7 @@ function createCompaction(ports) {
             // first: a terminal topic with no live shell would otherwise be told to start an
             // agent instead of that the backend cannot be compacted.
             if (route === 'notSupported') {
-                await replyToThread(key, (0, i18n_1.t)('compact.unsupported_backend', { label: (0, createAdapter_1.getThreadAdapter)(key).label }));
+                await replyToThread(key, (0, i18n_1.t)('compact.unsupported_backend', { label: getThreadAdapter(key).label }));
                 return;
             }
             // A sleeping conversation is woken first (L-D4): the compaction runs on its own context.
@@ -823,7 +1236,7 @@ function createCompaction(ports) {
             const arg = parsed.args.join(' ').toLowerCase();
             const isGeneral = checkIsGeneral(key);
             if (!isGeneral) {
-                if (!(0, createAdapter_1.getThreadAdapter)(key).checkIsActive(key) || getThreadCompactRoute(key) === 'notSupported') {
+                if (!getThreadAdapter(key).checkIsActive(key) || getThreadCompactRoute(key) === 'notSupported') {
                     await replyToThread(key, (0, i18n_1.t)('compactOnIdle.unsupported'));
                     return;
                 }
@@ -880,6 +1293,7 @@ function createCompaction(ports) {
         }));
         bot.action('csum_on', (ctx) => handleCompactSummaryCallback(ctx, true));
         bot.action('csum_off', (ctx) => handleCompactSummaryCallback(ctx, false));
+        bot.action(/^reask_(\d+)$/, (ctx) => handleReAskedQuestionTap(ctx, parseInt(ctx.match[1], 10)));
     }
     return {
         checkIsThreadCompacting,
@@ -891,7 +1305,11 @@ function createCompaction(ports) {
         armDeferredCompaction,
         checkIsDeferredCompactionArmed,
         threadsCompacting,
-        reAskedQuestionOptions,
+        answerReAskedQuestionByNumber,
+        reAskInterruptedQuestion,
+        restoreReAskedQuestion,
+        closeSavedReAskedQuestion,
+        closeReAskedQuestion,
         registerCompactionCommands,
         registerCompactionCallbacks,
     };