kimaki 0.26.0 → 0.28.0

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

@@ -2,7 +2,8 @@
 // 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 { waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+import { store } from './store.js';
+import { getMessageVisibleText, isFooterMessage, waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
 const TEXT_CHANNEL_ID = '200000000000001001';
 const e2eTest = describe;
 e2eTest('queue advanced: footer emission', () => {
@@ -33,17 +34,48 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: footer-check
         --- 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>"
       `);
         const foundFooter = footerMessages.some((m) => {
             return m.author.id === ctx.discord.botUserId
-                && m.content.startsWith('*')
-                && m.content.includes('⋅');
+                && isFooterMessage({ message: m, botUserId: ctx.discord.botUserId });
         });
         expect(foundFooter).toBe(true);
     }, 8_000);
+    test('skip-footer-mentions omits the thread creator mention', async () => {
+        store.setState({ footerMentionsEnabled: false });
+        try {
+            await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+                content: 'Reply with exactly: footer-without-mention',
+            });
+            const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+                timeout: 4_000,
+                predicate: (t) => {
+                    return t.name === 'Reply with exactly: footer-without-mention';
+                },
+            });
+            const th = ctx.discord.thread(thread.id);
+            await th.waitForBotReply({ timeout: 4_000 });
+            await waitForFooterMessage({
+                discord: ctx.discord,
+                threadId: thread.id,
+                timeout: 4_000,
+            });
+            expect(await th.text()).toMatchInlineSnapshot(`
+          "--- from: user (queue-advanced-tester)
+          Reply with exactly: footer-without-mention
+          --- from: assistant (TestBot)
+          > *using deterministic-provider/deterministic-v2*
+          > ok
+          > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*"
+        `);
+        }
+        finally {
+            store.setState({ footerMentionsEnabled: true });
+        }
+    }, 8_000);
     test('footer appears after second message in same session', async () => {
         await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'Reply with exactly: footer-multi-setup',
@@ -83,21 +115,20 @@ e2eTest('queue advanced: footer emission', () => {
         const msgs = await th.getMessages();
         const footerCount = msgs.filter((m) => {
             return m.author.id === ctx.discord.botUserId
-                && m.content.startsWith('*')
-                && m.content.includes('⋅');
+                && isFooterMessage({ message: m, botUserId: ctx.discord.botUserId });
         }).length;
         expect(await th.text()).toMatchInlineSnapshot(`
         "--- from: user (queue-advanced-tester)
         Reply with exactly: footer-multi-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)
         Reply with exactly: footer-multi-second
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         if (footerCount >= 2) {
             expect(footerCount).toBeGreaterThanOrEqual(2);
@@ -111,9 +142,7 @@ e2eTest('queue advanced: footer emission', () => {
             });
             const latestMsgs = await th.getMessages();
             const count = latestMsgs.filter((m) => {
-                return m.author.id === ctx.discord.botUserId
-                    && m.content.startsWith('*')
-                    && m.content.includes('⋅');
+                return isFooterMessage({ message: m, botUserId: ctx.discord.botUserId });
             }).length;
             if (count >= 2) {
                 found = true;
@@ -174,7 +203,7 @@ e2eTest('queue advanced: footer emission', () => {
             if (idx <= followupUserIdx) {
                 return false;
             }
-            return m.author.id === ctx.discord.botUserId && m.content.includes('ok');
+            return m.author.id === ctx.discord.botUserId && getMessageVisibleText(m).includes('ok');
         });
         await waitForFooterMessage({
             discord: ctx.discord,
@@ -187,18 +216,18 @@ e2eTest('queue advanced: footer emission', () => {
         "--- from: user (queue-advanced-tester)
         Reply with exactly: interrupt-footer-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: interrupt-footer-followup
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         expect(followupUserIdx).toBeGreaterThanOrEqual(0);
         expect(okReplyIdx).toBeGreaterThan(followupUserIdx);
@@ -207,107 +236,11 @@ e2eTest('queue advanced: footer emission', () => {
                 return false;
             }
             return m.author.id === ctx.discord.botUserId
-                && m.content.startsWith('*')
-                && m.content.includes('⋅');
+                && isFooterMessage({ message: m, botUserId: ctx.discord.botUserId });
         });
         expect(footerBetween).toBe(false);
     }, 15_000);
-    test('plugin timeout interrupt aborts slow sleep and avoids intermediate footer', async () => {
-        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'Reply with exactly: plugin-timeout-setup',
-        });
-        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 4_000,
-            predicate: (t) => {
-                return t.name === 'Reply with exactly: plugin-timeout-setup';
-            },
-        });
-        const th = ctx.discord.thread(thread.id);
-        await th.waitForBotReply({ timeout: 4_000 });
-        await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: '*project',
-            timeout: 4_000,
-        });
-        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: plugin-timeout-after',
-        });
-        const messages = await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: 'ok',
-            afterUserMessageIncludes: 'plugin-timeout-after',
-            timeout: 12_000,
-        });
-        const messagesWithFooter = await waitForFooterMessage({
-            discord: ctx.discord,
-            threadId: thread.id,
-            timeout: 12_000,
-            afterMessageIncludes: 'plugin-timeout-after',
-            afterAuthorId: TEST_USER_ID,
-        });
-        const afterIndex = messagesWithFooter.findIndex((message) => {
-            return (message.author.id === TEST_USER_ID
-                && message.content.includes('plugin-timeout-after'));
-        });
-        expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        Reply with exactly: plugin-timeout-setup
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ 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: plugin-timeout-after
-        --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        expect(afterIndex).toBeGreaterThanOrEqual(0);
-        const okReplyIndex = messagesWithFooter.findIndex((message, index) => {
-            if (index <= afterIndex) {
-                return false;
-            }
-            return message.author.id === ctx.discord.botUserId && message.content.includes('ok');
-        });
-        expect(okReplyIndex).toBeGreaterThan(afterIndex);
-        const footerBeforeReply = messagesWithFooter.some((message, index) => {
-            if (index <= afterIndex || index >= okReplyIndex) {
-                return false;
-            }
-            if (message.author.id !== ctx.discord.botUserId) {
-                return false;
-            }
-            return message.content.startsWith('*') && message.content.includes('⋅');
-        });
-        expect(footerBeforeReply).toBe(false);
-    }, 15_000);
-    test('tool-call assistant message gets footer when it completes normally', async () => {
-        // Reproduces the bug: model responds with text + tool call,
-        // finish="tool-calls", message gets completed timestamp. Then the tool
-        // result triggers a follow-up text response in a second assistant message.
-        // The second message gets a footer, but the first (tool-call) message
-        // should ALSO get a footer since it completed normally.
-        // This matches the real-world scenario where an agent calls a bash tool
-        // (e.g. `kimaki send`) and then follows up with a summary text.
+    test('tool-call turn emits a footer after the final follow-up', async () => {
         const existingThreadIds = new Set((await ctx.discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
             return thread.id;
         }));
@@ -337,159 +270,17 @@ e2eTest('queue advanced: footer emission', () => {
             threadId: thread.id,
             timeout: 4_000,
         });
-        // Poll until both footers have arrived — the first footer (after the
-        // tool-call step) and the second (after the text follow-up) are emitted
-        // by sequential handleNaturalAssistantCompletion calls but the second
-        // may not have hit the Discord thread by the time we first check.
-        const deadline = Date.now() + 4_000;
-        let footerCount = 0;
-        while (Date.now() < deadline) {
-            const msgs = await th.getMessages();
-            footerCount = msgs.filter((m) => {
-                return m.author.id === ctx.discord.botUserId
-                    && m.content.startsWith('*')
-                    && m.content.includes('⋅');
-            }).length;
-            if (footerCount >= 2) {
-                break;
-            }
-            await new Promise((resolve) => {
-                setTimeout(resolve, 100);
-            });
-        }
         expect(await th.text()).toMatchInlineSnapshot(`
         "--- from: user (queue-advanced-tester)
         TOOL_CALL_FOOTER_MARKER
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ running tool
+        > *using deterministic-provider/deterministic-v2*
+        > running tool
+
         ┣ bash _echo tool-call-footer-test_
-        ⬥ tool call completed
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        // Only ONE footer at the end — the tool-call step's footer is NOT
-        // emitted mid-turn. The final text follow-up gets the footer.
-        expect(footerCount).toBe(1);
-    }, 10_000);
-    test('multi-step tool chain should only have one footer at the end', async () => {
-        // Model does 3 sequential tool calls (each a separate assistant message
-        // with finish="tool-calls") then a final text response. Only the final
-        // text response should get a footer — intermediate tool-call steps
-        // should NOT get footers since they're mid-turn work.
-        const existingThreadIds = new Set((await ctx.discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
-            return thread.id;
-        }));
-        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'MULTI_TOOL_FOOTER_MARKER',
-        });
-        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 6_000,
-            predicate: (t) => {
-                return !existingThreadIds.has(t.id);
-            },
-        });
-        const th = ctx.discord.thread(thread.id);
-        // Wait for the final text response after all 3 tool steps
-        await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: 'all done, fixed 3 files',
-            timeout: 6_000,
-        });
-        // Wait for the footer after the final response
-        await waitForFooterMessage({
-            discord: ctx.discord,
-            threadId: thread.id,
-            timeout: 6_000,
-        });
-        // Give any spurious extra footers time to arrive
-        await new Promise((resolve) => {
-            setTimeout(resolve, 500);
-        });
-        const messages = await th.getMessages();
-        const footerCount = messages.filter((m) => {
-            return m.author.id === ctx.discord.botUserId
-                && m.content.startsWith('*')
-                && m.content.includes('⋅');
-        }).length;
-        expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        MULTI_TOOL_FOOTER_MARKER
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ investigating the issue
-        ┣ bash _echo search-done_
-        ┣ bash _echo read-done_
-        ┣ bash _echo fix-done_
-        ⬥ all done, fixed 3 files
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+
+        > tool call completed
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
-        // Only ONE footer should appear — after the final text response.
-        // Intermediate tool-call steps should NOT get footers.
-        expect(footerCount).toBe(1);
     }, 10_000);
-    test('3 sequential tool-call steps produce exactly 1 footer, not 3', async () => {
-        // This is the most obvious reproduction of the multi-footer bug:
-        // the model runs 3 sequential tool-call steps (each a SEPARATE
-        // assistant message with finish="tool-calls"), then a final text.
-        // With a naive fix that treats tool-calls as natural completions,
-        // you'd see 4 footers (one per assistant message). Only the final
-        // text response should produce a footer.
-        const existingThreadIds = new Set((await ctx.discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
-            return thread.id;
-        }));
-        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-            content: 'MULTI_STEP_CHAIN_MARKER',
-        });
-        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
-            timeout: 6_000,
-            predicate: (t) => {
-                return !existingThreadIds.has(t.id);
-            },
-        });
-        const th = ctx.discord.thread(thread.id);
-        // Wait for the final text after all 3 sequential tool steps
-        await waitForBotMessageContaining({
-            discord: ctx.discord,
-            threadId: thread.id,
-            userId: TEST_USER_ID,
-            text: 'chain complete: all 3 steps done',
-            timeout: 10_000,
-        });
-        // Wait for footer
-        await waitForFooterMessage({
-            discord: ctx.discord,
-            threadId: thread.id,
-            timeout: 6_000,
-        });
-        // Give any spurious extra footers time to arrive
-        await new Promise((resolve) => {
-            setTimeout(resolve, 500);
-        });
-        const messages = await th.getMessages();
-        const footerCount = messages.filter((m) => {
-            return m.author.id === ctx.discord.botUserId
-                && m.content.startsWith('*')
-                && m.content.includes('⋅');
-        }).length;
-        expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-advanced-tester)
-        MULTI_STEP_CHAIN_MARKER
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ chain step 1: reading config
-        ┣ bash _echo chain-step-1-output_
-        ⬥ chain step 2: analyzing results
-        ┣ bash _echo chain-step-2-output_
-        ⬥ chain step 3: applying fix
-        ┣ bash _echo chain-step-3-output_
-        ⬥ chain complete: all 3 steps done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `);
-        // The critical assertion: only 1 footer at the very end.
-        // With the naive "allow tool-calls as natural completion" fix,
-        // this would be 4 (one per assistant message). We want 1.
-        expect(footerCount).toBe(1);
-    }, 15_000);
 });

package/dist/queue-advanced-model-switch.e2e.test.js

@@ -5,7 +5,7 @@ import { describe, test, expect } from 'vitest';
 import fs from 'node:fs';
 import path from 'node:path';
 import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
-import { waitForBotMessageContaining, waitForBotReplyAfterUserMessage, waitForFooterMessage, waitForMessageById, } from './test-utils.js';
+import { isFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, waitForFooterMessage, waitForMessageById, } from './test-utils.js';
 import { getThreadState } from './session-handler/thread-runtime-state.js';
 import { getSessionModel } from './database.js';
 import { initializeOpencodeForDirectory } from './opencode.js';
@@ -242,17 +242,15 @@ describe('queue advanced: /model with interrupt recovery', () => {
             afterAuthorId: TEST_USER_ID,
         });
         const footer = [...finalMessages].reverse().find((message) => {
-            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-model-switch-tester)
         Reply with exactly: model-switcher-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>
         Model set for this session:
         **Deterministic Provider** / **deterministic-v3**
         \`deterministic-provider/deterministic-v3\`
@@ -261,13 +259,13 @@ describe('queue advanced: /model with interrupt recovery', () => {
         --- from: user (queue-model-switch-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        ⬥ ok
-        ⬥ starting sleep 100
+        > ok
+        > starting sleep 100
         --- from: user (queue-model-switch-tester)
         Reply with exactly: model-switcher-followup
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v3*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v3* <@200000000000000991>"
       `);
         expect(footer).toBeDefined();
         expect(footer?.content).toContain('deterministic-v3');

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

@@ -32,7 +32,7 @@ describe('queue advanced: typing around permissions', () => {
         // every directory, so opt into the --restrict-directories behaviour here.
         restrictExternalDirectories: true,
     });
-    test('permission prompt pauses typing until user click, then typing resumes for long follow-up step', async () => {
+    test('permission prompt pauses typing until user click, then typing resumes', async () => {
         await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
             content: 'PERMISSION_TYPING_MARKER',
         });
@@ -56,7 +56,7 @@ describe('queue advanced: typing around permissions', () => {
             timeout: 4_000,
         });
         th.clearTypingEvents();
-        await th.waitForTypingEvent({ timeout: 2_000 }).then(() => {
+        await th.waitForTypingEvent({ timeout: 700 }).then(() => {
             throw new Error('Typing should stay paused while permission UI is pending');
         }, () => {
             return undefined;
@@ -69,19 +69,19 @@ describe('queue advanced: typing around permissions', () => {
             interactionId: interaction.id,
             timeout: 4_000,
         });
-        const resumedTyping = await th.waitForTypingEvent({ timeout: 9_000 });
+        const resumedTyping = await th.waitForTypingEvent({ timeout: 2_000 });
         expect(resumedTyping).toBeDefined();
         await waitForBotMessageContaining({
             discord: ctx.discord,
             threadId: thread.id,
             userId: TEST_USER_ID,
             text: 'permission-flow-done',
-            timeout: 12_000,
+            timeout: 4_000,
         });
         await waitForFooterMessage({
             discord: ctx.discord,
             threadId: thread.id,
-            timeout: 12_000,
+            timeout: 4_000,
             afterMessageIncludes: 'permission-flow-done',
             afterAuthorId: ctx.discord.botUserId,
         });
@@ -89,8 +89,9 @@ describe('queue advanced: typing around permissions', () => {
         "--- from: user (queue-permission-tester)
         PERMISSION_TYPING_MARKER
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        ⬥ requesting external read permission
+        > *using deterministic-provider/deterministic-v2*
+        > requesting external read permission
+
         ┣ read *.zprofile*
         ⚠️ **Permission Required**
         **Type:** \`external_directory\`
@@ -98,25 +99,24 @@ describe('queue advanced: typing around permissions', () => {
         **Pattern:** \`/Users/morse/*\`
         ✅ Permission **accepted**
         [user clicks button]
-        ⬥ permission-flow-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+
+        > permission-flow-done
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         const timeline = await th.text({
             showTyping: true,
             showInteractions: true,
         });
         const clickPosition = timeline.indexOf('[user clicks button]');
-        const donePosition = timeline.indexOf('⬥ permission-flow-done');
+        const donePosition = timeline.indexOf('permission-flow-done');
         const footerPosition = timeline.lastIndexOf('*project ⋅');
         expect(clickPosition).toBeGreaterThanOrEqual(0);
         expect(donePosition).toBeGreaterThan(clickPosition);
         expect(footerPosition).toBeGreaterThan(donePosition);
         const afterClick = timeline.slice(clickPosition, donePosition);
-        const afterDone = timeline.slice(donePosition, footerPosition);
         expect(afterClick).toContain('[bot typing]');
-        expect(afterDone).toContain('[bot typing]');
         expect(timeline.slice(footerPosition)).not.toContain('[bot typing]');
-    }, 20_000);
+    }, 12_000);
     test('manual thread message dismisses pending permission and sends the new prompt', async () => {
         const initialPrompt = 'PERMISSION_TYPING_MARKER dismiss-flow';
         const existingThreadIds = new Set((await ctx.discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
@@ -175,12 +175,12 @@ describe('queue advanced: typing around permissions', () => {
             afterAuthorId: ctx.discord.botUserId,
         });
         const timeline = await th.text({ showInteractions: true });
-        const normalizedTimeline = timeline.replace('⬥ requesting external read permission\n', '');
+        const normalizedTimeline = timeline.replace('requesting external read permission\n', '');
         expect(normalizedTimeline).toContain('PERMISSION_TYPING_MARKER dismiss-flow');
         expect(normalizedTimeline).toContain('Permission dismissed - user sent a new message.');
         expect(normalizedTimeline).toContain('Reply with exactly: post-permission-user-message');
         const followupUserPosition = normalizedTimeline.indexOf('Reply with exactly: post-permission-user-message');
-        const followupReplyPosition = normalizedTimeline.indexOf('⬥ ok', followupUserPosition);
+        const followupReplyPosition = normalizedTimeline.indexOf('ok', followupUserPosition);
         const followupFooterPosition = normalizedTimeline.indexOf('*project ⋅', followupReplyPosition);
         expect(followupUserPosition).toBeGreaterThanOrEqual(0);
         expect(followupReplyPosition).toBeGreaterThan(followupUserPosition);

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

@@ -4,12 +4,11 @@
 // 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 { waitForBotMessageContaining, waitForBotReplyAfterUserMessage, 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 },
@@ -128,45 +127,55 @@ describe('queue advanced: question tool answer', () => {
         // 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)
+        const answer = 'Reply with exactly: question-text-answer-done';
         await th.user(TEST_USER_ID).sendMessage({
-            content: 'my text answer',
+            content: answer,
         });
-        // Give time for question cleanup to propagate
-        await new Promise((r) => {
-            setTimeout(r, 1_000);
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: answer,
+            timeout: 8_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'ok',
+            afterUserMessageIncludes: answer,
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: 'ok',
+            afterAuthorId: ctx.discord.botUserId,
         });
         const timeline = await th.text({ showInteractions: true });
         // The user's text answer must appear in Discord
-        expect(timeline).toContain('my text answer');
+        expect(timeline).toContain(answer);
+        expect(timeline).toContain('ok');
         // 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 marker = 'QUESTION_TEXT_ANSWER_MARKER voice';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: marker,
         });
-        const thread = await ctx.discord.channel(VOICE_CHANNEL_ID).waitForThread({
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
             timeout: 8_000,
             predicate: (t) => {
-                return t.name === 'QUESTION_TEXT_ANSWER_MARKER';
+                return t.name === marker;
             },
         });
         const th = ctx.discord.thread(thread.id);
@@ -188,10 +197,6 @@ describe('queue advanced: voice message during pending question', () => {
         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({
@@ -254,7 +259,7 @@ describe('queue advanced: voice message during pending question', () => {
         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');
+        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);