kimaki 0.26.0 → 0.28.0

package/dist/queue-advanced-typing-interrupt.e2e.test.js

@@ -2,7 +2,7 @@
 // Split from queue-advanced-typing.e2e.test.ts for parallelization.
 import { describe, test, expect } from 'vitest';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
-import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { getMessageVisibleText, isFooterMessage, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 const TEXT_CHANNEL_ID = '200000000000001008';
 const e2eTest = describe;
 e2eTest('queue advanced: typing interrupt', () => {
@@ -68,32 +68,30 @@ e2eTest('queue advanced: typing interrupt', () => {
             if (index <= finalUserIndex) {
                 return false;
             }
-            return message.author.id === ctx.discord.botUserId && message.content.includes('ok');
+            return message.author.id === ctx.discord.botUserId && getMessageVisibleText(message).includes('ok');
         });
         const finalFooterIndex = messages.findIndex((message, index) => {
             if (index <= finalReplyIndex) {
                 return false;
             }
-            return message.author.id === ctx.discord.botUserId
-                && message.content.startsWith('*')
-                && message.content.includes('⋅');
+            return isFooterMessage({ message, botUserId: ctx.discord.botUserId });
         });
         expect(await th.text()).toMatchInlineSnapshot(`
         "--- from: user (queue-advanced-tester)
         Reply with exactly: typing-stop-interrupt-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        ⬥ starting sleep 100
+        > starting sleep 100
         --- from: user (queue-advanced-tester)
         Reply with exactly: typing-stop-interrupt-final
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         const timeline = await th.text({ showTyping: true });
         expect(finalUserIndex).toBeGreaterThanOrEqual(0);
@@ -101,7 +99,7 @@ e2eTest('queue advanced: typing interrupt', () => {
         expect(finalFooterIndex).toBeGreaterThan(finalReplyIndex);
         expect(messages[finalFooterIndex]).toBeDefined();
         const finalPromptPosition = timeline.indexOf('Reply with exactly: typing-stop-interrupt-final');
-        const finalReplyPosition = timeline.indexOf('--- from: assistant (TestBot)\n⬥ ok', finalPromptPosition);
+        const finalReplyPosition = timeline.indexOf('--- from: assistant (TestBot)\n> ok', finalPromptPosition);
         const lastFooterPosition = timeline.lastIndexOf('*project ⋅');
         expect(finalPromptPosition).toBeGreaterThanOrEqual(0);
         expect(finalReplyPosition).toBeGreaterThan(finalPromptPosition);

package/dist/queue-advanced-typing.e2e.test.js

@@ -2,7 +2,7 @@
 // Split from thread-queue-advanced.e2e.test.ts for parallelization.
 import { describe, test, expect } from 'vitest';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
-import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { getMessageVisibleText, isFooterMessage, waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
 const TEXT_CHANNEL_ID = '200000000000001002';
 const e2eTest = describe;
 e2eTest('queue advanced: typing lifecycle', () => {
@@ -41,19 +41,17 @@ e2eTest('queue advanced: typing lifecycle', () => {
             afterAuthorId: ctx.discord.botUserId,
         });
         const replyIndex = messages.findIndex((message) => {
-            return message.author.id === ctx.discord.botUserId && message.content.includes('ok');
+            return message.author.id === ctx.discord.botUserId && getMessageVisibleText(message).includes('ok');
         });
         const footerIndex = messages.findIndex((message, index) => {
             if (index <= replyIndex) {
                 return false;
             }
-            return message.author.id === ctx.discord.botUserId
-                && message.content.startsWith('*')
-                && message.content.includes('⋅');
+            return isFooterMessage({ message, botUserId: ctx.discord.botUserId });
         });
         const timeline = await th.text({ showTyping: true });
         expect(timeline).toContain('Reply with exactly: typing-stop-normal');
-        expect(timeline).toContain('⬥ ok');
+        expect(timeline).toContain('ok');
         expect(timeline).toContain('*project ⋅ main ⋅');
         const typingCount = (timeline.match(/\[bot typing\]/g) || []).length;
         expect(typingCount).toBeGreaterThanOrEqual(1);
@@ -110,7 +108,7 @@ e2eTest('queue advanced: typing lifecycle', () => {
                 return false;
             }
             return message.author.id === ctx.discord.botUserId
-                && message.content.includes('repulse-first');
+                && getMessageVisibleText(message).includes('repulse-first');
         });
         if (!firstReply) {
             throw new Error('Expected first bot reply after TYPING_REPULSE_MARKER');
@@ -132,7 +130,7 @@ e2eTest('queue advanced: typing lifecycle', () => {
         });
         const timeline = await th.text({ showTyping: true });
         expect(timeline).toContain('TYPING_REPULSE_MARKER');
-        expect(timeline).toContain('⬥ repulse-first');
+        expect(timeline).toContain('repulse-first');
         const typingCount = (timeline.match(/\[bot typing\]/g) || []).length;
         expect(typingCount).toBeGreaterThanOrEqual(2);
         const followupUserIndex = messages.findIndex((message) => {
@@ -144,7 +142,7 @@ e2eTest('queue advanced: typing lifecycle', () => {
                 return false;
             }
             return message.author.id === ctx.discord.botUserId
-                && message.content.includes('repulse-first');
+                && getMessageVisibleText(message).includes('repulse-first');
         });
         expect(followupUserIndex).toBeGreaterThanOrEqual(0);
         expect(followupReplyIndex).toBeGreaterThan(followupUserIndex);

package/dist/queue-delete-message.e2e.test.js

@@ -63,11 +63,11 @@ e2eTest('queue delete message', () => {
         "--- from: user (queue-delete-tester)
         SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         Queued at position 1. Edit or delete your message to update the queue
         ⬦ **queue-delete-tester** removed message from queue
-        ⬥ slow-busy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > slow-busy-reply
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         const finalText = await th.text();
         expect(finalText).not.toContain('» **queue-delete-tester:** Reply with exactly: deleted-queue');

package/dist/queue-drain-after-interactive-ui.e2e.test.js

@@ -107,14 +107,14 @@ describe('queue drain with pending interactive UI', () => {
         "--- from: user (drain-ui-tester)
         Reply with exactly: drain-button-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         **Action Required**
         [user interaction]
         » **drain-ui-tester:** Reply with exactly: post-button-drain
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
     }, 20_000);
 });

package/dist/queue-interrupt-drain.e2e.test.js

@@ -7,7 +7,7 @@
 //   2. User queues a message via /queue (enters kimaki local queue)
 //   3. User sends a normal message (interrupt)
 //   4. Session aborts the slow task, processes the interrupt message immediately
-//   5. Interrupt response appears in Discord with a ⬥ ok reply
+//   5. Interrupt response appears in Discord with a ok reply
 //   6. When interrupt response completes, the queued message drains and runs
 //
 // Uses opencode-deterministic-provider (no real LLM calls).
@@ -15,6 +15,9 @@
 import { describe, test, expect } from 'vitest';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
 import { waitForFooterMessage, waitForBotMessageContaining, waitForMessageById, } from './test-utils.js';
+import { getThreadSession } from './database.js';
+import { archiveThread } from './discord-utils.js';
+import { getOpencodeClient } from './opencode.js';
 const TEXT_CHANNEL_ID = '200000000000001099';
 const e2eTest = describe;
 e2eTest('queue + interrupt drain ordering', () => {
@@ -24,6 +27,113 @@ e2eTest('queue + interrupt drain ordering', () => {
         dirName: 'qa-interrupt-drain-e2e',
         username: 'interrupt-tester',
     });
+    test('archiving keeps the active run alive so queued messages drain', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: setup-archive-drain',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (candidate) => {
+                return candidate.name === 'Reply with exactly: setup-archive-drain';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'PLUGIN_TIMEOUT_SLEEP_MARKER archive queue drain',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'starting sleep',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER archive queue drain',
+            timeout: 4_000,
+        });
+        const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{
+                    name: 'message',
+                    type: 3,
+                    value: 'Reply with exactly: archived-queue-survives',
+                }],
+        });
+        const queueAck = await th.waitForInteractionAck({
+            interactionId: queueInteractionId,
+            timeout: 4_000,
+        });
+        if (!queueAck.messageId) {
+            throw new Error('Expected /queue response message id');
+        }
+        const queueStatusMessage = await waitForMessageById({
+            discord: ctx.discord,
+            threadId: thread.id,
+            messageId: queueAck.messageId,
+            timeout: 4_000,
+        });
+        expect(queueStatusMessage.content).toContain('Queued message');
+        const sessionId = await getThreadSession(thread.id);
+        if (!sessionId)
+            throw new Error('Expected mapped OpenCode session');
+        const client = getOpencodeClient(ctx.directories.projectDirectory);
+        if (!client)
+            throw new Error('Expected initialized OpenCode client');
+        await archiveThread({
+            rest: ctx.botClient.rest,
+            threadId: thread.id,
+            parentChannelId: TEXT_CHANNEL_ID,
+            sessionId,
+            client,
+        });
+        const statusResponse = await client.session.status({
+            directory: ctx.directories.projectDirectory,
+        });
+        expect(statusResponse.data?.[sessionId]?.type).toBe('busy');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: continue-after-archive',
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 12_000,
+            afterMessageIncludes: 'continue-after-archive',
+            afterAuthorId: TEST_USER_ID,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 12_000,
+            afterMessageIncludes: 'archived-queue-survives',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (interrupt-tester)
+        Reply with exactly: setup-archive-drain
+        --- from: assistant (TestBot)
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
+        --- from: user (interrupt-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER archive queue drain
+        --- from: assistant (TestBot)
+        > starting sleep 100
+        Queued message (position 1)
+        --- from: user (interrupt-tester)
+        Reply with exactly: continue-after-archive
+        --- from: assistant (TestBot)
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
+        » **interrupt-tester:** Reply with exactly: archived-queue-survives
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+      `);
+    }, 20_000);
     test('queued message via /queue + normal interrupt: interrupt reply should appear, then queue drains', async () => {
         // 1. Establish session with a quick first message
         await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
@@ -84,7 +194,7 @@ e2eTest('queue + interrupt drain ordering', () => {
             content: 'Reply with exactly: interrupt-now',
         });
         // 5. Wait for the final state: the interrupt message should get its own
-        //    ⬥ ok reply, then the queued message should drain and get processed.
+        //    ok reply, then the queued message should drain and get processed.
         //    We wait for the queued message's footer as the final signal.
         await waitForFooterMessage({
             discord: ctx.discord,
@@ -98,24 +208,24 @@ e2eTest('queue + interrupt drain ordering', () => {
         "--- from: user (interrupt-tester)
         Reply with exactly: setup-interrupt-drain
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (interrupt-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        ⬥ starting sleep 100
+        > starting sleep 100
         Queued message (position 1)
         --- from: user (interrupt-tester)
         Reply with exactly: interrupt-now
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
         » **interrupt-tester:** Reply with exactly: queued-behind-slow
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
-        // 7. Assert the interrupt message got its own ⬥ ok reply between the
+        // 7. Assert the interrupt message got its own ok reply between the
         //    user's interrupt message and the queue dispatch indicator.
         const text = await th.text();
         const lines = text.split('\n');
@@ -129,7 +239,7 @@ e2eTest('queue + interrupt drain ordering', () => {
         expect(queueDispatchLine).toBeGreaterThan(-1);
         const linesBetween = lines.slice(interruptUserLine + 1, queueDispatchLine);
         const hasInterruptReply = linesBetween.some((line) => {
-            return line.includes('⬥ ok');
+            return line.includes('ok');
         });
         expect(hasInterruptReply).toBe(true);
     }, 20_000);

package/dist/queue-question-select-drain.e2e.test.js

@@ -1,7 +1,4 @@
-// E2e test: queued message must drain after the user answers a pending question
-// via the Discord dropdown select menu. Reproduces a bug where answering via
-// select (not text) leaves queued messages stuck because the session continues
-// processing after the answer and may enter another blocking state.
+// E2e test for ordered queue drain after a pending question is answered via select.
 import { describe, test, expect } from 'vitest';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
 import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
@@ -27,8 +24,7 @@ async function expectNoBotMessageContaining({ discord, threadId, text, timeout,
     while (Date.now() - start < timeout) {
         const messages = await discord.thread(threadId).getMessages();
         const match = messages.find((message) => {
-            return (message.author.id === discord.botUserId
-                && message.content.includes(text));
+            return message.author.id === discord.botUserId && message.content.includes(text);
         });
         if (match) {
             throw new Error(`Unexpected bot message containing ${JSON.stringify(text)} while it should still be queued`);
@@ -45,110 +41,15 @@ describe('queue drain after question select answer', () => {
         dirName: 'qa-question-select-drain',
         username: 'question-select-tester',
     });
-    test('queued message drains after answering question via dropdown select', async () => {
-        // 1. Send a message that triggers the question tool
-        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'QUESTION_SELECT_QUEUE_MARKER',
-        });
-        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 8_000,
-            predicate: (t) => {
-                return t.name === 'QUESTION_SELECT_QUEUE_MARKER';
-            },
-        });
-        const th = ctx.discord.thread(thread.id);
-        // 2. Wait for the question dropdown message to appear in Discord.
-        // Uses visible message wait instead of internal Map polling which
-        // is too timing-sensitive on CI.
-        const questionMessages = await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            text: 'How to proceed?',
-            timeout: 12_000,
-        });
-        // Get the pending question context hash from the internal map.
-        // By this point the question message is visible so the context must exist.
-        const pending = await waitForPendingQuestion({
-            threadId: thread.id,
-            timeoutMs: 8_000,
-        });
-        const questionMsg = questionMessages.find((m) => {
-            return m.content.includes('How to proceed?');
-        });
-        expect(questionMsg).toBeTruthy();
-        // 3. Queue a message while question is pending
-        const { id: queueInteractionId } = await th.user(TEST_USER_ID)
-            .runSlashCommand({
-            name: 'queue',
-            options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-question-drain' }],
-        });
-        const queueAck = await th.waitForInteractionAck({
-            interactionId: queueInteractionId,
-            timeout: 8_000,
-        });
-        if (!queueAck.messageId) {
-            throw new Error('Expected /queue response message id');
-        }
-        // 4. The first queued item should be handed off immediately even while
-        //    the question is still pending, so the visible dispatch indicator
-        //    appears before the user answers the dropdown.
-        await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            text: '» **question-select-tester:** Reply with exactly: post-question-drain',
-            timeout: 8_000,
-        });
-        // 5. Answer the question via dropdown select (pick first option "Alpha")
-        const interaction = await th.user(TEST_USER_ID).selectMenu({
-            messageId: questionMsg.id,
-            customId: `ask_question:${pending.contextHash}:0`,
-            values: ['0'],
-        });
-        await th.waitForInteractionAck({
-            interactionId: interaction.id,
-            timeout: 8_000,
-        });
-        // 6. Wait for footer from the drained queued message
-        await waitForFooterMessage({
-            discord: ctx.discord,
-            threadId: thread.id,
-            timeout: 8_000,
-            afterMessageIncludes: '» **question-select-tester:**',
-            afterAuthorId: ctx.discord.botUserId,
-        });
-        const timeline = await th.text({ showInteractions: true });
-        expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (question-select-tester)
-        QUESTION_SELECT_QUEUE_MARKER
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        **Select action**
-        How to proceed?
-        ✓ _Alpha_
-        [user interaction]
-        » **question-select-tester:** Reply with exactly: post-question-drain
-        Queued message (position 1)
-        [user selects dropdown: 0]
-        » **question-select-tester:** Alpha
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        expect(timeline).toContain('QUESTION_SELECT_QUEUE_MARKER');
-        expect(timeline).toContain('How to proceed?');
-        expect(timeline).toContain('[user selects dropdown: 0]');
-        expect(timeline).toContain('» **question-select-tester:** Reply with exactly: post-question-drain');
-        expect(timeline).toContain('⬥ ok');
-        expect(timeline).toContain('*project ⋅ main ⋅');
-    }, 20_000);
-    test('only the first queued message is handed off after dropdown answer', async () => {
-        const marker = 'QUESTION_SELECT_QUEUE_MARKER second-test';
+    test('queued messages drain in order after answering via dropdown select', async () => {
+        const marker = 'QUESTION_SELECT_QUEUE_MARKER';
         await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: marker,
         });
         const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 8_000,
-            predicate: (t) => {
-                return t.name === marker;
+            predicate: (candidate) => {
+                return candidate.name === marker;
             },
         });
         const th = ctx.discord.thread(thread.id);
@@ -162,14 +63,13 @@ describe('queue drain after question select answer', () => {
             threadId: thread.id,
             timeoutMs: 8_000,
         });
-        const questionMsg = questionMessages.find((message) => {
+        const questionMessage = questionMessages.find((message) => {
             return message.content.includes('How to proceed?');
         });
-        expect(questionMsg).toBeTruthy();
-        if (!questionMsg) {
+        if (!questionMessage) {
             throw new Error('Expected question message');
         }
-        const firstQueuedPrompt = 'SLOW_ABORT_MARKER run long response';
+        const firstQueuedPrompt = 'QUESTION_SELECT_DRAIN_FIRST_MARKER';
         const secondQueuedPrompt = 'Reply with exactly: post-question-second';
         const { id: firstQueueInteractionId } = await th.user(TEST_USER_ID)
             .runSlashCommand({
@@ -180,6 +80,12 @@ describe('queue drain after question select answer', () => {
             interactionId: firstQueueInteractionId,
             timeout: 8_000,
         });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: `» **question-select-tester:** ${firstQueuedPrompt}`,
+            timeout: 8_000,
+        });
         const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
             .runSlashCommand({
             name: 'queue',
@@ -189,8 +95,14 @@ describe('queue drain after question select answer', () => {
             interactionId: secondQueueInteractionId,
             timeout: 8_000,
         });
+        await expectNoBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+            timeout: 200,
+        });
         const interaction = await th.user(TEST_USER_ID).selectMenu({
-            messageId: questionMsg.id,
+            messageId: questionMessage.id,
             customId: `ask_question:${pending.contextHash}:0`,
             values: ['0'],
         });
@@ -198,18 +110,6 @@ describe('queue drain after question select answer', () => {
             interactionId: interaction.id,
             timeout: 8_000,
         });
-        await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            text: `» **question-select-tester:** ${firstQueuedPrompt}`,
-            timeout: 8_000,
-        });
-        await expectNoBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            text: `» **question-select-tester:** ${secondQueuedPrompt}`,
-            timeout: 200,
-        });
         await waitForFooterMessage({
             discord: ctx.discord,
             threadId: thread.id,
@@ -233,28 +133,30 @@ describe('queue drain after question select answer', () => {
         const timeline = await th.text({ showInteractions: true });
         expect(timeline).toMatchInlineSnapshot(`
         "--- from: user (question-select-tester)
-        QUESTION_SELECT_QUEUE_MARKER second-test
+        QUESTION_SELECT_QUEUE_MARKER
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         **Select action**
         How to proceed?
         ✓ _Alpha_
         [user interaction]
-        » **question-select-tester:** SLOW_ABORT_MARKER run long response
+        » **question-select-tester:** QUESTION_SELECT_DRAIN_FIRST_MARKER
         Queued message (position 1)
         [user interaction]
         Queued message (position 1)
         [user selects dropdown: 0]
         » **question-select-tester:** Alpha
-        ⬥ slow-response-started
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > question-drain-first
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
         » **question-select-tester:** Reply with exactly: post-question-second
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
+        expect(timeline).toContain('How to proceed?');
+        expect(timeline).toContain('[user selects dropdown: 0]');
         expect(timeline).toContain(`» **question-select-tester:** ${firstQueuedPrompt}`);
-        expect(timeline).toContain('⬥ slow-response-started');
+        expect(timeline).toContain('question-drain-first');
         expect(timeline).toContain(`» **question-select-tester:** ${secondQueuedPrompt}`);
-        expect(timeline).toContain('⬥ ok');
-    }, 20_000);
+        expect(timeline).toContain('ok');
+    }, 15_000);
 });