kimaki 0.26.0 → 0.28.0

package/dist/voice-message.e2e.test.js

@@ -17,7 +17,7 @@ import { buildDeterministicOpencodeConfig, } from 'opencode-deterministic-provid
 import { setDataDir } from './config.js';
 import { store } from './store.js';
 import { startDiscordBot } from './discord-bot.js';
-import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, } from './database.js';
+import { setBotToken, initDatabase, closeDatabase, setChannelDirectory, setChannelVerbosity, getThreadSession, createPendingWorkspace, setWorkspaceReady, getThreadWorktreeOrWorkspace, } from './database.js';
 import { startHranaServer, stopHranaServer } from './hrana-server.js';
 import { initializeOpencodeForDirectory, getOpencodeClient, stopOpencodeServer } from './opencode.js';
 import { chooseLockPort, cleanupTestSessions, initTestGitRepo, waitForFooterMessage, waitForBotMessageContaining, waitForThreadState, } from './test-utils.js';
@@ -332,6 +332,120 @@ e2eTest('voice message handling', () => {
         setDeterministicTranscription(null);
     });
     // ── Test 1: Voice message in a channel creates thread + session ──
+    // Vitest disallows inline snapshots in test.each; register separate tests instead.
+    for (const sessionAction of ['btw', 'new-session']) {
+        test(`voice ${sessionAction} routing creates a separate thread with the correct history`, async () => {
+            await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID)
+                .sendMessage({ content: `Source history for voice ${sessionAction}` });
+            const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+                timeout: 4_000,
+                predicate: (candidate) => Boolean(candidate.name?.includes(`Source history for voice ${sessionAction}`)),
+            });
+            await waitForFooterMessage({ discord, threadId: thread.id, timeout: 4_000 });
+            const sourceSessionId = await getThreadSession(thread.id);
+            await createPendingWorkspace({
+                threadId: thread.id,
+                workspaceType: 'worktree',
+                workspaceName: 'voice-workspace',
+                projectDirectory: directories.projectDirectory,
+            });
+            await setWorkspaceReady({
+                threadId: thread.id,
+                workspaceId: 'voice-workspace-id',
+                workspaceDirectory: directories.projectDirectory,
+            });
+            const prompt = `Explain voice routing ${sessionAction}`;
+            setDeterministicTranscription({ transcription: prompt, queueMessage: false, sessionAction });
+            await discord.thread(thread.id).user(TEST_USER_ID).sendVoiceMessage();
+            const confirmation = sessionAction === 'btw' ? 'Session forked!' : 'Created new session in';
+            const routingMessages = await waitForBotMessageContaining({
+                discord,
+                threadId: thread.id,
+                text: confirmation,
+                timeout: 4_000,
+            });
+            // OpenCode can rename the destination before discovery; follow its confirmed ID.
+            const targetId = routingMessages.find((message) => message.content.includes(confirmation))
+                ?.content.match(/<#(\d+)>/)?.[1];
+            if (!targetId)
+                throw new Error('Expected destination thread link');
+            const target = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+                timeout: 4_000,
+                predicate: (candidate) => candidate.id === targetId,
+            });
+            await waitForFooterMessage({ discord, threadId: target.id, timeout: 4_000 });
+            const th = discord.thread(target.id);
+            const transcript = {
+                source: (await discord.thread(thread.id).text()).replaceAll(target.id, 'TARGET_THREAD'),
+                target: (await th.text()).replaceAll(thread.id, 'SOURCE_THREAD'),
+            };
+            if (sessionAction === 'btw') {
+                expect(transcript).toMatchInlineSnapshot(`
+            {
+              "source": "--- from: user (voice-tester)
+            Source history for voice btw
+            --- from: assistant (TestBot)
+            > *using deterministic-provider/deterministic-v2*
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
+            --- from: user (voice-tester)
+            [attachment: voice-message.ogg]
+            --- from: assistant (TestBot)
+            🎤 Transcribing voice message...
+            📝 **Transcribed message:** Explain voice routing btw
+            Session forked! Continue in <#TARGET_THREAD>",
+              "target": "--- from: assistant (TestBot)
+            Reusing context from <#SOURCE_THREAD> to answer prompt...
+            Explain voice routing btw
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>",
+            }
+          `);
+            }
+            else {
+                expect(transcript).toMatchInlineSnapshot(`
+            {
+              "source": "--- from: user (voice-tester)
+            Source history for voice new-session
+            --- from: assistant (TestBot)
+            > *using deterministic-provider/deterministic-v2*
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
+            --- from: user (voice-tester)
+            [attachment: voice-message.ogg]
+            --- from: assistant (TestBot)
+            🎤 Transcribing voice message...
+            📝 **Transcribed message:** Explain voice routing new-session
+            Created new session in <#TARGET_THREAD>",
+              "target": "--- from: assistant (TestBot)
+            **Starting OpenCode session**
+            Explain voice routing new-session
+            > *using deterministic-provider/deterministic-v2*
+            > session-reply
+            > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>",
+            }
+          `);
+            }
+            const targetSessionId = await getThreadSession(target.id);
+            expect(targetSessionId).toBeTruthy();
+            expect(targetSessionId).not.toBe(sourceSessionId);
+            expect(await getThreadWorktreeOrWorkspace(target.id)).toMatchObject({
+                status: 'ready',
+                workspace_type: 'worktree',
+                workspace_name: 'voice-workspace',
+                workspace_id: 'voice-workspace-id',
+                workspace_directory: directories.projectDirectory,
+            });
+            const client = getOpencodeClientForTest(directories.projectDirectory);
+            const targetMessages = await client.session.messages({ sessionID: targetSessionId });
+            const targetTexts = getUserTexts(targetMessages.data ?? []).join('\n');
+            expect(targetTexts).toContain(prompt);
+            expect(targetTexts).toContain(`Voice message transcription from Discord user:\n${prompt}`);
+            expect(targetTexts.includes(`Source history for voice ${sessionAction}`)).toBe(sessionAction === 'btw');
+            const sourceMessages = await client.session.messages({ sessionID: sourceSessionId });
+            expect(getUserTexts(sourceMessages.data ?? []).join('\n')).not.toContain(prompt);
+        });
+    }
     test('voice message in channel creates thread and starts session', async () => {
         setDeterministicTranscription({
             transcription: 'Fix the login bug in auth.ts',
@@ -394,9 +508,9 @@ e2eTest('voice message handling', () => {
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Fix the login bug in auth.ts
-        *using deterministic-provider/deterministic-v2*
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         expect(finalState.sessionId).toBeDefined();
         // Verify OpenCode session received the transcribed voice message as a prompt
@@ -484,9 +598,9 @@ e2eTest('voice message handling', () => {
         Voice transcription requires an API key (OpenAI or Gemini). Set one to enable voice message transcription.
         Gemini API key saved. Retrying the original voice message.
         📝 **Transcribed message:** Resume the original voice note
-        *using deterministic-provider/deterministic-v2*
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         const finalState = getThreadState(thread.id);
         expect(finalState?.sessionId).toBeDefined();
@@ -548,9 +662,9 @@ e2eTest('voice message handling', () => {
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Investigate the missing content type path
-        *using deterministic-provider/deterministic-v2*
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > *using deterministic-provider/deterministic-v2*
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         const messages = await waitForSessionMessages({
             projectDirectory: directories.projectDirectory,
@@ -637,16 +751,16 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         FAST_RESPONSE_MARKER initial setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ fast-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > fast-response-done
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Add error handling to the parser
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         expect(finalState?.sessionId).toBeDefined();
         if (!finalState?.sessionId) {
@@ -848,19 +962,19 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         SLOW_RESPONSE_MARKER start queued task
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Queue this task for later
         Queued at position 1. Edit or delete your message to update the queue
-        ⬥ slow-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > slow-response-done
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2*
         » **voice-tester:** Voice message transcription from Discord user:
         Queue this task for later
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         expect(finalState.queueItems.length).toBe(0);
         // Verify the OpenCode session processed BOTH prompts sequentially:
@@ -957,16 +1071,16 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         FAST_RESPONSE_MARKER quick task
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ fast-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > fast-response-done
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Delayed transcription result
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         expect(finalState.sessionId).toBeDefined();
         expect(finalState.queueItems.length).toBe(0);
@@ -1075,16 +1189,16 @@ e2eTest('voice message handling', () => {
         "--- from: user (voice-tester)
         FAST_RESPONSE_MARKER fast before queued voice
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ fast-response-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
+        > fast-response-done
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>
         --- from: user (voice-tester)
         [attachment: voice-message.ogg]
         --- from: assistant (TestBot)
         🎤 Transcribing voice message...
         📝 **Transcribed message:** Queued voice after idle
-        ⬥ session-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > session-reply
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@300000000000000777>"
       `);
         expect(finalState.sessionId).toBeDefined();
         expect(finalState.queueItems.length).toBe(0);

package/dist/voice-routing-input.e2e.test.js

@@ -0,0 +1,195 @@
+// Cover long routed prompts and rejected voice routes without an existing session.
+import { afterEach, describe, expect, test } from 'vitest';
+import { ChannelType } from 'discord.js';
+import { setupQueueAdvancedSuite, TEST_USER_ID } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage } from './test-utils.js';
+import { getThreadSession } from './database.js';
+import { getOpencodeClient } from './opencode.js';
+import { store } from './store.js';
+const TEXT_CHANNEL_ID = '200000000000001084';
+describe('voice routing input boundaries', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'voice-routing-input',
+        dirName: 'voice-routing-input',
+        username: 'voice-input-tester',
+    });
+    afterEach(() => {
+        store.setState({ test: { deterministicTranscription: null } });
+    });
+    test('fresh voice route splits display and preserves the full model prompt', async () => {
+        const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID);
+        if (channel?.type !== ChannelType.GuildText)
+            throw new Error('Expected text channel');
+        const source = await channel.threads.create({ name: 'Long voice source' });
+        const prompt = `Long voice request ${'Z'.repeat(2100)} END_OF_REQUEST`;
+        const caption = 'Keep the existing public API unchanged.';
+        store.setState({
+            test: {
+                deterministicTranscription: {
+                    transcription: prompt,
+                    queueMessage: false,
+                    sessionAction: 'new-session',
+                },
+            },
+        });
+        await ctx.discord.thread(source.id).user(TEST_USER_ID).sendVoiceMessage({ content: caption });
+        const routingMessages = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: source.id,
+            text: 'Created new session in',
+            timeout: 4_000,
+        });
+        const targetId = routingMessages.find((message) => message.content.includes('Created new session in'))
+            ?.content.match(/<#(\d+)>/)?.[1];
+        if (!targetId)
+            throw new Error('Expected destination thread link');
+        const target = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (thread) => thread.id === targetId,
+        });
+        await waitForFooterMessage({ discord: ctx.discord, threadId: target.id, timeout: 4_000 });
+        expect((await ctx.discord.channel(TEXT_CHANNEL_ID).text()).replace(/Z+/g, '[DETAILS]'))
+            .toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        **Starting OpenCode session**
+        Keep the existing public API unchanged.
+
+        "
+      `);
+        expect((await ctx.discord.thread(target.id).text()).replace(/Z+/g, '[DETAILS]'))
+            .toMatchInlineSnapshot(`
+        "--- from: assistant (TestBot)
+        **Starting OpenCode session**
+        Keep the existing public API unchanged.
+
+
+        Long voice request [DETAILS]
+        [DETAILS] END_OF_REQUEST
+        > *using deterministic-provider/deterministic-v2*
+        > ok
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+      `);
+        const channelMessages = await ctx.discord.channel(TEXT_CHANNEL_ID).getMessages();
+        expect(channelMessages).toHaveLength(1);
+        expect(channelMessages.every((message) => message.content.length <= 2000)).toBe(true);
+        const threadText = await ctx.discord.thread(target.id).text();
+        expect(threadText).toContain(caption);
+        expect(threadText.replace(/\s/g, '')).toContain(prompt.replace(/\s/g, ''));
+        expect(threadText.match(/Z/g)).toHaveLength(2100);
+        const sessionId = await getThreadSession(target.id);
+        if (!sessionId)
+            throw new Error('Expected target session');
+        const client = getOpencodeClient(ctx.directories.projectDirectory);
+        if (!client)
+            throw new Error('Expected OpenCode client');
+        const messages = await client.session.messages({ sessionID: sessionId });
+        const userTexts = messages.data
+            ?.filter((message) => message.info.role === 'user')
+            .flatMap((message) => message.parts.flatMap((part) => (part.type === 'text' ? [part.text] : [])));
+        expect(userTexts?.join('\n')).toContain(`Voice message transcription from Discord user:\n${prompt}`);
+        expect(userTexts?.join('\n')).toContain(caption);
+        expect(await getThreadSession(source.id)).toBeFalsy();
+    });
+    test('unsupported contextual route keeps the transcript and never dispatches raw text', async () => {
+        const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID);
+        if (channel?.type !== ChannelType.GuildText)
+            throw new Error('Expected text channel');
+        const source = await channel.threads.create({ name: 'Unsupported voice source' });
+        const th = ctx.discord.thread(source.id);
+        store.setState({
+            test: {
+                deterministicTranscription: {
+                    transcription: 'Explain the parser in a contextual side chat',
+                    queueMessage: false,
+                    sessionAction: 'btw',
+                },
+            },
+        });
+        await th.user(TEST_USER_ID).sendVoiceMessage({ content: 'Do not dispatch this raw text' });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: source.id,
+            text: 'Nothing was sent to the agent',
+            timeout: 4_000,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+      "--- from: user (voice-input-tester)
+      Do not dispatch this raw text
+      [attachment: voice-message.ogg]
+      --- from: assistant (TestBot)
+      🎤 Transcribing voice message...
+      📝 **Transcribed message:** Explain the parser in a contextual side chat
+      A contextual side chat needs an existing session. Nothing was sent to the agent. Retry from a session, or ask to create a fresh chat with this request."
+    `);
+        for (let index = 0; index < 10; index++) {
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            expect(await getThreadSession(source.id)).toBeFalsy();
+        }
+    });
+    test('routing-only audio does not start a junk turn', async () => {
+        const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID);
+        if (channel?.type !== ChannelType.GuildText)
+            throw new Error('Expected text channel');
+        const source = await channel.threads.create({ name: 'Empty voice source' });
+        const th = ctx.discord.thread(source.id);
+        store.setState({
+            test: {
+                deterministicTranscription: {
+                    transcription: '',
+                    queueMessage: false,
+                    sessionAction: 'new-session',
+                },
+            },
+        });
+        await th.user(TEST_USER_ID).sendVoiceMessage({ content: 'Create a new chat' });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: source.id,
+            text: 'No request was transcribed',
+            timeout: 4_000,
+        });
+        expect(await th.text()).toMatchInlineSnapshot(`
+      "--- from: user (voice-input-tester)
+      Create a new chat
+      [attachment: voice-message.ogg]
+      --- from: assistant (TestBot)
+      🎤 Transcribing voice message...
+      No request was transcribed. Record another voice message with the task to send."
+    `);
+        for (let index = 0; index < 10; index++) {
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            expect(await getThreadSession(source.id)).toBeFalsy();
+        }
+    });
+    test('/new-session confirms the destination and sends the prompt', async () => {
+        const channel = await ctx.botClient.channels.fetch(TEXT_CHANNEL_ID);
+        if (channel?.type !== ChannelType.GuildText)
+            throw new Error('Expected text channel');
+        const source = await channel.threads.create({ name: 'Slash source' });
+        const th = ctx.discord.thread(source.id);
+        const interaction = await th.user(TEST_USER_ID).runSlashCommand({
+            name: 'new-session',
+            options: [{ name: 'prompt', type: 3, value: 'Slash fresh request' }],
+        });
+        await th.waitForInteractionAck({ interactionId: interaction.id, timeout: 4_000 });
+        const target = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (thread) => thread.name === 'Slash fresh request',
+        });
+        await waitForFooterMessage({ discord: ctx.discord, threadId: target.id, timeout: 4_000 });
+        expect((await th.text({ showInteractions: true })).replaceAll(target.id, 'TARGET_THREAD')).toMatchInlineSnapshot(`
+      "[user interaction]
+      --- from: assistant (TestBot)
+      Created new session in <#TARGET_THREAD>"
+    `);
+        expect(await ctx.discord.thread(target.id).text()).toMatchInlineSnapshot(`
+      "--- from: assistant (TestBot)
+      **Starting OpenCode session**
+      Slash fresh request
+      > *using deterministic-provider/deterministic-v2*
+      > ok
+      > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+    `);
+    });
+});

package/dist/voice-routing-question.e2e.test.js

@@ -0,0 +1,125 @@
+// Voice routes must leave the source question answerable without aborting its run.
+import { afterEach, describe, expect, test } 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';
+const TEXT_CHANNEL_ID = '200000000000001083';
+describe('voice routing preserves source questions', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'voice-routing-question',
+        dirName: 'voice-routing-question',
+        username: 'voice-question-tester',
+    });
+    afterEach(() => {
+        store.setState({ test: { deterministicTranscription: null } });
+    });
+    // Separate registrations permit distinct inline snapshots with Vitest 3.
+    for (const sessionAction of ['btw', 'new-session']) {
+        test(`${sessionAction} preserves the source dropdown`, async () => {
+            const marker = `QUESTION_SELECT_QUEUE_MARKER voice ${sessionAction}`;
+            await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({ content: marker });
+            const source = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+                timeout: 4_000,
+                predicate: (thread) => thread.name === marker,
+            });
+            const th = ctx.discord.thread(source.id);
+            const messages = await waitForBotMessageContaining({
+                discord: ctx.discord,
+                threadId: source.id,
+                text: 'How to proceed?',
+                timeout: 4_000,
+            });
+            const question = messages.find((message) => message.content.includes('How to proceed?'));
+            if (!question)
+                throw new Error('Expected question message');
+            const customId = JSON.stringify(question.components).match(/"custom_id":"(ask_question:[^"]+)"/)?.[1];
+            if (!customId)
+                throw new Error('Expected question dropdown');
+            const prompt = `Explain routing without changing the source ${sessionAction}`;
+            store.setState({
+                test: {
+                    deterministicTranscription: {
+                        transcription: prompt,
+                        queueMessage: false,
+                        sessionAction,
+                    },
+                },
+            });
+            await th.user(TEST_USER_ID).sendVoiceMessage();
+            const confirmation = sessionAction === 'btw' ? 'Session forked!' : 'Created new session in';
+            const routingMessages = await waitForBotMessageContaining({
+                discord: ctx.discord,
+                threadId: source.id,
+                text: confirmation,
+                timeout: 4_000,
+            });
+            const targetId = routingMessages.find((message) => message.content.includes(confirmation))
+                ?.content.match(/<#(\d+)>/)?.[1];
+            if (!targetId)
+                throw new Error('Expected destination thread link');
+            const target = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+                timeout: 4_000,
+                predicate: (thread) => thread.id === targetId,
+            });
+            await waitForFooterMessage({ discord: ctx.discord, threadId: target.id, timeout: 4_000 });
+            const interaction = await th.user(TEST_USER_ID).selectMenu({
+                messageId: question.id,
+                customId,
+                values: ['0'],
+            });
+            await th.waitForInteractionAck({ interactionId: interaction.id, timeout: 4_000 });
+            await waitForBotMessageContaining({
+                discord: ctx.discord,
+                threadId: source.id,
+                text: '» **voice-question-tester:** Alpha',
+                timeout: 4_000,
+            });
+            await waitForFooterMessage({ discord: ctx.discord, threadId: source.id, timeout: 4_000 });
+            const transcript = (await th.text({ showInteractions: true })).replaceAll(target.id, 'TARGET_THREAD');
+            if (sessionAction === 'btw') {
+                expect(transcript).toMatchInlineSnapshot(`
+          "--- from: user (voice-question-tester)
+          QUESTION_SELECT_QUEUE_MARKER voice btw
+          --- from: assistant (TestBot)
+          > *using deterministic-provider/deterministic-v2*
+          **Select action**
+          How to proceed?
+          ✓ _Alpha_
+          --- from: user (voice-question-tester)
+          [attachment: voice-message.ogg]
+          --- from: assistant (TestBot)
+          🎤 Transcribing voice message...
+          📝 **Transcribed message:** Explain routing without changing the source btw
+          Session forked! Continue in <#TARGET_THREAD>
+          [user selects dropdown: 0]
+          » **voice-question-tester:** Alpha
+          > tool done
+          > *project ⋅ main ⋅ 1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        `);
+            }
+            else {
+                expect(transcript).toMatchInlineSnapshot(`
+          "--- from: user (voice-question-tester)
+          QUESTION_SELECT_QUEUE_MARKER voice new-session
+          --- from: assistant (TestBot)
+          > *using deterministic-provider/deterministic-v2*
+          **Select action**
+          How to proceed?
+          ✓ _Alpha_
+          --- from: user (voice-question-tester)
+          [attachment: voice-message.ogg]
+          --- from: assistant (TestBot)
+          🎤 Transcribing voice message...
+          📝 **Transcribed message:** Explain routing without changing the source new-session
+          Created new session in <#TARGET_THREAD>
+          [user selects dropdown: 0]
+          » **voice-question-tester:** Alpha
+          > tool done
+          > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+        `);
+            }
+            expect(transcript).not.toContain('expired');
+        });
+    }
+});