@otto-assistant/bridge 0.4.92

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

@@ -0,0 +1,261 @@
+// E2e test for question tool: user text message during pending question should
+// dismiss the question (abort), then enqueue as a normal user prompt.
+// The user's message must appear as a real user message in the thread, not
+// get consumed as a tool result answer (which lost voice/image content).
+import { describe, test, expect, afterEach } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage } from './test-utils.js';
+import { store } from './store.js';
+import { getOpencodeClient } from './opencode.js';
+import { getThreadSession } from './database.js';
+const TEXT_CHANNEL_ID = '200000000000001007';
+const VOICE_CHANNEL_ID = '200000000000001017';
+function setDeterministicTranscription(config) {
+    store.setState({
+        test: { deterministicTranscription: config },
+    });
+}
+function getOpencodeClientForTest(projectDirectory) {
+    const client = getOpencodeClient(projectDirectory);
+    if (!client) {
+        throw new Error('OpenCode client not found for project directory');
+    }
+    return client;
+}
+function getTextFromParts(parts) {
+    return parts.flatMap((part) => {
+        if (part.type === 'text') {
+            return [part.text];
+        }
+        return [];
+    });
+}
+function normalizeSessionText(text) {
+    return text
+        .replace(/\[current git branch is [^\]]+\]/g, '')
+        .replace(/<discord-user[^>]*\/>/g, '<discord-user />')
+        .trim();
+}
+function getSessionRoleTextTimeline(messages) {
+    return messages.flatMap((message) => {
+        const text = normalizeSessionText(getTextFromParts(message.parts).join(''));
+        if (!text.trim()) {
+            return [];
+        }
+        return [{ role: message.info.role, text }];
+    });
+}
+function getSessionMessageSummary(messages) {
+    return messages.map((message) => {
+        return {
+            role: message.info.role,
+            parts: message.parts.map((part) => {
+                if (part.type === 'text') {
+                    return {
+                        type: part.type,
+                        text: normalizeSessionText(part.text),
+                    };
+                }
+                if (part.type === 'tool') {
+                    return {
+                        type: part.type,
+                        tool: part.tool,
+                        status: part.state.status,
+                        title: part.state.status === 'completed' ? part.state.title : undefined,
+                        output: part.state.status === 'completed' ? part.state.output : undefined,
+                    };
+                }
+                return { type: part.type };
+            }),
+        };
+    });
+}
+async function waitForSessionMessages({ projectDirectory, sessionId, timeoutMs, predicate, }) {
+    const client = getOpencodeClientForTest(projectDirectory);
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const response = await client.session.messages({
+            sessionID: sessionId,
+            directory: projectDirectory,
+        });
+        const messages = response.data ?? [];
+        if (predicate(messages)) {
+            return messages;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+        });
+    }
+    const finalResponse = await client.session.messages({
+        sessionID: sessionId,
+        directory: projectDirectory,
+    });
+    return finalResponse.data ?? [];
+}
+describe('queue advanced: question tool answer', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-e2e',
+        dirName: 'qa-question-e2e',
+        username: 'queue-question-tester',
+    });
+    afterEach(() => {
+        setDeterministicTranscription(null);
+    });
+    test('user text message dismisses pending question and enqueues as normal prompt', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'QUESTION_TEXT_ANSWER_MARKER',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === 'QUESTION_TEXT_ANSWER_MARKER';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        // Wait for the question dropdown message to appear in Discord.
+        // This is the user-visible signal that the question tool fired and
+        // kimaki processed the event. Avoids polling internal Maps which
+        // have timing sensitivity on slower CI hardware.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'Which option do you prefer?',
+            timeout: 12_000,
+        });
+        // User sends a text message while question is pending.
+        // This should:
+        // 1. Dismiss the pending question (cleanup context)
+        // 2. Abort the blocked session so OpenCode unblocks
+        // 3. Enqueue the message as a normal user prompt (not consumed as answer)
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'my text answer',
+        });
+        // Give time for question cleanup to propagate
+        await new Promise((r) => {
+            setTimeout(r, 1_000);
+        });
+        const timeline = await th.text({ showInteractions: true });
+        // The user's text answer must appear in Discord
+        expect(timeline).toContain('my text answer');
+        // The original question must have appeared
+        expect(timeline).toContain('Which option do you prefer?');
+        // The user's marker message triggered the question
+        expect(timeline).toContain('QUESTION_TEXT_ANSWER_MARKER');
+    }, 20_000);
+});
+describe('queue advanced: voice message during pending question', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: VOICE_CHANNEL_ID,
+        channelName: 'qa-question-voice-e2e',
+        dirName: 'qa-question-voice-e2e',
+        username: 'queue-question-tester',
+    });
+    afterEach(() => {
+        setDeterministicTranscription(null);
+    });
+    test('voice message during pending question dismisses question and transcribes normally', async () => {
+        // This is the exact bug scenario: user sends a voice message while a
+        // question dropdown is pending. Voice messages have empty message.content
+        // (audio is in attachments, transcription happens later). The old code
+        // passed "" as the question answer and consumed the message — the voice
+        // content was completely lost.
+        await ctx.discord.channel(VOICE_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'QUESTION_TEXT_ANSWER_MARKER',
+        });
+        const thread = await ctx.discord.channel(VOICE_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === 'QUESTION_TEXT_ANSWER_MARKER';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        // Wait for the question dropdown message to appear in Discord
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'Which option do you prefer?',
+            timeout: 12_000,
+        });
+        // Send a voice message while the question is pending.
+        // Reproduction: Discord voice messages can still carry non-empty
+        // message.content. The bug consumed that raw text before transcription,
+        // so the session never received the spoken content.
+        setDeterministicTranscription({
+            transcription: 'I want option Alpha please',
+            queueMessage: false,
+        });
+        await th.user(TEST_USER_ID).sendVoiceMessage({
+            content: 'VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL',
+        });
+        // Give time for question cleanup to propagate
+        await new Promise((r) => {
+            setTimeout(r, 1_000);
+        });
+        // Voice content should be transcribed and appear as the next user message,
+        // processed after the model responds to the empty question answer.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'I want option Alpha please',
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: 'I want option Alpha please',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const sessionId = await getThreadSession(thread.id);
+        expect(sessionId).toBeTruthy();
+        const sessionMessages = await waitForSessionMessages({
+            projectDirectory: ctx.directories.projectDirectory,
+            sessionId: sessionId,
+            timeoutMs: 8_000,
+            predicate: (messages) => {
+                const timeline = getSessionRoleTextTimeline(messages);
+                return timeline.some((entry) => {
+                    return entry.text.includes('I want option Alpha please');
+                });
+            },
+        });
+        const sessionTimeline = getSessionRoleTextTimeline(sessionMessages);
+        const sessionSummary = getSessionMessageSummary(sessionMessages);
+        const latestUserText = sessionTimeline
+            .filter((entry) => {
+            return entry.role === 'user';
+        })
+            .at(-1)?.text;
+        const assistantTexts = sessionTimeline.flatMap((entry) => {
+            if (entry.role === 'assistant') {
+                return [entry.text];
+            }
+            return [];
+        });
+        expect(latestUserText).toContain('I want option Alpha please');
+        expect(latestUserText).not.toContain('VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL');
+        expect(assistantTexts).toContain('ok');
+        expect(sessionSummary.some((message) => {
+            return message.role === 'user'
+                && message.parts.some((part) => {
+                    return part.type === 'text' && part.text.includes('I want option Alpha please');
+                });
+        })).toBe(true);
+        expect(sessionSummary.some((message) => {
+            return message.role === 'assistant'
+                && message.parts.some((part) => {
+                    return part.type === 'text' && part.text === 'ok';
+                });
+        })).toBe(true);
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toContain('QUESTION_TEXT_ANSWER_MARKER');
+        expect(timeline).toContain('Which option do you prefer?');
+        expect(timeline).toContain('VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL');
+        expect(timeline).toContain('🎤 Transcribing voice message...');
+        expect(timeline).toContain('📝 **Transcribed message:** I want option Alpha please');
+        expect(timeline).toContain('⬥ ok');
+        // Voice content must be present as a real transcribed message, not lost
+        expect(timeline).toContain('I want option Alpha please');
+    }, 20_000);
+});

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

@@ -0,0 +1,114 @@
+// E2e test for typing indicator lifecycle during interruption flow.
+// 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';
+const TEXT_CHANNEL_ID = '200000000000001008';
+const e2eTest = describe;
+e2eTest('queue advanced: typing interrupt', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-typing-interrupt-e2e',
+        dirName: 'qa-typing-interrupt-e2e',
+        username: 'queue-advanced-tester',
+    });
+    test('interruption flow emits footer for final assistant reply and then stops typing', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: typing-stop-interrupt-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: typing-stop-interrupt-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '*project',
+            timeout: 4_000,
+        });
+        th.clearTypingEvents();
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'starting sleep 100',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: typing-stop-interrupt-final',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            afterUserMessageIncludes: 'typing-stop-interrupt-final',
+            timeout: 12_000,
+        });
+        const messages = await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 12_000,
+            afterMessageIncludes: 'typing-stop-interrupt-final',
+            afterAuthorId: TEST_USER_ID,
+        });
+        const finalUserIndex = messages.findIndex((message) => {
+            return message.author.id === TEST_USER_ID
+                && message.content.includes('typing-stop-interrupt-final');
+        });
+        const finalReplyIndex = messages.findIndex((message, index) => {
+            if (index <= finalUserIndex) {
+                return false;
+            }
+            return message.author.id === ctx.discord.botUserId && message.content.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('⋅');
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: typing-stop-interrupt-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (queue-advanced-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER
+        --- from: assistant (TestBot)
+        ⬥ 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*"
+      `);
+        const timeline = await th.text({ showTyping: true });
+        expect(finalUserIndex).toBeGreaterThanOrEqual(0);
+        expect(finalReplyIndex).toBeGreaterThan(finalUserIndex);
+        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 lastFooterPosition = timeline.lastIndexOf('*project ⋅');
+        expect(finalPromptPosition).toBeGreaterThanOrEqual(0);
+        expect(finalReplyPosition).toBeGreaterThan(finalPromptPosition);
+        expect(lastFooterPosition).toBeGreaterThanOrEqual(0);
+        const typingDuringFinalRun = timeline
+            .slice(finalPromptPosition, finalReplyPosition)
+            .match(/\[bot typing\]/g) || [];
+        expect(typingDuringFinalRun.length).toBeGreaterThanOrEqual(2);
+        expect(timeline.slice(lastFooterPosition)).not.toContain('[bot typing]');
+    }, 12_000);
+});

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

@@ -0,0 +1,153 @@
+// E2e tests for typing indicator lifecycle in advanced queue scenarios.
+// 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';
+const TEXT_CHANNEL_ID = '200000000000001002';
+const e2eTest = describe;
+e2eTest('queue advanced: typing lifecycle', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-typing-e2e',
+        dirName: 'qa-typing-e2e',
+        username: 'queue-advanced-tester',
+    });
+    test('normal reply stops typing after footer', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: typing-stop-normal',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: typing-stop-normal';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForTypingEvent({ timeout: 1_000 }).catch(() => {
+            return undefined;
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            timeout: 4_000,
+        });
+        const messages = await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const replyIndex = messages.findIndex((message) => {
+            return message.author.id === ctx.discord.botUserId && message.content.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('⋅');
+        });
+        const timeline = await th.text({ showTyping: true });
+        expect(timeline).toContain('Reply with exactly: typing-stop-normal');
+        expect(timeline).toContain('⬥ ok');
+        expect(timeline).toContain('*project ⋅ main ⋅');
+        const typingCount = (timeline.match(/\[bot typing\]/g) || []).length;
+        expect(typingCount).toBeGreaterThanOrEqual(1);
+        expect(replyIndex).toBeGreaterThanOrEqual(0);
+        expect(footerIndex).toBeGreaterThan(replyIndex);
+        expect(messages[footerIndex]).toBeDefined();
+        const lastFooterPosition = timeline.lastIndexOf('*project ⋅');
+        expect(lastFooterPosition).toBeGreaterThanOrEqual(0);
+        expect(timeline.slice(lastFooterPosition)).not.toContain('[bot typing]');
+    }, 8_000);
+    test('thread follow-up reply re-pulses typing after a visible assistant message while session stays busy', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: typing-thread-reply-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: typing-thread-reply-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            timeout: 4_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        th.clearTypingEvents();
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'TYPING_REPULSE_MARKER',
+        });
+        const messagesAfterFirstReply = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'repulse-first',
+            afterUserMessageIncludes: 'TYPING_REPULSE_MARKER',
+            timeout: 4_000,
+        });
+        const markerUserIndex = messagesAfterFirstReply.findIndex((message) => {
+            return message.author.id === TEST_USER_ID
+                && message.content.includes('TYPING_REPULSE_MARKER');
+        });
+        const firstReply = messagesAfterFirstReply.find((message, index) => {
+            if (index <= markerUserIndex) {
+                return false;
+            }
+            return message.author.id === ctx.discord.botUserId
+                && message.content.includes('repulse-first');
+        });
+        if (!firstReply) {
+            throw new Error('Expected first bot reply after TYPING_REPULSE_MARKER');
+        }
+        const typingAfterVisibleReply = await th.waitForTypingEvent({
+            timeout: 700,
+            afterTimestamp: new Date(firstReply.timestamp).getTime(),
+        }).then(() => {
+            return true;
+        }, () => {
+            return false;
+        });
+        const messages = await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 6_000,
+            afterMessageIncludes: 'TYPING_REPULSE_MARKER',
+            afterAuthorId: TEST_USER_ID,
+        });
+        const timeline = await th.text({ showTyping: true });
+        expect(timeline).toContain('TYPING_REPULSE_MARKER');
+        expect(timeline).toContain('⬥ repulse-first');
+        const typingCount = (timeline.match(/\[bot typing\]/g) || []).length;
+        expect(typingCount).toBeGreaterThanOrEqual(2);
+        const followupUserIndex = messages.findIndex((message) => {
+            return message.author.id === TEST_USER_ID
+                && message.content.includes('TYPING_REPULSE_MARKER');
+        });
+        const followupReplyIndex = messages.findIndex((message, index) => {
+            if (index <= followupUserIndex) {
+                return false;
+            }
+            return message.author.id === ctx.discord.botUserId
+                && message.content.includes('repulse-first');
+        });
+        expect(followupUserIndex).toBeGreaterThanOrEqual(0);
+        expect(followupReplyIndex).toBeGreaterThan(followupUserIndex);
+        expect(typingAfterVisibleReply).toBe(true);
+    }, 10_000);
+});

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

@@ -0,0 +1,119 @@
+// E2e test: queued messages must drain immediately when the session is idle,
+// even if action buttons are still pending. The isSessionBusy check is
+// sufficient — hasPendingInteractiveUi() should NOT block queue drain.
+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 { getThreadSession } from './database.js';
+import { pendingActionButtonContexts, showActionButtons, } from './commands/action-buttons.js';
+const TEXT_CHANNEL_ID = '200000000000001020';
+describe('queue drain with pending interactive UI', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-drain-interactive-ui',
+        dirName: 'qa-drain-interactive-ui',
+        username: 'drain-ui-tester',
+    });
+    test('queued message drains immediately while action buttons are still pending', async () => {
+        // 1. Create a thread with a first completed reply
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: drain-button-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: drain-button-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            timeout: 4_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        // 2. Show action buttons (session is idle, buttons are pending)
+        const currentSessionId = await getThreadSession(thread.id);
+        if (!currentSessionId) {
+            throw new Error('Expected thread session id');
+        }
+        const channel = await ctx.botClient.channels.fetch(thread.id);
+        if (!channel || !channel.isThread()) {
+            throw new Error('Expected Discord thread channel');
+        }
+        await showActionButtons({
+            thread: channel,
+            sessionId: currentSessionId,
+            directory: ctx.directories.projectDirectory,
+            buttons: [{ label: 'Pending button', color: 'white' }],
+        });
+        // Verify buttons are pending
+        const start = Date.now();
+        while (Date.now() - start < 4_000) {
+            const entry = [...pendingActionButtonContexts.entries()].find(([, context]) => {
+                return context.thread.id === thread.id && Boolean(context.messageId);
+            });
+            if (entry) {
+                break;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 100);
+            });
+        }
+        expect([...pendingActionButtonContexts.values()].some((c) => {
+            return c.thread.id === thread.id;
+        })).toBe(true);
+        // 3. Queue a message via /queue while buttons are still pending.
+        //    The queue should drain immediately because session is idle.
+        //    Currently FAILS: hasPendingInteractiveUi() blocks tryDrainQueue().
+        const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-button-drain' }],
+        });
+        const queueAck = await th.waitForInteractionAck({
+            interactionId: queueInteractionId,
+            timeout: 4_000,
+        });
+        if (!queueAck.messageId) {
+            throw new Error('Expected /queue response message id');
+        }
+        // 4. Queued message should dispatch immediately (not stay "Queued").
+        //    The dispatch indicator should appear quickly.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: '» **drain-ui-tester:** Reply with exactly: post-button-drain',
+            timeout: 4_000,
+        });
+        // 5. Wait for the footer after the drained message completes
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: '» **drain-ui-tester:**',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (drain-ui-tester)
+        Reply with exactly: drain-button-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        [user interaction]
+        » **drain-ui-tester:** Reply with exactly: post-button-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+    }, 20_000);
+});