kimaki 0.26.0 → 0.27.0

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

@@ -5,14 +5,17 @@
 
 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, type DeterministicTranscriptionConfig } from './store.js'
 import { getOpencodeClient } from './opencode.js'
 import { getThreadSession } from './database.js'
 import type { Message, Part } from '@opencode-ai/sdk/v2'
 
 const TEXT_CHANNEL_ID = '200000000000001007'
-const VOICE_CHANNEL_ID = '200000000000001017'
 
 function setDeterministicTranscription(config: DeterministicTranscriptionConfig | null) {
   store.setState({
@@ -158,37 +161,44 @@ 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
@@ -196,14 +206,15 @@ describe('queue advanced: voice message during pending question', () => {
     // (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
       },
     })
 
@@ -230,11 +241,6 @@ describe('queue advanced: voice message during pending question', () => {
       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({

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

@@ -108,7 +108,7 @@ e2eTest('queue advanced: typing interrupt', () => {
         --- 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)
@@ -117,7 +117,7 @@ e2eTest('queue advanced: typing interrupt', () => {
         Reply with exactly: typing-stop-interrupt-final
         --- from: assistant (TestBot)
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `)
 
       const timeline = await th.text({ showTyping: true })

package/src/queue-delete-message.e2e.test.ts

@@ -90,7 +90,7 @@ e2eTest('queue delete message', () => {
         Queued at position 1. Edit or delete your message to update the queue
         ⬦ **queue-delete-tester** removed message from queue
         ⬥ slow-busy-reply
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `)
       const finalText = await th.text()
       expect(finalText).not.toContain(

package/src/queue-drain-after-interactive-ui.e2e.test.ts

@@ -139,12 +139,12 @@ describe('queue drain with pending interactive UI', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         **Action Required**
         [user interaction]
         » **drain-ui-tester:** Reply with exactly: post-button-drain
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `)
     },
     20_000,

package/src/queue-interrupt-drain.e2e.test.ts

@@ -23,6 +23,9 @@ import {
   waitForBotMessageContaining,
   waitForMessageById,
 } from './test-utils.js'
+import { getThreadSession } from './database.js'
+import { archiveThread } from './discord-utils.js'
+import { getOpencodeClient } from './opencode.js'
 
 const TEXT_CHANNEL_ID = '200000000000001099'
 
@@ -36,6 +39,124 @@ e2eTest('queue + interrupt drain ordering', () => {
     username: 'interrupt-tester',
   })
 
+  test(
+    'archiving keeps the active run alive so queued messages drain',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: setup-archive-drain',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (candidate) => {
+          return candidate.name === 'Reply with exactly: setup-archive-drain'
+        },
+      })
+      const th = ctx.discord.thread(thread.id)
+      await th.waitForBotReply({ timeout: 4_000 })
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+      })
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'PLUGIN_TIMEOUT_SLEEP_MARKER archive queue drain',
+      })
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'starting sleep',
+        afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER archive queue drain',
+        timeout: 4_000,
+      })
+
+      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+        .runSlashCommand({
+          name: 'queue',
+          options: [{
+            name: 'message',
+            type: 3,
+            value: 'Reply with exactly: archived-queue-survives',
+          }],
+        })
+      const queueAck = await th.waitForInteractionAck({
+        interactionId: queueInteractionId,
+        timeout: 4_000,
+      })
+      if (!queueAck.messageId) {
+        throw new Error('Expected /queue response message id')
+      }
+      const queueStatusMessage = await waitForMessageById({
+        discord: ctx.discord,
+        threadId: thread.id,
+        messageId: queueAck.messageId,
+        timeout: 4_000,
+      })
+      expect(queueStatusMessage.content).toContain('Queued message')
+
+      const sessionId = await getThreadSession(thread.id)
+      if (!sessionId) throw new Error('Expected mapped OpenCode session')
+      const client = getOpencodeClient(ctx.directories.projectDirectory)
+      if (!client) throw new Error('Expected initialized OpenCode client')
+      await archiveThread({
+        rest: ctx.botClient.rest,
+        threadId: thread.id,
+        parentChannelId: TEXT_CHANNEL_ID,
+        sessionId,
+        client,
+      })
+
+      const statusResponse = await client.session.status({
+        directory: ctx.directories.projectDirectory,
+      })
+      expect(statusResponse.data?.[sessionId]?.type).toBe('busy')
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: continue-after-archive',
+      })
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 12_000,
+        afterMessageIncludes: 'continue-after-archive',
+        afterAuthorId: TEST_USER_ID,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 12_000,
+        afterMessageIncludes: 'archived-queue-survives',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (interrupt-tester)
+        Reply with exactly: setup-archive-drain
+        --- from: assistant (TestBot)
+        *using deterministic-provider/deterministic-v2*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
+        --- from: user (interrupt-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER archive queue drain
+        --- from: assistant (TestBot)
+        ⬥ starting sleep 100
+        Queued message (position 1)
+        --- from: user (interrupt-tester)
+        Reply with exactly: continue-after-archive
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **interrupt-tester:** Reply with exactly: archived-queue-survives
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
+      `)
+    },
+    20_000,
+  )
+
   test(
     'queued message via /queue + normal interrupt: interrupt reply should appear, then queue drains',
     async () => {
@@ -125,7 +246,7 @@ e2eTest('queue + interrupt drain ordering', () => {
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>
         --- from: user (interrupt-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
@@ -138,7 +259,7 @@ e2eTest('queue + interrupt drain ordering', () => {
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         » **interrupt-tester:** Reply with exactly: queued-behind-slow
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `)
 
       // 7. Assert the interrupt message got its own ⬥ ok reply between the

package/src/queue-question-select-drain.e2e.test.ts

@@ -1,7 +1,4 @@
-// E2e test: queued message must drain after the user answers a pending question
-// via the Discord dropdown select menu. Reproduces a bug where answering via
-// select (not text) leaves queued messages stuck because the session continues
-// processing after the answer and may enter another blocking state.
+// E2e test for ordered queue drain after a pending question is answered via select.
 
 import { describe, test, expect } from 'vitest'
 import {
@@ -53,10 +50,7 @@ async function expectNoBotMessageContaining({
   while (Date.now() - start < timeout) {
     const messages = await discord.thread(threadId).getMessages()
     const match = messages.find((message) => {
-      return (
-        message.author.id === discord.botUserId
-        && message.content.includes(text)
-      )
+      return message.author.id === discord.botUserId && message.content.includes(text)
     })
     if (match) {
       throw new Error(
@@ -78,132 +72,19 @@ describe('queue drain after question select answer', () => {
   })
 
   test(
-    'queued message drains after answering question via dropdown select',
+    'queued messages drain in order after answering via dropdown select',
     async () => {
-      // 1. Send a message that triggers the question tool
-      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: 'QUESTION_SELECT_QUEUE_MARKER',
-      })
-
-      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 8_000,
-        predicate: (t) => {
-          return t.name === 'QUESTION_SELECT_QUEUE_MARKER'
-        },
-      })
-
-      const th = ctx.discord.thread(thread.id)
-
-      // 2. Wait for the question dropdown message to appear in Discord.
-      // Uses visible message wait instead of internal Map polling which
-      // is too timing-sensitive on CI.
-      const questionMessages = await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: 'How to proceed?',
-        timeout: 12_000,
-      })
-
-      // Get the pending question context hash from the internal map.
-      // By this point the question message is visible so the context must exist.
-      const pending = await waitForPendingQuestion({
-        threadId: thread.id,
-        timeoutMs: 8_000,
-      })
-      const questionMsg = questionMessages.find((m) => {
-        return m.content.includes('How to proceed?')
-      })!
-      expect(questionMsg).toBeTruthy()
-
-      // 3. Queue a message while question is pending
-      const { id: queueInteractionId } = await th.user(TEST_USER_ID)
-        .runSlashCommand({
-          name: 'queue',
-          options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-question-drain' }],
-        })
-
-      const queueAck = await th.waitForInteractionAck({
-        interactionId: queueInteractionId,
-        timeout: 8_000,
-      })
-      if (!queueAck.messageId) {
-        throw new Error('Expected /queue response message id')
-      }
-
-      // 4. The first queued item should be handed off immediately even while
-      //    the question is still pending, so the visible dispatch indicator
-      //    appears before the user answers the dropdown.
-      await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: '» **question-select-tester:** Reply with exactly: post-question-drain',
-        timeout: 8_000,
-      })
-
-      // 5. Answer the question via dropdown select (pick first option "Alpha")
-      const interaction = await th.user(TEST_USER_ID).selectMenu({
-        messageId: questionMsg.id,
-        customId: `ask_question:${pending.contextHash}:0`,
-        values: ['0'],
-      })
-
-      await th.waitForInteractionAck({
-        interactionId: interaction.id,
-        timeout: 8_000,
-      })
-
-      // 6. Wait for footer from the drained queued message
-      await waitForFooterMessage({
-        discord: ctx.discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageIncludes: '» **question-select-tester:**',
-        afterAuthorId: ctx.discord.botUserId,
-      })
-
-      const timeline = await th.text({ showInteractions: true })
-      expect(timeline).toMatchInlineSnapshot(`
-        "--- from: user (question-select-tester)
-        QUESTION_SELECT_QUEUE_MARKER
-        --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
-        **Select action**
-        How to proceed?
-        ✓ _Alpha_
-        [user interaction]
-        » **question-select-tester:** Reply with exactly: post-question-drain
-        Queued message (position 1)
-        [user selects dropdown: 0]
-        » **question-select-tester:** Alpha
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-      expect(timeline).toContain('QUESTION_SELECT_QUEUE_MARKER')
-      expect(timeline).toContain('How to proceed?')
-      expect(timeline).toContain('[user selects dropdown: 0]')
-      expect(timeline).toContain('» **question-select-tester:** Reply with exactly: post-question-drain')
-      expect(timeline).toContain('⬥ ok')
-      expect(timeline).toContain('*project ⋅ main ⋅')
-    },
-    20_000,
-  )
-
-  test(
-    'only the first queued message is handed off after dropdown answer',
-    async () => {
-      const marker = 'QUESTION_SELECT_QUEUE_MARKER second-test'
-
+      const marker = 'QUESTION_SELECT_QUEUE_MARKER'
       await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
         content: marker,
       })
 
       const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
         timeout: 8_000,
-        predicate: (t) => {
-          return t.name === marker
+        predicate: (candidate) => {
+          return candidate.name === marker
         },
       })
-
       const th = ctx.discord.thread(thread.id)
 
       const questionMessages = await waitForBotMessageContaining({
@@ -212,21 +93,18 @@ describe('queue drain after question select answer', () => {
         text: 'How to proceed?',
         timeout: 12_000,
       })
-
       const pending = await waitForPendingQuestion({
         threadId: thread.id,
         timeoutMs: 8_000,
       })
-
-      const questionMsg = questionMessages.find((message) => {
+      const questionMessage = questionMessages.find((message) => {
         return message.content.includes('How to proceed?')
       })
-      expect(questionMsg).toBeTruthy()
-      if (!questionMsg) {
+      if (!questionMessage) {
         throw new Error('Expected question message')
       }
 
-      const firstQueuedPrompt = 'SLOW_ABORT_MARKER run long response'
+      const firstQueuedPrompt = 'QUESTION_SELECT_DRAIN_FIRST_MARKER'
       const secondQueuedPrompt = 'Reply with exactly: post-question-second'
 
       const { id: firstQueueInteractionId } = await th.user(TEST_USER_ID)
@@ -234,48 +112,45 @@ describe('queue drain after question select answer', () => {
           name: 'queue',
           options: [{ name: 'message', type: 3, value: firstQueuedPrompt }],
         })
-
       await th.waitForInteractionAck({
         interactionId: firstQueueInteractionId,
         timeout: 8_000,
       })
 
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${firstQueuedPrompt}`,
+        timeout: 8_000,
+      })
+
       const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
         .runSlashCommand({
           name: 'queue',
           options: [{ name: 'message', type: 3, value: secondQueuedPrompt }],
         })
-
       await th.waitForInteractionAck({
         interactionId: secondQueueInteractionId,
         timeout: 8_000,
       })
 
+      await expectNoBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+        timeout: 200,
+      })
+
       const interaction = await th.user(TEST_USER_ID).selectMenu({
-        messageId: questionMsg.id,
+        messageId: questionMessage.id,
         customId: `ask_question:${pending.contextHash}:0`,
         values: ['0'],
       })
-
       await th.waitForInteractionAck({
         interactionId: interaction.id,
         timeout: 8_000,
       })
 
-      await waitForBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: `» **question-select-tester:** ${firstQueuedPrompt}`,
-        timeout: 8_000,
-      })
-
-      await expectNoBotMessageContaining({
-        discord: ctx.discord,
-        threadId: thread.id,
-        text: `» **question-select-tester:** ${secondQueuedPrompt}`,
-        timeout: 200,
-      })
-
       await waitForFooterMessage({
         discord: ctx.discord,
         threadId: thread.id,
@@ -283,14 +158,12 @@ describe('queue drain after question select answer', () => {
         afterMessageIncludes: `» **question-select-tester:** ${firstQueuedPrompt}`,
         afterAuthorId: ctx.discord.botUserId,
       })
-
       await waitForBotMessageContaining({
         discord: ctx.discord,
         threadId: thread.id,
         text: `» **question-select-tester:** ${secondQueuedPrompt}`,
         timeout: 8_000,
       })
-
       await waitForFooterMessage({
         discord: ctx.discord,
         threadId: thread.id,
@@ -302,30 +175,32 @@ describe('queue drain after question select answer', () => {
       const timeline = await th.text({ showInteractions: true })
       expect(timeline).toMatchInlineSnapshot(`
         "--- from: user (question-select-tester)
-        QUESTION_SELECT_QUEUE_MARKER second-test
+        QUESTION_SELECT_QUEUE_MARKER
         --- from: assistant (TestBot)
         *using deterministic-provider/deterministic-v2*
         **Select action**
         How to proceed?
         ✓ _Alpha_
         [user interaction]
-        » **question-select-tester:** SLOW_ABORT_MARKER run long response
+        » **question-select-tester:** QUESTION_SELECT_DRAIN_FIRST_MARKER
         Queued message (position 1)
         [user interaction]
         Queued message (position 1)
         [user selects dropdown: 0]
         » **question-select-tester:** Alpha
-        ⬥ slow-response-started
+        ⬥ question-drain-first
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         » **question-select-tester:** Reply with exactly: post-question-second
         ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2* <@200000000000000991>"
       `)
+      expect(timeline).toContain('How to proceed?')
+      expect(timeline).toContain('[user selects dropdown: 0]')
       expect(timeline).toContain(`» **question-select-tester:** ${firstQueuedPrompt}`)
-      expect(timeline).toContain('⬥ slow-response-started')
+      expect(timeline).toContain('⬥ question-drain-first')
       expect(timeline).toContain(`» **question-select-tester:** ${secondQueuedPrompt}`)
       expect(timeline).toContain('⬥ ok')
     },
-    20_000,
+    15_000,
   )
 })