kimaki 0.26.0 → 0.28.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({
@@ -308,7 +314,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')

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

@@ -7,6 +7,8 @@ import {
   TEST_USER_ID,
 } from './queue-advanced-e2e-setup.js'
 import {
+  getMessageVisibleText,
+  isFooterMessage,
   waitForBotMessageContaining,
   waitForFooterMessage,
 } from './test-utils.js'
@@ -91,33 +93,31 @@ e2eTest('queue advanced: typing interrupt', () => {
         if (index <= finalUserIndex) {
           return false
         }
-        return message.author.id === ctx.discord.botUserId && message.content.includes('ok')
+        return message.author.id === ctx.discord.botUserId && getMessageVisibleText(message).includes('ok')
       })
       const finalFooterIndex = messages.findIndex((message, index) => {
         if (index <= finalReplyIndex) {
           return false
         }
-        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-advanced-tester)
         Reply with exactly: typing-stop-interrupt-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: typing-stop-interrupt-final
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `)
 
       const timeline = await th.text({ showTyping: true })
@@ -129,7 +129,7 @@ e2eTest('queue advanced: typing interrupt', () => {
       const finalPromptPosition = timeline.indexOf(
         'Reply with exactly: typing-stop-interrupt-final',
       )
-      const finalReplyPosition = timeline.indexOf('--- from: assistant (TestBot)\n⬥ ok', finalPromptPosition)
+      const finalReplyPosition = timeline.indexOf('--- from: assistant (TestBot)\n> ok', finalPromptPosition)
       const lastFooterPosition = timeline.lastIndexOf('*project ⋅')
       expect(finalPromptPosition).toBeGreaterThanOrEqual(0)
       expect(finalReplyPosition).toBeGreaterThan(finalPromptPosition)

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

@@ -7,6 +7,8 @@ import {
   TEST_USER_ID,
 } from './queue-advanced-e2e-setup.js'
 import {
+  getMessageVisibleText,
+  isFooterMessage,
   waitForBotMessageContaining,
   waitForFooterMessage,
 } from './test-utils.js'
@@ -60,20 +62,18 @@ e2eTest('queue advanced: typing lifecycle', () => {
       })
 
       const replyIndex = messages.findIndex((message) => {
-        return message.author.id === ctx.discord.botUserId && message.content.includes('ok')
+        return message.author.id === ctx.discord.botUserId && getMessageVisibleText(message).includes('ok')
       })
       const footerIndex = messages.findIndex((message, index) => {
         if (index <= replyIndex) {
           return false
         }
-        return message.author.id === ctx.discord.botUserId
-          && message.content.startsWith('*')
-          && message.content.includes('⋅')
+        return isFooterMessage({ message, botUserId: ctx.discord.botUserId })
       })
 
       const timeline = await th.text({ showTyping: true })
       expect(timeline).toContain('Reply with exactly: typing-stop-normal')
-      expect(timeline).toContain('⬥ ok')
+      expect(timeline).toContain('ok')
       expect(timeline).toContain('*project ⋅ main ⋅')
       const typingCount = (timeline.match(/\[bot typing\]/g) || []).length
       expect(typingCount).toBeGreaterThanOrEqual(1)
@@ -145,7 +145,7 @@ e2eTest('queue advanced: typing lifecycle', () => {
           return false
         }
         return message.author.id === ctx.discord.botUserId
-          && message.content.includes('repulse-first')
+          && getMessageVisibleText(message).includes('repulse-first')
       })
       if (!firstReply) {
         throw new Error('Expected first bot reply after TYPING_REPULSE_MARKER')
@@ -173,7 +173,7 @@ e2eTest('queue advanced: typing lifecycle', () => {
 
       const timeline = await th.text({ showTyping: true })
       expect(timeline).toContain('TYPING_REPULSE_MARKER')
-      expect(timeline).toContain('⬥ repulse-first')
+      expect(timeline).toContain('repulse-first')
       const typingCount = (timeline.match(/\[bot typing\]/g) || []).length
       expect(typingCount).toBeGreaterThanOrEqual(2)
 
@@ -186,7 +186,7 @@ e2eTest('queue advanced: typing lifecycle', () => {
           return false
         }
         return message.author.id === ctx.discord.botUserId
-          && message.content.includes('repulse-first')
+          && getMessageVisibleText(message).includes('repulse-first')
       })
 
       expect(followupUserIndex).toBeGreaterThanOrEqual(0)

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

@@ -86,11 +86,11 @@ e2eTest('queue delete message', () => {
         "--- from: user (queue-delete-tester)
         SLOW_BUSY_MARKER Reply with exactly: delete-queue-setup
         --- from: assistant (TestBot)
-        *using deterministic-provider/deterministic-v2*
+        > *using deterministic-provider/deterministic-v2*
         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*"
+        > slow-busy-reply
+        > *project ⋅ main ⋅ 2s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `)
       const finalText = await th.text()
       expect(finalText).not.toContain(

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

@@ -137,14 +137,14 @@ describe('queue drain with pending interactive UI', () => {
         "--- from: user (drain-ui-tester)
         Reply with exactly: drain-button-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>
         **Action Required**
         [user interaction]
         » **drain-ui-tester:** Reply with exactly: post-button-drain
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `)
     },
     20_000,

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

@@ -7,7 +7,7 @@
 //   2. User queues a message via /queue (enters kimaki local queue)
 //   3. User sends a normal message (interrupt)
 //   4. Session aborts the slow task, processes the interrupt message immediately
-//   5. Interrupt response appears in Discord with a ⬥ ok reply
+//   5. Interrupt response appears in Discord with a ok reply
 //   6. When interrupt response completes, the queued message drains and runs
 //
 // Uses opencode-deterministic-provider (no real LLM calls).
@@ -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 ⋅ <1s ⋅ 0% ⋅ 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 ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
+        » **interrupt-tester:** Reply with exactly: archived-queue-survives
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
+      `)
+    },
+    20_000,
+  )
+
   test(
     'queued message via /queue + normal interrupt: interrupt reply should appear, then queue drains',
     async () => {
@@ -108,7 +229,7 @@ e2eTest('queue + interrupt drain ordering', () => {
       })
 
       // 5. Wait for the final state: the interrupt message should get its own
-      //    ⬥ ok reply, then the queued message should drain and get processed.
+      //    ok reply, then the queued message should drain and get processed.
       //    We wait for the queued message's footer as the final signal.
       await waitForFooterMessage({
         discord: ctx.discord,
@@ -123,25 +244,25 @@ e2eTest('queue + interrupt drain ordering', () => {
         "--- from: user (interrupt-tester)
         Reply with exactly: setup-interrupt-drain
         --- 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 (interrupt-tester)
         PLUGIN_TIMEOUT_SLEEP_MARKER
         --- from: assistant (TestBot)
-        ⬥ starting sleep 100
+        > starting sleep 100
         Queued message (position 1)
         --- from: user (interrupt-tester)
         Reply with exactly: interrupt-now
         --- from: assistant (TestBot)
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2*
         » **interrupt-tester:** Reply with exactly: queued-behind-slow
-        ⬥ ok
-        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+        > ok
+        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@200000000000000991>"
       `)
 
-      // 7. Assert the interrupt message got its own ⬥ ok reply between the
+      // 7. Assert the interrupt message got its own ok reply between the
       //    user's interrupt message and the queue dispatch indicator.
       const text = await th.text()
       const lines = text.split('\n')
@@ -158,7 +279,7 @@ e2eTest('queue + interrupt drain ordering', () => {
 
       const linesBetween = lines.slice(interruptUserLine + 1, queueDispatchLine)
       const hasInterruptReply = linesBetween.some((line) => {
-        return line.includes('⬥ ok')
+        return line.includes('ok')
       })
       expect(hasInterruptReply).toBe(true)
     },