kimaki 0.26.0 → 0.27.0

package/dist/queue-advanced-action-buttons.e2e.test.js

@@ -124,13 +124,13 @@ describe('queue advanced: action buttons', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         **Action Required**
         _Selected: Continue action-buttons flow_
         [user clicks button]
         » **queue-action-tester:** Continue action-buttons flow
         ⬥ action-buttons-click-continued
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         expect(timeline).toContain('action-buttons-click-continued');
     }, 20_000);
@@ -197,7 +197,7 @@ describe('queue advanced: action buttons', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         **Action Required**
         _Buttons dismissed._
         --- from: user (queue-action-tester)

package/dist/queue-advanced-e2e-setup.js

@@ -78,6 +78,31 @@ export function createDeterministicMatchers() {
             partDelaysMs: [0, 500, 0, 0, 0],
         },
     };
+    const questionSelectDrainMatcher = {
+        id: 'question-select-drain-first',
+        priority: 109,
+        when: {
+            latestUserTextIncludes: 'QUESTION_SELECT_DRAIN_FIRST_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'question-select-drain-first' },
+                {
+                    type: 'text-delta',
+                    id: 'question-select-drain-first',
+                    delta: 'question-drain-first',
+                },
+                { type: 'text-end', id: 'question-select-drain-first' },
+                {
+                    type: 'finish',
+                    finishReason: 'stop',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [0, 0, 0, 400, 0],
+        },
+    };
     const slowAbortMatcher = {
         id: 'slow-abort-marker',
         priority: 100,
@@ -260,9 +285,7 @@ export function createDeterministicMatchers() {
                     usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
                 },
             ],
-            // Keep run busy long enough after permission reply so typing keepalive
-            // must pulse again. This makes typing resume assertions deterministic.
-            partDelaysMs: [0, 0, 0, 0, 8_000],
+            partDelaysMs: [0, 400, 0, 0, 0],
         },
     };
     const externalDirectoryProbeMatcher = {
@@ -382,6 +405,7 @@ export function createDeterministicMatchers() {
         when: {
             lastMessageRole: 'user',
             latestUserTextIncludes: 'QUESTION_TEXT_ANSWER_MARKER',
+            rawPromptRegex: '^(?!.*question-text-answer-call)',
         },
         then: {
             parts: [
@@ -417,6 +441,7 @@ export function createDeterministicMatchers() {
         when: {
             lastMessageRole: 'user',
             latestUserTextIncludes: 'QUESTION_SELECT_QUEUE_MARKER',
+            rawPromptRegex: '^(?!.*question-select-queue-call)',
         },
         then: {
             parts: [
@@ -444,6 +469,49 @@ export function createDeterministicMatchers() {
             ],
         },
     };
+    // Text then question, with text-end delayed after the tool call.
+    // Reproduces OpenCode emitting question.asked before the text part's time.end.
+    const questionAfterTextMatcher = {
+        id: 'question-after-text-marker',
+        priority: 108,
+        when: {
+            lastMessageRole: 'user',
+            latestUserTextIncludes: 'QUESTION_AFTER_TEXT_MARKER',
+        },
+        then: {
+            parts: [
+                { type: 'stream-start', warnings: [] },
+                { type: 'text-start', id: 'plan-before-question' },
+                {
+                    type: 'text-delta',
+                    id: 'plan-before-question',
+                    delta: 'PLAN_TEXT_BEFORE_QUESTION',
+                },
+                {
+                    type: 'tool-call',
+                    toolCallId: 'question-after-text-call',
+                    toolName: 'question',
+                    input: JSON.stringify({
+                        questions: [{
+                                question: 'What next?',
+                                header: 'Next step',
+                                options: [
+                                    { label: 'Commit', description: 'Commit these files' },
+                                    { label: 'Stop', description: 'Leave uncommitted' },
+                                ],
+                            }],
+                    }),
+                },
+                { type: 'text-end', id: 'plan-before-question' },
+                {
+                    type: 'finish',
+                    finishReason: 'tool-calls',
+                    usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
+                },
+            ],
+            partDelaysMs: [200, 0, 0, 0, 400, 0],
+        },
+    };
     // Model responds with text + tool call, then after tool result the
     // follow-up matcher responds with text. This creates two assistant messages:
     // first with finish="tool-calls" + completed, second with finish="stop".
@@ -753,6 +821,7 @@ export function createDeterministicMatchers() {
         },
     };
     return [
+        questionSelectDrainMatcher,
         slowAbortMatcher,
         slowBusyMatcher,
         typingRepulseMatcher,
@@ -760,6 +829,7 @@ export function createDeterministicMatchers() {
         actionButtonClickFollowupMatcher,
         questionToolMatcher,
         questionSelectQueueMatcher,
+        questionAfterTextMatcher,
         permissionTypingMatcher,
         permissionTypingFollowupMatcher,
         externalDirectoryProbeMatcher,
@@ -787,7 +857,7 @@ export const TEST_USER_ID = '200000000000000991';
  * Each caller should use a unique channelId and dirName to avoid collisions
  * when vitest runs files in parallel.
  */
-export function setupQueueAdvancedSuite({ channelId, channelName, dirName, username, restrictExternalDirectories = false, projectPermission, }) {
+export function setupQueueAdvancedSuite({ channelId, channelName, dirName, username, restrictExternalDirectories = false, projectPermission, extraMatchers = [], }) {
     const ctx = {
         directories: undefined,
         discord: undefined,
@@ -828,7 +898,10 @@ export function setupQueueAdvancedSuite({ channelId, channelName, dirName, usern
             providerNpm,
             model: 'deterministic-v2',
             smallModel: 'deterministic-v3',
-            settings: { strict: false, matchers: createDeterministicMatchers() },
+            settings: {
+                strict: false,
+                matchers: [...createDeterministicMatchers(), ...extraMatchers],
+            },
         });
         fs.writeFileSync(path.join(ctx.directories.projectDirectory, 'opencode.json'), JSON.stringify(projectPermission
             ? { ...opencodeConfig, permission: projectPermission }

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

@@ -2,6 +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 { store } from './store.js';
 import { waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
 const TEXT_CHANNEL_ID = '200000000000001001';
 const e2eTest = describe;
@@ -35,7 +36,7 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         const foundFooter = footerMessages.some((m) => {
             return m.author.id === ctx.discord.botUserId
@@ -44,6 +45,38 @@ e2eTest('queue advanced: footer emission', () => {
         });
         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 ⋅ Ns ⋅ N% ⋅ 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',
@@ -92,12 +125,12 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (queue-advanced-tester)
         Reply with exactly: footer-multi-second
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         if (footerCount >= 2) {
             expect(footerCount).toBeGreaterThanOrEqual(2);
@@ -189,7 +222,7 @@ e2eTest('queue advanced: footer emission', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (queue-advanced-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
@@ -198,7 +231,7 @@ e2eTest('queue advanced: footer emission', () => {
         Reply with exactly: interrupt-footer-followup
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         expect(followupUserIdx).toBeGreaterThanOrEqual(0);
         expect(okReplyIdx).toBeGreaterThan(followupUserIdx);
@@ -212,102 +245,7 @@ e2eTest('queue advanced: footer emission', () => {
         });
         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,26 +275,6 @@ 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
@@ -365,131 +283,7 @@ e2eTest('queue advanced: footer emission', () => {
         ⬥ running tool
         ┣ bash _echo tool-call-footer-test_
         ⬥ tool call completed
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `);
-        // 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*"
-      `);
-        // 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

@@ -252,7 +252,7 @@ describe('queue advanced: /model with interrupt recovery', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         Model set for this session:
         **Deterministic Provider** / **deterministic-v3**
         \`deterministic-provider/deterministic-v3\`
@@ -267,7 +267,7 @@ describe('queue advanced: /model with interrupt recovery', () => {
         Reply with exactly: model-switcher-followup
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v3*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ 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,
         });
@@ -99,7 +99,7 @@ describe('queue advanced: typing around permissions', () => {
         ✅ Permission **accepted**
         [user clicks button]
         ⬥ permission-flow-done
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `);
         const timeline = await th.text({
             showTyping: true,
@@ -112,11 +112,9 @@ describe('queue advanced: typing around permissions', () => {
         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) => {