kimaki 0.26.0 → 0.27.0

package/src/queue-advanced-e2e-setup.ts

@@ -105,6 +105,32 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     },
   }
 
+  const questionSelectDrainMatcher: DeterministicMatcher = {
+    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: DeterministicMatcher = {
     id: 'slow-abort-marker',
     priority: 100,
@@ -294,9 +320,7 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
           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],
     },
   }
 
@@ -423,6 +447,7 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     when: {
       lastMessageRole: 'user',
       latestUserTextIncludes: 'QUESTION_TEXT_ANSWER_MARKER',
+      rawPromptRegex: '^(?!.*question-text-answer-call)',
     },
     then: {
       parts: [
@@ -459,6 +484,7 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     when: {
       lastMessageRole: 'user',
       latestUserTextIncludes: 'QUESTION_SELECT_QUEUE_MARKER',
+      rawPromptRegex: '^(?!.*question-select-queue-call)',
     },
     then: {
       parts: [
@@ -487,6 +513,50 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     },
   }
 
+  // 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: DeterministicMatcher = {
+    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".
@@ -806,6 +876,7 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
   }
 
   return [
+    questionSelectDrainMatcher,
     slowAbortMatcher,
     slowBusyMatcher,
     typingRepulseMatcher,
@@ -813,6 +884,7 @@ export function createDeterministicMatchers(): DeterministicMatcher[] {
     actionButtonClickFollowupMatcher,
     questionToolMatcher,
     questionSelectQueueMatcher,
+    questionAfterTextMatcher,
     permissionTypingMatcher,
     permissionTypingFollowupMatcher,
     externalDirectoryProbeMatcher,
@@ -857,11 +929,15 @@ export function setupQueueAdvancedSuite({
   username,
   restrictExternalDirectories = false,
   projectPermission,
+  extraMatchers = [],
 }: {
   channelId: string
   channelName: string
   dirName: string
   username: string
+  // Matchers only this suite needs. Keeps narrow markers out of the shared list
+  // so they cannot cascade into unrelated e2e files.
+  extraMatchers?: DeterministicMatcher[]
   // Opt into the --restrict-directories behaviour so reads outside the project
   // still raise an external_directory permission prompt. Off by default, which
   // matches the shipped default of allowing every directory.
@@ -924,7 +1000,10 @@ export function setupQueueAdvancedSuite({
       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'),

package/src/queue-advanced-footer.e2e.test.ts

@@ -6,6 +6,7 @@ import {
   setupQueueAdvancedSuite,
   TEST_USER_ID,
 } from './queue-advanced-e2e-setup.js'
+import { store } from './store.js'
 import {
   waitForFooterMessage,
   waitForBotMessageContaining,
@@ -52,7 +53,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
@@ -64,6 +65,45 @@ e2eTest('queue advanced: footer emission', () => {
     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 () => {
@@ -121,12 +161,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)
@@ -235,7 +275,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)
@@ -244,7 +284,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)
@@ -263,120 +303,8 @@ e2eTest('queue advanced: footer emission', () => {
   )
 
   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',
+    'tool-call turn emits a footer after the final follow-up',
     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.
       const existingThreadIds = new Set(
         (await ctx.discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
           return thread.id
@@ -413,27 +341,6 @@ e2eTest('queue advanced: footer emission', () => {
         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
@@ -442,164 +349,10 @@ 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/src/queue-advanced-model-switch.e2e.test.ts

@@ -330,7 +330,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\`
@@ -345,7 +345,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()

package/src/queue-advanced-permissions-typing.e2e.test.ts

@@ -51,7 +51,7 @@ describe('queue advanced: typing around permissions', () => {
   })
 
   test(
-    'permission prompt pauses typing until user click, then typing resumes for long follow-up step',
+    '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',
@@ -83,7 +83,7 @@ describe('queue advanced: typing around permissions', () => {
 
       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')
         },
@@ -102,7 +102,7 @@ describe('queue advanced: typing around permissions', () => {
         timeout: 4_000,
       })
 
-      const resumedTyping = await th.waitForTypingEvent({ timeout: 9_000 })
+      const resumedTyping = await th.waitForTypingEvent({ timeout: 2_000 })
       expect(resumedTyping).toBeDefined()
 
       await waitForBotMessageContaining({
@@ -110,13 +110,13 @@ describe('queue advanced: typing around permissions', () => {
         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,
       })
@@ -135,7 +135,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({
@@ -150,12 +150,10 @@ describe('queue advanced: typing around permissions', () => {
       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(