@brianli/kimaki 0.4.72-brianli.1

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

@@ -0,0 +1,997 @@
+// E2e tests for per-thread message queue ordering (threadMessageQueue).
+// Validates that messages in the same thread are processed sequentially
+// in Discord arrival order, and that immediate interrupt allows
+// queued messages to start without waiting for the full prior response.
+//
+// The threadMessageQueue (Map<string, Promise<void>>) only serializes messages
+// arriving in threads — the initial text channel message goes through a separate
+// code path (creates thread + calls handleOpencodeSession directly). So each
+// test first establishes a session via the initial message, waits for the bot
+// reply, then sends follow-up messages into the thread to exercise the queue.
+//
+// Bot replies may be error messages (e.g. "opencode session error: Not Found")
+// rather than actual LLM content, depending on provider/session state. The
+// tests verify ordering by message position, not content matching.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
+import { describe, beforeAll, afterAll, test, expect } from 'vitest'
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js'
+import type { APIMessage } from 'discord.js'
+import { DigitalDiscord } from 'discord-digital-twin/src'
+import {
+  buildDeterministicOpencodeConfig,
+  type DeterministicMatcher,
+} from 'opencode-deterministic-provider'
+import {
+  getDefaultVerbosity,
+  setDataDir,
+  setDefaultVerbosity,
+} from './config.js'
+import { startDiscordBot } from './discord-bot.js'
+import {
+  setBotToken,
+  initDatabase,
+  closeDatabase,
+  setChannelDirectory,
+  setChannelVerbosity,
+  getChannelVerbosity,
+} from './database.js'
+import { startHranaServer, stopHranaServer } from './hrana-server.js'
+import { getOpencodeServers } from './opencode.js'
+
+const e2eTest = describe
+
+function createRunDirectories() {
+  const root = path.resolve(process.cwd(), 'tmp', 'thread-queue-e2e')
+  fs.mkdirSync(root, { recursive: true })
+
+  const dataDir = fs.mkdtempSync(path.join(root, 'data-'))
+  const projectDirectory = path.join(root, 'project')
+  fs.mkdirSync(projectDirectory, { recursive: true })
+
+  return { root, dataDir, projectDirectory }
+}
+
+function chooseLockPort() {
+  return 47_000 + (Date.now() % 2_000)
+}
+
+function createDiscordJsClient({ restUrl }: { restUrl: string }) {
+  return new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.GuildVoiceStates,
+    ],
+    partials: [
+      Partials.Channel,
+      Partials.Message,
+      Partials.User,
+      Partials.ThreadMember,
+    ],
+    rest: {
+      api: restUrl,
+      version: '10',
+    },
+  })
+}
+
+async function cleanupOpencodeServers() {
+  const servers = getOpencodeServers()
+  for (const [, server] of servers) {
+    if (!server.process.killed) {
+      server.process.kill('SIGTERM')
+    }
+  }
+  servers.clear()
+}
+
+function createDeterministicMatchers() {
+  const raceFinalReplyMatcher: DeterministicMatcher = {
+    id: 'race-final-reply',
+    priority: 110,
+    when: {
+      rawPromptIncludes: 'Reply with exactly: race-final',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'race-final' },
+        { type: 'text-delta', id: 'race-final', delta: 'race-final' },
+        { type: 'text-end', id: 'race-final' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: {
+            inputTokens: 1,
+            outputTokens: 1,
+            totalTokens: 2,
+          },
+        },
+      ],
+      // Delay first output to widen the window where a stale idle could end
+      // this new request before it emits any assistant text.
+      partDelaysMs: [0, 2500, 0, 0, 0],
+    },
+  }
+
+  const sleepMatcher: DeterministicMatcher = {
+    id: 'sleep-tool-call',
+    priority: 100,
+    when: {
+      rawPromptIncludes:
+        'MANDATORY INSTRUCTION: call the bash tool immediately and run exactly this command: `sleep 500`',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'sleep-start' },
+        { type: 'text-delta', id: 'sleep-start', delta: 'running sleep 500' },
+        { type: 'text-end', id: 'sleep-start' },
+        {
+          type: 'tool-call',
+          toolCallId: 'sleep-call-1',
+          toolName: 'bash',
+          input: JSON.stringify({
+            command: 'sleep 500',
+            description: 'Deterministic sleep for interrupt e2e',
+            hasSideEffect: true,
+          }),
+        },
+        {
+          type: 'finish',
+          finishReason: 'tool-calls',
+          usage: {
+            inputTokens: 1,
+            outputTokens: 1,
+            totalTokens: 2,
+          },
+        },
+      ],
+    },
+  }
+
+  const toolFollowupMatcher: DeterministicMatcher = {
+    id: 'tool-followup',
+    priority: 50,
+    when: {
+      lastMessageRole: 'tool',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'tool-followup' },
+        { type: 'text-delta', id: 'tool-followup', delta: 'tool done' },
+        { type: 'text-end', id: 'tool-followup' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: {
+            inputTokens: 1,
+            outputTokens: 1,
+            totalTokens: 2,
+          },
+        },
+      ],
+    },
+  }
+
+  const userReplyMatcher: DeterministicMatcher = {
+    id: 'user-reply',
+    priority: 10,
+    when: {
+      lastMessageRole: 'user',
+      rawPromptIncludes: 'Reply with exactly:',
+    },
+    then: {
+      parts: [
+        { type: 'stream-start', warnings: [] },
+        { type: 'text-start', id: 'default-reply' },
+        { type: 'text-delta', id: 'default-reply', delta: 'ok' },
+        { type: 'text-end', id: 'default-reply' },
+        {
+          type: 'finish',
+          finishReason: 'stop',
+          usage: {
+            inputTokens: 1,
+            outputTokens: 1,
+            totalTokens: 2,
+          },
+        },
+      ],
+      partDelaysMs: [0, 700, 0, 0, 0],
+    },
+  }
+
+  return [
+    sleepMatcher,
+    raceFinalReplyMatcher,
+    toolFollowupMatcher,
+    userReplyMatcher,
+  ]
+}
+
+/** Poll getMessages until we see at least `count` bot messages. */
+async function waitForBotMessageCount({
+  discord,
+  threadId,
+  count,
+  timeout,
+}: {
+  discord: DigitalDiscord
+  threadId: string
+  count: number
+  timeout: number
+}) {
+  const start = Date.now()
+  while (Date.now() - start < timeout) {
+    const messages = await discord.thread(threadId).getMessages()
+    const botMessages = messages.filter((m) => {
+      return m.author.id === discord.botUserId
+    })
+    if (botMessages.length >= count) {
+      return messages
+    }
+    await new Promise((r) => {
+      setTimeout(r, 500)
+    })
+  }
+  throw new Error(
+    `Timed out waiting for ${count} bot messages in thread ${threadId}`,
+  )
+}
+
+async function waitForBotReplyAfterUserMessage({
+  discord,
+  threadId,
+  userMessageIncludes,
+  timeout,
+}: {
+  discord: DigitalDiscord
+  threadId: string
+  userMessageIncludes: string
+  timeout: number
+}) {
+  const start = Date.now()
+  while (Date.now() - start < timeout) {
+    const messages = await discord.thread(threadId).getMessages()
+    const userMessageIndex = messages.findIndex((message) => {
+      return (
+        message.author.id === TEST_USER_ID &&
+        message.content.includes(userMessageIncludes)
+      )
+    })
+    const botReplyIndex = messages.findIndex((message, index) => {
+      return index > userMessageIndex && message.author.id === discord.botUserId
+    })
+    if (userMessageIndex >= 0 && botReplyIndex >= 0) {
+      return messages
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 500)
+    })
+  }
+  throw new Error(
+    `Timed out waiting for bot reply after user message containing "${userMessageIncludes}" in thread ${threadId}`,
+  )
+}
+
+async function waitForBotMessageContaining({
+  discord,
+  threadId,
+  text,
+  afterUserMessageIncludes,
+  timeout,
+}: {
+  discord: DigitalDiscord
+  threadId: string
+  text: string
+  afterUserMessageIncludes?: string
+  timeout: number
+}) {
+  const start = Date.now()
+  let lastMessages: APIMessage[] = []
+  while (Date.now() - start < timeout) {
+    const messages = await discord.thread(threadId).getMessages()
+    lastMessages = messages
+    const afterIndex = afterUserMessageIncludes
+      ? messages.findIndex((message) => {
+          return (
+            message.author.id === TEST_USER_ID &&
+            message.content.includes(afterUserMessageIncludes)
+          )
+        })
+      : -1
+    const match = messages.find((message, index) => {
+      if (afterUserMessageIncludes && afterIndex >= 0 && index <= afterIndex) {
+        return false
+      }
+      return (
+        message.author.id === discord.botUserId &&
+        message.content.includes(text)
+      )
+    })
+    if (match) {
+      return messages
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 500)
+    })
+  }
+  const recent = lastMessages
+    .slice(-12)
+    .map((message) => {
+      const role = message.author.id === discord.botUserId ? 'bot' : 'user'
+      return `${role}: ${message.content.slice(0, 120)}`
+    })
+    .join('\n')
+  throw new Error(
+    `Timed out waiting for bot message containing "${text}" in thread ${threadId}. Recent messages:\n${recent}`,
+  )
+}
+
+const TEST_USER_ID = '200000000000000777'
+const TEXT_CHANNEL_ID = '200000000000000778'
+
+e2eTest('thread message queue ordering', () => {
+  let directories: ReturnType<typeof createRunDirectories>
+  let discord: DigitalDiscord
+  let botClient: Client
+  let previousDefaultVerbosity: ReturnType<typeof getDefaultVerbosity> | null =
+    null
+
+  beforeAll(async () => {
+    directories = createRunDirectories()
+    const lockPort = chooseLockPort()
+
+    process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
+    setDataDir(directories.dataDir)
+    previousDefaultVerbosity = getDefaultVerbosity()
+    setDefaultVerbosity('tools-and-text')
+
+    discord = new DigitalDiscord({
+      guild: {
+        name: 'Queue E2E Guild',
+        ownerId: TEST_USER_ID,
+      },
+      channels: [
+        {
+          id: TEXT_CHANNEL_ID,
+          name: 'queue-e2e',
+          type: ChannelType.GuildText,
+        },
+      ],
+      users: [
+        {
+          id: TEST_USER_ID,
+          username: 'queue-tester',
+        },
+      ],
+    })
+
+    await discord.start()
+
+    const providerNpm = url
+      .pathToFileURL(
+        path.resolve(
+          process.cwd(),
+          '..',
+          'opencode-deterministic-provider',
+          'src',
+          'index.ts',
+        ),
+      )
+      .toString()
+
+    const opencodeConfig = buildDeterministicOpencodeConfig({
+      providerName: 'deterministic-provider',
+      providerNpm,
+      model: 'deterministic-v2',
+      smallModel: 'deterministic-v2',
+      settings: {
+        strict: false,
+        matchers: createDeterministicMatchers(),
+      },
+    })
+    fs.writeFileSync(
+      path.join(directories.projectDirectory, 'opencode.json'),
+      JSON.stringify(opencodeConfig, null, 2),
+    )
+
+    const dbPath = path.join(directories.dataDir, 'discord-sessions.db')
+    const hranaResult = await startHranaServer({ dbPath })
+    if (hranaResult instanceof Error) {
+      throw hranaResult
+    }
+    process.env['KIMAKI_DB_URL'] = hranaResult
+    await initDatabase()
+    await setBotToken(discord.botUserId, discord.botToken)
+
+    await setChannelDirectory({
+      channelId: TEXT_CHANNEL_ID,
+      directory: directories.projectDirectory,
+      channelType: 'text',
+      appId: discord.botUserId,
+    })
+    await setChannelVerbosity(TEXT_CHANNEL_ID, 'tools-and-text')
+    const channelVerbosity = await getChannelVerbosity(TEXT_CHANNEL_ID)
+    expect(channelVerbosity).toBe('tools-and-text')
+
+    botClient = createDiscordJsClient({ restUrl: discord.restUrl })
+    await startDiscordBot({
+      token: discord.botToken,
+      appId: discord.botUserId,
+      discordClient: botClient,
+    })
+  }, 60_000)
+
+  afterAll(async () => {
+    if (botClient) {
+      botClient.destroy()
+    }
+
+    await cleanupOpencodeServers()
+    await Promise.all([
+      closeDatabase().catch(() => {
+        return
+      }),
+      stopHranaServer().catch(() => {
+        return
+      }),
+      discord?.stop().catch(() => {
+        return
+      }),
+    ])
+
+    delete process.env['KIMAKI_LOCK_PORT']
+    delete process.env['KIMAKI_DB_URL']
+    if (previousDefaultVerbosity) {
+      setDefaultVerbosity(previousDefaultVerbosity)
+    }
+    if (directories) {
+      fs.rmSync(directories.dataDir, { recursive: true, force: true })
+    }
+  }, 30_000)
+
+  test(
+    'text message during active session gets processed',
+    async () => {
+      // 1. Send initial message to text channel → thread created + session established
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: alpha',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 60_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: alpha'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+
+      // Wait for the first bot reply so session is fully established in DB
+      const firstReply = await th.waitForBotReply({
+        timeout: 120_000,
+      })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      // Snapshot bot message count before sending follow-up
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === discord.botUserId
+      }).length
+
+      // 2. Send follow-up message B into the thread — goes through threadMessageQueue
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: beta',
+      })
+
+      // 3. Wait for exactly 1 new bot message (the response to B)
+      const after = await waitForBotMessageCount({
+        discord,
+        threadId: thread.id,
+        count: beforeBotCount + 1,
+        timeout: 120_000,
+      })
+
+      // 4. Verify at least 1 new bot message appeared for the follow-up.
+      //    The bot may send additional messages per session (error reactions,
+      //    session notifications) so we check >= not exact equality.
+      const afterBotMessages = after.filter((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1)
+
+      // User B's message must appear before the new bot response
+      const userBIndex = after.findIndex((m) => {
+        return (
+          m.author.id === TEST_USER_ID &&
+          m.content.includes('beta')
+        )
+      })
+      const lastBotIndex = after.findLastIndex((m) => {
+        return m.author.id === discord.botUserId
+      })
+
+      expect(userBIndex).toBeGreaterThan(-1)
+      expect(lastBotIndex).toBeGreaterThan(-1)
+      expect(userBIndex).toBeLessThan(lastBotIndex)
+
+      // New bot response has non-empty content
+      const newBotReply = afterBotMessages[afterBotMessages.length - 1]!
+      expect(newBotReply.content.trim().length).toBeGreaterThan(0)
+    },
+    360_000,
+  )
+
+  test(
+    'two rapid text messages in thread — both processed in order',
+    async () => {
+      // 1. Send initial message to text channel → thread + session established
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: one',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 60_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: one'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+
+      // Wait for the first bot reply so session is established
+      const firstReply = await th.waitForBotReply({
+        timeout: 120_000,
+      })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      // Snapshot bot message count before sending follow-ups
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === discord.botUserId
+      }).length
+
+      // 2. Rapidly send messages B and C — both go through threadMessageQueue
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: two',
+      })
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: three',
+      })
+
+      // 3. Wait for exactly 2 new bot messages (one per follow-up)
+      const after = await waitForBotMessageCount({
+        discord,
+        threadId: thread.id,
+        count: beforeBotCount + 2,
+        timeout: 120_000,
+      })
+
+      // 4. Verify at least 2 new bot messages appeared (one per follow-up).
+      //    The bot may send additional messages per session (error reactions,
+      //    session notifications) so we check >= not exact equality.
+      const afterBotMessages = after.filter((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 2)
+
+      // Each new bot message has non-empty content
+      const newBotReplies = afterBotMessages.slice(beforeBotCount)
+      for (const reply of newBotReplies) {
+        expect(reply.content.trim().length).toBeGreaterThan(0)
+      }
+
+      // 5. Verify per-follow-up causality: user B appears before 2nd bot
+      //    message, user C appears before 3rd bot message
+      const botIndices = after.reduce<number[]>((acc, m, i) => {
+        if (m.author.id === discord.botUserId) {
+          acc.push(i)
+        }
+        return acc
+      }, [])
+
+      const userTwoIndex = after.findIndex((m) => {
+        return (
+          m.author.id === TEST_USER_ID &&
+          m.content.includes('two')
+        )
+      })
+      const userThreeIndex = after.findIndex((m) => {
+        return (
+          m.author.id === TEST_USER_ID &&
+          m.content.includes('three')
+        )
+      })
+
+      expect(userTwoIndex).toBeGreaterThan(-1)
+      expect(userThreeIndex).toBeGreaterThan(-1)
+
+      // Bot responses for B and C are the last 2 bot messages
+      const botForB = botIndices[botIndices.length - 2]!
+      const botForC = botIndices[botIndices.length - 1]!
+
+      // Each user message appears before its corresponding bot response
+      expect(userTwoIndex).toBeLessThan(botForB)
+      expect(userThreeIndex).toBeLessThan(botForC)
+
+      // Bot response for B appears before bot response for C (queue order)
+      expect(botForB).toBeLessThan(botForC)
+    },
+    360_000,
+  )
+
+  test(
+    'queued message aborts running session immediately',
+    async () => {
+      // When a new message queues behind a running session,
+      // signalThreadInterrupt aborts the in-flight session immediately,
+      // then the queue processes the next message.
+      //
+      // 1. Fast setup: establish session
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: delta',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 60_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: delta'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+      const firstReply = await th.waitForBotReply({ timeout: 120_000 })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === discord.botUserId
+      }).length
+
+      // 2. Send B, then quickly send C to trigger the interrupt.
+      //    200ms gap gives B time to enter the queue and start processing.
+      //    signalThreadInterrupt aborts B immediately so C can run.
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: echo',
+      })
+      await new Promise((r) => {
+        setTimeout(r, 200)
+      })
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: foxtrot',
+      })
+
+      // 3. Poll until foxtrot's user message has a bot reply after it.
+      //    waitForBotMessageCount alone isn't enough — error messages from the
+      //    interrupted session can satisfy the count before foxtrot gets its reply.
+      const after = await waitForBotReplyAfterUserMessage({
+        discord,
+        threadId: thread.id,
+        userMessageIncludes: 'foxtrot',
+        timeout: 120_000,
+      })
+
+      // 4. Both B and C got bot responses
+      const afterBotMessages = after.filter((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 2)
+
+      const userEchoIndex = after.findIndex((m) => {
+        return m.author.id === TEST_USER_ID && m.content.includes('echo')
+      })
+      const userFoxtrotIndex = after.findIndex((m) => {
+        return m.author.id === TEST_USER_ID && m.content.includes('foxtrot')
+      })
+      expect(userEchoIndex).toBeGreaterThan(-1)
+      expect(userFoxtrotIndex).toBeGreaterThan(-1)
+
+      // Foxtrot's bot reply appears after the foxtrot user message
+      const botAfterFoxtrot = after.findIndex((m, i) => {
+        return i > userFoxtrotIndex && m.author.id === discord.botUserId
+      })
+      expect(botAfterFoxtrot).toBeGreaterThan(userFoxtrotIndex)
+    },
+    360_000,
+  )
+
+  test(
+    'slow stream still gets interrupted when no step-finish arrives',
+    async () => {
+      // With immediate abort, a queued message interrupts even while the previous
+      // request is mid-stream and has not reached a step-finish event.
+
+      // 1. Fast setup: establish session
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: golf',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 60_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: golf'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+      const firstReply = await th.waitForBotReply({ timeout: 120_000 })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === discord.botUserId
+      }).length
+
+      // 2. Start request B, then send C while B is still in progress.
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: hotel',
+      })
+
+      // 3. Wait briefly for B to start, then send C to trigger immediate abort
+      await new Promise((r) => {
+        setTimeout(r, 500)
+      })
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: india',
+      })
+
+      // 4. B is aborted and C gets processed.
+      //    Poll until india's user message has a bot reply after it.
+      const after = await waitForBotReplyAfterUserMessage({
+        discord,
+        threadId: thread.id,
+        userMessageIncludes: 'india',
+        timeout: 120_000,
+      })
+
+      // C's user message appears before its bot response.
+      // The interrupted hotel session may or may not produce a visible bot message
+      // (depends on timing), so we only assert on india's reply existence.
+      const userIndiaIndex = after.findIndex((m) => {
+        return m.author.id === TEST_USER_ID && m.content.includes('india')
+      })
+      expect(userIndiaIndex).toBeGreaterThan(-1)
+      const botAfterIndia = after.findIndex((m, i) => {
+        return i > userIndiaIndex && m.author.id === discord.botUserId
+      })
+      expect(botAfterIndia).toBeGreaterThan(userIndiaIndex)
+    },
+    360_000,
+  )
+
+  test(
+    'queue drains correctly after interrupted session',
+    async () => {
+      // Verifies the queue doesn't get stuck after multiple interrupts.
+      // Rapidly sends B, C, D — each interrupts the previous. Then after all
+      // complete, sends E to prove the queue is clean and accepting new work.
+
+      // 1. Fast setup: establish session
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: juliet',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 60_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: juliet'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+      const firstReply = await th.waitForBotReply({ timeout: 120_000 })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === discord.botUserId
+      }).length
+
+      // 2. Rapidly send B, C, D — each queues behind the previous and triggers interrupt
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: kilo',
+      })
+      await new Promise((r) => {
+        setTimeout(r, 300)
+      })
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: lima',
+      })
+      await new Promise((r) => {
+        setTimeout(r, 300)
+      })
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: mike',
+      })
+
+      // 3. Wait until the last burst message (mike) has a bot reply after it.
+      const afterBurst = await waitForBotReplyAfterUserMessage({
+        discord,
+        threadId: thread.id,
+        userMessageIncludes: 'mike',
+        timeout: 120_000,
+      })
+
+      const burstBotMessages = afterBurst.filter((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(burstBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1)
+
+      // 4. Queue should be clean — send E and verify it also gets processed
+      const burstBotCount = burstBotMessages.length
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: november',
+      })
+
+      const afterE = await waitForBotReplyAfterUserMessage({
+        discord,
+        threadId: thread.id,
+        userMessageIncludes: 'november',
+        timeout: 120_000,
+      })
+
+      const finalBotMessages = afterE.filter((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(finalBotMessages.length).toBeGreaterThanOrEqual(burstBotCount)
+
+      // E's user message appears before the final bot response
+      const userNovemberIndex = afterE.findIndex((m) => {
+        return m.author.id === TEST_USER_ID && m.content.includes('november')
+      })
+      expect(userNovemberIndex).toBeGreaterThan(-1)
+      const lastBotIndex = afterE.findLastIndex((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(userNovemberIndex).toBeLessThan(lastBotIndex)
+    },
+    360_000,
+  )
+
+  test(
+    'slow tool call (sleep) gets aborted when new message queues',
+    async () => {
+      // Tests that long-running tool calls get properly aborted when a new
+      // message queues behind them. During tool execution no step-finish events
+      // arrive, but interrupt should still abort immediately so the queue can
+      // process the next message normally.
+
+      // 1. Fast setup: establish session
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: oscar',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 60_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: oscar'
+        },
+      })
+
+      const th = discord.thread(thread.id)
+      const firstReply = await th.waitForBotReply({ timeout: 120_000 })
+      expect(firstReply.content.trim().length).toBeGreaterThan(0)
+
+      const before = await th.getMessages()
+      const beforeBotCount = before.filter((m) => {
+        return m.author.id === discord.botUserId
+      }).length
+
+      // 2. Ask the model to run a long sleep command
+      await th.user(TEST_USER_ID).sendMessage({
+        content:
+          'MANDATORY INSTRUCTION: call the bash tool immediately and run exactly this command: `sleep 500`. No explanation. No normal text. Do not skip the tool call.',
+      })
+
+      // 3. Wait until we see the bash tool message for sleep, proving the tool
+      //    call actually started before the interrupt message is sent.
+      await waitForBotMessageContaining({
+        discord,
+        threadId: thread.id,
+        text: 'sleep 500',
+        afterUserMessageIncludes: 'sleep 500',
+        timeout: 30_000,
+      })
+
+      // 4. Send interrupt message while sleep is still running
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: papa',
+      })
+
+      // 5. The interrupt aborts the sleep session, and the queue processes "papa".
+      const after = await waitForBotReplyAfterUserMessage({
+        discord,
+        threadId: thread.id,
+        userMessageIncludes: 'papa',
+        timeout: 120_000,
+      })
+
+      const afterBotMessages = after.filter((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1)
+
+      // Ensure sleep tool output appeared before the interrupt message.
+      const sleepToolIndex = after.findIndex((m) => {
+        return m.author.id === discord.botUserId && m.content.includes('sleep 500')
+      })
+      expect(sleepToolIndex).toBeGreaterThan(-1)
+
+      // "papa" user message appears before the last bot response
+      const userPapaIndex = after.findIndex((m) => {
+        return m.author.id === TEST_USER_ID && m.content.includes('papa')
+      })
+      expect(userPapaIndex).toBeGreaterThan(-1)
+      expect(sleepToolIndex).toBeLessThan(userPapaIndex)
+      const lastBotIndex = after.findLastIndex((m) => {
+        return m.author.id === discord.botUserId
+      })
+      expect(userPapaIndex).toBeLessThan(lastBotIndex)
+    },
+    360_000,
+  )
+
+  async function runInterruptRaceScenario(runIndex: number) {
+    // Reproduces the stale-idle timing window reported in production:
+    // 1) an active stream is interrupted by a new message,
+    // 2) late events from the interrupted stream arrive,
+    // 3) the new prompt must still produce assistant text.
+    const setupPrompt = `Reply with exactly: race-setup-${runIndex}`
+    const raceFinalPrompt = `Reply with exactly: race-final-${runIndex}`
+
+    await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+      content: setupPrompt,
+    })
+
+    const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+      timeout: 60_000,
+      predicate: (t) => {
+        return t.name === setupPrompt
+      },
+    })
+
+    const th = discord.thread(thread.id)
+    const setupReply = await th.waitForBotReply({ timeout: 120_000 })
+    expect(setupReply.content.trim().length).toBeGreaterThan(0)
+
+    await th.user(TEST_USER_ID).sendMessage({
+      content:
+        'MANDATORY INSTRUCTION: call the bash tool immediately and run exactly this command: `sleep 500`. No explanation. No normal text. Do not skip the tool call.',
+    })
+
+    await waitForBotMessageContaining({
+      discord,
+      threadId: thread.id,
+      text: 'sleep 500',
+      afterUserMessageIncludes: 'sleep 500',
+      timeout: 30_000,
+    })
+
+    await th.user(TEST_USER_ID).sendMessage({
+      content: raceFinalPrompt,
+    })
+
+    await waitForBotMessageContaining({
+      discord,
+      threadId: thread.id,
+      text: 'race-final',
+      afterUserMessageIncludes: raceFinalPrompt,
+      timeout: 30_000,
+    })
+  }
+
+  test(
+    'interrupt race: queued message still gets assistant text after stale idle window',
+    async () => {
+      await runInterruptRaceScenario(1)
+    },
+    360_000,
+  )
+})