kimaki 0.31.0 → 1.1.0

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

@@ -1,1468 +0,0 @@
-// E2e tests for basic per-thread message queue ordering.
-// Advanced interrupt/abort/retry tests are in thread-queue-advanced.e2e.test.ts.
-//
-// Uses opencode-deterministic-provider which returns canned responses instantly
-// (no real LLM calls), so poll timeouts can be aggressive (4s). The only real
-// latency is OpenCode server startup (beforeAll) and intentional partDelaysMs
-// in matchers (100ms for user-reply).
-//
-// If total duration of a file exceeds ~10s, split into a new test file
-// so vitest can parallelize across files.
-
-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 { DigitalDiscord } from 'discord-digital-twin/src'
-import {
-  buildDeterministicOpencodeConfig,
-  type DeterministicMatcher,
-} from 'opencode-deterministic-provider'
-import {
-  setDataDir,
-} from './config.js'
-import { store } from './store.js'
-import { startDiscordBot } from './discord-bot.js'
-import {
-  setBotToken,
-  initDatabase,
-  closeDatabase,
-  setChannelDirectory,
-  setChannelVerbosity,
-  getChannelVerbosity,
-  type VerbosityLevel,
-} from './database.js'
-import { startHranaServer, stopHranaServer } from './hrana-server.js'
-import { initializeOpencodeForDirectory, stopOpencodeServer } from './opencode.js'
-import {
-  chooseLockPort,
-  cleanupTestSessions,
-  initTestGitRepo,
-  waitForFooterMessage,
-  waitForBotMessageContaining,
-  waitForMessageById,
-  waitForBotMessageCount,
-  waitForBotReplyAfterUserMessage,
-  waitForBotReplyTo,
-  waitForThreadState,
-  getMessageVisibleText,
-} from './test-utils.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 })
-  initTestGitRepo(projectDirectory)
-
-  return { root, dataDir, projectDirectory }
-}
-
-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',
-    },
-  })
-}
-
-function createDeterministicMatchers() {
-  const bashCreateFileMatcher: DeterministicMatcher = {
-    id: 'bash-create-file',
-    priority: 130,
-    when: {
-      lastMessageRole: 'user',
-      rawPromptIncludes: 'BASH_TOOL_FILE_MARKER',
-    },
-    then: {
-      parts: [
-        { type: 'stream-start', warnings: [] },
-        { type: 'text-start', id: 'bash-create-file' },
-        {
-          type: 'text-delta',
-          id: 'bash-create-file',
-          delta: 'running create file',
-        },
-        { type: 'text-end', id: 'bash-create-file' },
-        { type: 'text-start', id: 'bash-create-file-status' },
-        {
-          type: 'text-delta',
-          id: 'bash-create-file-status',
-          delta: 'creating marker',
-        },
-        { type: 'text-end', id: 'bash-create-file-status' },
-        {
-          type: 'tool-call',
-          toolCallId: 'bash-create-file-call',
-          toolName: 'bash',
-          input: JSON.stringify({
-            command: 'mkdir -p tmp && printf "created" > tmp/bash-tool-executed.txt',
-            description: 'Create marker file for e2e test',
-            hasSideEffect: true,
-          }),
-        },
-        {
-          type: 'finish',
-          finishReason: 'tool-calls',
-          usage: {
-            inputTokens: 1,
-            outputTokens: 1,
-            totalTokens: 2,
-          },
-        },
-      ],
-    },
-  }
-
-  const bashCreateFileFollowupMatcher: DeterministicMatcher = {
-    id: 'bash-create-file-followup',
-    priority: 120,
-    when: {
-      lastMessageRole: 'tool',
-      rawPromptIncludes: 'BASH_TOOL_FILE_MARKER',
-    },
-    then: {
-      parts: [
-        { type: 'stream-start', warnings: [] },
-        { type: 'text-start', id: 'bash-create-file-followup' },
-        {
-          type: 'text-delta',
-          id: 'bash-create-file-followup',
-          delta: 'file created',
-        },
-        { type: 'text-end', id: 'bash-create-file-followup' },
-        {
-          type: 'finish',
-          finishReason: 'stop',
-          usage: {
-            inputTokens: 1,
-            outputTokens: 1,
-            totalTokens: 2,
-          },
-        },
-      ],
-    },
-  }
-
-  const raceFinalReplyMatcher: DeterministicMatcher = {
-    id: 'race-final-reply',
-    priority: 110,
-    when: {
-      latestUserTextIncludes: '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 stale-idle window. The race happens
-      // in <1ms; 500ms is plenty to keep the window reliably open.
-      partDelaysMs: [0, 500, 0, 0, 0],
-    },
-  }
-
-  // Slow matcher for "hotel" so the 200ms sleep in the queueing test
-  // guarantees "india" arrives while hotel is still streaming.
-  const hotelSlowMatcher: DeterministicMatcher = {
-    id: 'hotel-slow-reply',
-    priority: 20,
-    when: {
-      latestUserTextIncludes: 'Reply with exactly: hotel',
-    },
-    then: {
-      parts: [
-        { type: 'stream-start', warnings: [] },
-        { type: 'text-start', id: 'hotel-reply' },
-        { type: 'text-delta', id: 'hotel-reply', delta: 'ok' },
-        { type: 'text-end', id: 'hotel-reply' },
-        {
-          type: 'finish',
-          finishReason: 'stop',
-          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-        },
-      ],
-      partDelaysMs: [0, 100, 300, 0, 0],
-    },
-  }
-
-  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, 100, 0, 0, 0],
-    },
-  }
-
-  // Matcher that keeps the session busy for 2s after the first text part.
-  // Used by queue-edit tests to ensure the follow-up message lands in the
-  // local queue before the session finishes.
-  const slowBusyMatcher: DeterministicMatcher = {
-    id: 'slow-busy-reply',
-    priority: 115,
-    when: {
-      latestUserTextIncludes: 'SLOW_BUSY_MARKER',
-    },
-    then: {
-      parts: [
-        { type: 'stream-start', warnings: [] },
-        { type: 'text-start', id: 'slow-busy' },
-        { type: 'text-delta', id: 'slow-busy', delta: 'slow-busy-reply' },
-        { type: 'text-end', id: 'slow-busy' },
-        {
-          type: 'finish',
-          finishReason: 'stop',
-          usage: { inputTokens: 1, outputTokens: 1, totalTokens: 2 },
-        },
-      ],
-      partDelaysMs: [0, 100, 0, 0, 2_000],
-    },
-  }
-
-  return [
-    bashCreateFileMatcher,
-    bashCreateFileFollowupMatcher,
-    raceFinalReplyMatcher,
-    slowBusyMatcher,
-    hotelSlowMatcher,
-    userReplyMatcher,
-  ]
-}
-
-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: VerbosityLevel | null =
-    null
-  let testStartTime = Date.now()
-
-  beforeAll(async () => {
-    testStartTime = Date.now()
-    directories = createRunDirectories()
-    const lockPort = chooseLockPort({ key: TEXT_CHANNEL_ID })
-
-    process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
-    setDataDir(directories.dataDir)
-    previousDefaultVerbosity = store.getState().defaultVerbosity
-    store.setState({ defaultVerbosity: 'tools_and_text' })
-
-    const digitalDiscordDbPath = path.join(
-      directories.dataDir,
-      'digital-discord.db',
-    )
-
-    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',
-        },
-      ],
-      dbUrl: `file:${digitalDiscordDbPath}`,
-    })
-
-    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',
-    })
-    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,
-    })
-
-    // Pre-warm the opencode server so the first test doesn't include
-    // server startup time (~3-4s) inside its 4s poll timeouts.
-    const warmup = await initializeOpencodeForDirectory(
-      directories.projectDirectory,
-    )
-    if (warmup instanceof Error) {
-      throw warmup
-    }
-  }, 60_000)
-
-  afterAll(async () => {
-    if (directories) {
-      await cleanupTestSessions({
-        projectDirectory: directories.projectDirectory,
-        testStartTime,
-      })
-    }
-
-    if (botClient) {
-      void botClient.destroy()
-    }
-
-    await stopOpencodeServer()
-    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) {
-      store.setState({ defaultVerbosity: previousDefaultVerbosity })
-    }
-    if (directories) {
-      fs.rmSync(directories.dataDir, { recursive: true, force: true })
-    }
-  }, 20_000)
-
-  test(
-    'first prompt after cold opencode server start still streams text parts',
-    async () => {
-      // Reproduce cold-start path: clear in-memory server/client registry so
-      // runtime startEventListener() runs once before initialize and exits with
-      // "No OpenCode client". The first prompt must still show text parts.
-      await stopOpencodeServer()
-
-      const prompt = 'Reply with exactly: cold-start-stream'
-
-      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: prompt,
-      })
-
-      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 4_000,
-        predicate: (t) => {
-          return t.name === prompt
-        },
-      })
-
-      await waitForBotMessageContaining({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        text: 'ok',
-        timeout: 10_000,
-      })
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 4_000,
-      })
-
-      expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: cold-start-stream
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-    },
-    12_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: 4_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: 4_000,
-      })
-      expect(getMessageVisibleText(firstReply).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 — serialized by runtime's enqueueIncoming
-      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: 4_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)
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageIncludes: 'beta',
-        afterAuthorId: TEST_USER_ID,
-      })
-
-      const timeline = await th.text()
-      expect(timeline).toContain('Reply with exactly: alpha')
-      expect(timeline).toContain('Reply with exactly: beta')
-      expect(timeline).toContain('ok')
-      expect(timeline).toContain('*project ⋅ main ⋅')
-      // 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(getMessageVisibleText(newBotReply).trim().length).toBeGreaterThan(0)
-    },
-    12_000,
-  )
-
-  test('btw queue forks after the current turn and includes its answer', async () => {
-    const start = 'Reply with exactly: SLOW_BUSY_MARKER queued-fork-source'
-    await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({ content: start })
-    const source = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-      timeout: 4_000,
-      predicate: (thread) => thread.name === start,
-    })
-    const th = discord.thread(source.id)
-    await waitForBotMessageContaining({
-      discord, threadId: source.id, userId: TEST_USER_ID,
-      text: 'slow-busy-reply', timeout: 10_000,
-    })
-    await th.user(TEST_USER_ID).sendMessage({
-      content: 'Reply with exactly: earlier-queue. queue',
-    })
-    await th.user(TEST_USER_ID).sendMessage({
-      content: 'Reply with exactly: queued-fork-answer. btw queue',
-    })
-
-    const before = await th.text()
-    expect(before).not.toContain('Session forked!')
-
-    const fork = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-      timeout: 8_000,
-      predicate: (thread) => thread.id !== source.id && (thread.name?.startsWith('btw:') ?? false),
-    })
-    await waitForBotMessageContaining({
-      discord, threadId: fork.id, userId: TEST_USER_ID,
-      text: 'ok', timeout: 8_000,
-    })
-    await waitForFooterMessage({ discord, threadId: fork.id, timeout: 8_000 })
-    await waitForBotMessageContaining({
-      discord, threadId: source.id, userId: TEST_USER_ID,
-      text: 'Session forked!', timeout: 8_000,
-    })
-    const sourceText = await th.text()
-    expect(sourceText.replace(/<#[0-9]+>/g, '<#FORK_THREAD>')).toMatchInlineSnapshot(`
-      "--- from: user (queue-tester)
-      Reply with exactly: SLOW_BUSY_MARKER queued-fork-source
-      --- from: assistant (TestBot)
-      -# *using deterministic-provider/deterministic-v2*
-      slow-busy-reply
-      --- from: user (queue-tester)
-      Reply with exactly: earlier-queue. queue
-      Reply with exactly: queued-fork-answer. btw queue
-      --- from: assistant (TestBot)
-      -# Queued at position 1. Edit or delete your message to update the queue
-      -# Queued at position 2. Edit or delete your message to update the queue
-      -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-      -# Executing queued prompt
-      ok
-      -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-      -# Executing queued prompt
-      Session forked! Continue in <#FORK_THREAD>"
-    `)
-    expect(sourceText.indexOf('*project ⋅ main ⋅')).toBeLessThan(sourceText.indexOf('Session forked!'))
-    expect(sourceText.indexOf('earlier-queue')).toBeLessThan(sourceText.indexOf('Session forked!'))
-    expect((await discord.thread(fork.id).text()).replace(/<#[0-9]+>/g, '<#SOURCE_THREAD>')).toMatchInlineSnapshot(`
-      "--- from: assistant (TestBot)
-      Reusing context from <#SOURCE_THREAD> to answer prompt...
-      Reply with exactly: queued-fork-answer
-      ok
-      -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-    `)
-
-    await discord.thread(fork.id).user(TEST_USER_ID).runSlashCommand({
-      name: 'queue',
-      options: [{ name: 'message', type: 3, value: 'Reply with exactly: nested-fork. btw' }],
-    })
-    const nested = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-      timeout: 8_000,
-      predicate: (thread) => thread.id !== source.id && thread.id !== fork.id && (thread.name?.startsWith('btw:') ?? false),
-    })
-    await waitForBotMessageContaining({
-      discord, threadId: nested.id, userId: TEST_USER_ID,
-      text: 'ok', timeout: 8_000,
-    })
-    await waitForFooterMessage({ discord, threadId: nested.id, timeout: 8_000 })
-    expect((await discord.thread(nested.id).text()).replace(/<#[0-9]+>/g, '<#SOURCE_THREAD>')).toMatchInlineSnapshot(`
-      "--- from: assistant (TestBot)
-      Reusing context from <#SOURCE_THREAD> to answer prompt...
-      Reply with exactly: nested-fork
-      ok
-      -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-    `)
-  }, 16_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: 4_000,
-        predicate: (t) => {
-          return t.name === 'Reply with exactly: one'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-
-      // Wait for the first bot reply AND its footer so the first response
-      // cycle is fully complete before sending follow-ups. Without this,
-      // the footer for "one" can still be in-flight when the snapshot runs.
-      const firstReply = await th.waitForBotReply({
-        timeout: 4_000,
-      })
-      expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0)
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 4_000,
-        afterMessageIncludes: 'one',
-        afterAuthorId: TEST_USER_ID,
-      })
-
-      // 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. With opencode queue mode,
-      // both messages are serialized by opencode's per-session loop.
-      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 a bot reply after message C.
-      const after = await waitForBotReplyAfterUserMessage({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        userMessageIncludes: 'three',
-        timeout: 4_000,
-      })
-
-      // 4. Verify the latest user message got a bot reply.
-      const afterBotMessages = after.filter((m) => {
-        return m.author.id === discord.botUserId
-      })
-      expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1)
-
-      expect((await th.text()).replace(/\nok(?=\nok)/g, '')).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: one
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (queue-tester)
-        Reply with exactly: two
-        Reply with exactly: three
-        --- from: assistant (TestBot)
-        ok"
-      `)
-      const userThreeIndex = after.findIndex((message) => {
-        return (
-          message.author.id === TEST_USER_ID &&
-          message.content.includes('three')
-        )
-      })
-      expect(userThreeIndex).toBeGreaterThan(-1)
-
-      const botAfterThreeIndex = after.findIndex((message, index) => {
-        return index > userThreeIndex && message.author.id === discord.botUserId
-      })
-      expect(botAfterThreeIndex).toBeGreaterThan(userThreeIndex)
-
-      const newBotReplies = afterBotMessages.slice(beforeBotCount)
-      expect(newBotReplies.some((reply) => {
-        return getMessageVisibleText(reply).trim().length > 0
-      })).toBe(true)
-
-      const finalState = await waitForThreadState({
-        threadId: thread.id,
-        predicate: (state) => {
-          return state.queueItems.length === 0
-        },
-        timeout: 4_000,
-        description: 'queue empty after rapid interrupts',
-      })
-      expect(finalState.queueItems.length).toBe(0)
-    },
-    8_000,
-  )
-
-  test(
-    'bash tool-call actually executes and creates file in project directory',
-    async () => {
-      const markerRelativePath = path.join('tmp', 'bash-tool-executed.txt')
-      const markerPath = path.join(directories.projectDirectory, markerRelativePath)
-      fs.rmSync(markerPath, { force: true })
-      const existingThreadIds = new Set(
-        (await discord.channel(TEXT_CHANNEL_ID).getThreads()).map((thread) => {
-          return thread.id
-        }),
-      )
-
-      const prompt = 'Reply with exactly: BASH_TOOL_FILE_MARKER'
-      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: prompt,
-      })
-
-      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 6_000,
-        predicate: (t) => {
-          return !existingThreadIds.has(t.id)
-        },
-      })
-
-      await waitForBotMessageContaining({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        text: 'running create file',
-        timeout: 6_000,
-      })
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 6_000,
-      })
-
-      const deadline = Date.now() + 4_000
-      while (!fs.existsSync(markerPath) && Date.now() < deadline) {
-        await new Promise((resolve) => {
-          setTimeout(resolve, 100)
-        })
-      }
-
-      expect(await discord.thread(thread.id).text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: BASH_TOOL_FILE_MARKER
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        > running create file
-        > creating marker
-
-        -# ┣ bash _Create marker file for e2e test_
-
-        file created
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-      expect(fs.existsSync(markerPath)).toBe(true)
-      const markerContents = fs.readFileSync(markerPath, 'utf8')
-      expect(markerContents).toBe('created')
-    },
-    8_000,
-  )
-
-  test(
-    '/queue shows queued status first, then dispatch indicator when dequeued',
-    async () => {
-      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: queue-slash-setup',
-      })
-
-      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 4_000,
-        predicate: (t) => {
-          return t.name === 'Reply with exactly: queue-slash-setup'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-      const firstReply = await th.waitForBotReply({ timeout: 4_000 })
-      expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0)
-
-      // Ensure the setup run is fully settled before slash-queue checks.
-      // Otherwise the first /queue call can race with a still-busy run window.
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 4_000,
-      })
-
-      // Start a non-interrupting queued slash message while idle so it
-      // dispatches immediately and keeps the runtime active.
-      const { id: firstQueueInteractionId } = await th.user(TEST_USER_ID)
-        .runSlashCommand({
-          name: 'queue',
-          options: [{ name: 'message', type: 3, value: 'Reply with exactly: race-final' }],
-        })
-
-      const firstQueueAck = await th.waitForInteractionAck({
-        interactionId: firstQueueInteractionId,
-        timeout: 4_000,
-      })
-      if (!firstQueueAck.messageId) {
-        throw new Error('Expected first /queue response message id')
-      }
-
-      const firstQueueAckMessage = await waitForMessageById({
-        discord,
-        threadId: thread.id,
-        messageId: firstQueueAck.messageId,
-        timeout: 4_000,
-      })
-      expect(firstQueueAckMessage.content).toContain('» **queue-tester:** Reply with exactly: race-final')
-
-      const queuedPrompt = 'Reply with exactly: queued-from-slash'
-      const { id: interactionId } = await th.user(TEST_USER_ID).runSlashCommand({
-        name: 'queue',
-        options: [{ name: 'message', type: 3, value: queuedPrompt }],
-      })
-
-      const queuedAck = await th.waitForInteractionAck({ interactionId, timeout: 4_000 })
-      if (!queuedAck.messageId) {
-        throw new Error('Expected queued /queue response message id')
-      }
-
-      const queuedStatusMessage = await waitForMessageById({
-        discord,
-        threadId: thread.id,
-        messageId: queuedAck.messageId,
-        timeout: 4_000,
-      })
-      expect(queuedStatusMessage.content.startsWith('-# Queued message')).toBe(true)
-
-      // The drain indicator is a silent reply to the /queue ack.
-      const dispatchIndicatorMessage = await waitForBotReplyTo({
-        discord,
-        threadId: thread.id,
-        replyToMessageId: queuedStatusMessage.id,
-        timeout: 8_000,
-      })
-      expect(dispatchIndicatorMessage.content).toBe('-# Executing queued prompt')
-
-      await waitForBotMessageContaining({
-        discord,
-        threadId: thread.id,
-        text: 'ok',
-        afterMessageId: dispatchIndicatorMessage.id,
-        timeout: 8_000,
-      })
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageIncludes: 'ok',
-        afterAuthorId: discord.botUserId,
-      })
-
-      expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: queue-slash-setup
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        » **queue-tester:** Reply with exactly: race-final
-        -# Queued message (position 2)
-        race-final
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        -# Executing queued prompt
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-    },
-    12_000,
-  )
-
-  test(
-    'Remove from queue button clears only that queued message',
-    async () => {
-      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: clear-queue-setup',
-      })
-
-      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 4_000,
-        predicate: (t) => {
-          return t.name === 'Reply with exactly: clear-queue-setup'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-      await th.waitForBotReply({ timeout: 4_000 })
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 4_000,
-      })
-
-      await th.user(TEST_USER_ID).runSlashCommand({
-        name: 'queue',
-        options: [{ name: 'message', type: 3, value: 'Reply with exactly: race-final' }],
-      })
-
-      const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
-        .runSlashCommand({
-          name: 'queue',
-          options: [{ name: 'message', type: 3, value: 'Reply with exactly: removed-queued-message' }],
-        })
-      const secondQueueAck = await th.waitForInteractionAck({
-        interactionId: secondQueueInteractionId,
-        timeout: 4_000,
-      })
-      if (!secondQueueAck.messageId) {
-        throw new Error('Expected second /queue response message id')
-      }
-
-      const secondQueueAckMessage = await waitForMessageById({
-        discord,
-        threadId: thread.id,
-        messageId: secondQueueAck.messageId,
-        timeout: 4_000,
-      })
-      // The first /queue item is still in flight, so it holds position 1.
-      expect(secondQueueAckMessage.content).toContain('Queued message (position 2)')
-
-      const { id: thirdQueueInteractionId } = await th.user(TEST_USER_ID).runSlashCommand({
-        name: 'queue',
-        options: [{ name: 'message', type: 3, value: 'Reply with exactly: kept-queued-message' }],
-      })
-      const thirdQueueAck = await th.waitForInteractionAck({
-        interactionId: thirdQueueInteractionId,
-        timeout: 4_000,
-      })
-      if (!thirdQueueAck.messageId) {
-        throw new Error('Expected third /queue response message id')
-      }
-
-      const thirdQueueAckMessage = await waitForMessageById({
-        discord,
-        threadId: thread.id,
-        messageId: thirdQueueAck.messageId,
-        timeout: 4_000,
-      })
-      expect(thirdQueueAckMessage.content).toContain('Queued message (position 3)')
-
-      const serializedComponents = JSON.stringify(secondQueueAckMessage.components)
-      const customIdMatch = serializedComponents.match(
-        /"custom_id"\s*:\s*"(queue_remove:[^"]+)"/,
-      )
-      if (!customIdMatch?.[1]) {
-        throw new Error(
-          `Expected Remove from queue button on queue ack: ${serializedComponents}`,
-        )
-      }
-
-      const removeInteraction = await th.user(TEST_USER_ID).clickButton({
-        messageId: secondQueueAckMessage.id,
-        customId: customIdMatch[1],
-      })
-      await th.waitForInteractionAck({
-        interactionId: removeInteraction.id,
-        timeout: 4_000,
-      })
-
-      const removeAckMessage = await waitForMessageById({
-        discord,
-        threadId: thread.id,
-        messageId: secondQueueAckMessage.id,
-        timeout: 4_000,
-      })
-      expect(removeAckMessage.content).toContain('Removed queued message')
-      expect(removeAckMessage.content).toContain('removed-queued-message')
-
-      const indicator = await waitForBotReplyTo({
-        discord,
-        threadId: thread.id,
-        replyToMessageId: thirdQueueAckMessage.id,
-        timeout: 8_000,
-      })
-      expect(indicator.content).toBe('-# Executing queued prompt')
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageId: indicator.id,
-      })
-
-      const threadText = await th.text()
-      expect(threadText).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: clear-queue-setup
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        -# Removed queued message: Reply with exactly: removed-queued-message
-        » **queue-tester:** Reply with exactly: race-final
-        -# Queued message (position 3)
-        race-final
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        -# Executing queued prompt
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-      // The removed item never drained, so nothing replies to its ack.
-      const finalMessages = await th.getMessages()
-      expect(finalMessages.some((message) => {
-        return message.message_reference?.message_id === secondQueueAckMessage.id
-      })).toBe(false)
-    },
-    12_000,
-  )
-
-  test(
-    'slow stream still processes queued next message after completion',
-    async () => {
-      // A message sent mid-stream queues and runs after the in-flight request
-      // completes (no auto-interrupt).
-
-      // 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: 4_000,
-        predicate: (t) => {
-          return t.name === 'Reply with exactly: golf'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-      const firstReply = await th.waitForBotReply({ timeout: 4_000 })
-      expect(getMessageVisibleText(firstReply).trim().length).toBeGreaterThan(0)
-
-      // Wait for golf's footer so the golf→hotel transition is deterministic
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 4_000,
-        afterMessageIncludes: 'ok',
-        afterAuthorId: discord.botUserId,
-      })
-
-      const before = await th.getMessages()
-      const beforeBotCount = before.filter((m) => {
-        return m.author.id === discord.botUserId
-      }).length
-
-      // 2. Start request B (hotel, slow matcher ~400ms), 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 queue behind it
-      await new Promise((r) => {
-        setTimeout(r, 200)
-      })
-      await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: india',
-      })
-
-      // 4. B completes, then C gets processed.
-      //    Poll until india's user message has a bot reply after it.
-      const after = await waitForBotReplyAfterUserMessage({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        userMessageIncludes: 'india',
-        timeout: 4_000,
-      })
-
-      // C's user message appears before its bot response.
-      // We assert on india's reply existence.
-      expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: golf
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        --- from: user (queue-tester)
-        Reply with exactly: hotel
-        Reply with exactly: india
-        --- from: assistant (TestBot)
-        > ok"
-      `)
-      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)
-    },
-    8_000,
-  )
-
-  test(
-    'queue drains correctly after bursty queued messages',
-    async () => {
-      // Verifies the queue doesn't get stuck after multiple rapid messages.
-
-      // 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: 4_000,
-        predicate: (t) => {
-          return t.name === 'Reply with exactly: juliet'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-      const firstReply = await th.waitForBotReply({ timeout: 4_000 })
-      expect(getMessageVisibleText(firstReply).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 back-to-back to avoid timing windows where
-      // one run can finish between sends and reorder transcript lines.
-      await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: kilo',
-      })
-      await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: lima',
-      })
-      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,
-        userId: TEST_USER_ID,
-        userMessageIncludes: 'mike',
-        timeout: 4_000,
-      })
-
-      // 4. Queue should be clean — send E and verify it also gets processed
-      await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: november',
-      })
-
-      const afterE = await waitForBotReplyAfterUserMessage({
-        discord,
-        threadId: thread.id,
-        userId: TEST_USER_ID,
-        userMessageIncludes: 'november',
-        timeout: 4_000,
-      })
-
-      const textWithoutFooters = (await th.text())
-        .split('\n')
-        .filter((line) => {
-          return !line.startsWith('*project ⋅') && !line.startsWith('> *project ⋅') && !line.startsWith('-# *project ⋅')
-        })
-        .join('\n')
-
-      const normalizedTextWithoutFooters = textWithoutFooters.replace(
-        [
-          '--- from: assistant (TestBot)',
-          'ok',
-          '--- from: user (queue-tester)',
-          'Reply with exactly: november',
-        ].join('\n'),
-        [
-          '--- from: assistant (TestBot)',
-          '--- from: user (queue-tester)',
-          'Reply with exactly: november',
-        ].join('\n'),
-      )
-
-      expect(normalizedTextWithoutFooters).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        Reply with exactly: juliet
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        --- from: user (queue-tester)
-        Reply with exactly: kilo
-        Reply with exactly: lima
-        Reply with exactly: mike
-        --- from: assistant (TestBot)
-        --- from: user (queue-tester)
-        Reply with exactly: november
-        --- from: assistant (TestBot)"
-      `)
-      // 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)
-    },
-    8_000,
-  )
-
-  test(
-    'editing a queued message updates its prompt before dispatch',
-    async () => {
-      // 1. Start a session with a slow matcher (2s busy) to keep it busy.
-      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: 'SLOW_BUSY_MARKER Reply with exactly: edit-queue-setup',
-      })
-
-      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 4_000,
-        predicate: (t) => {
-          return t.name === 'SLOW_BUSY_MARKER Reply with exactly: edit-queue-setup'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-
-      // 2. Wait until the bot has replied, then queue while the slow stream is busy.
-      await th.waitForBotReply({ timeout: 4_000 })
-      const queuedMsg = await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: original-queued. queue',
-      })
-
-      // 3. Verify the message landed in the local queue.
-      const queuedState = await waitForThreadState({
-        threadId: thread.id,
-        predicate: (state) => {
-          return state.queueItems.length > 0
-        },
-        timeout: 4_000,
-        description: 'queue has item from suffix message',
-      })
-      expect(queuedState.queueItems.length).toBeGreaterThanOrEqual(1)
-      const queueItem = queuedState.queueItems.find((item) => {
-        return item.sourceMessageId === queuedMsg.id
-      })
-      expect(queueItem).toBeTruthy()
-      expect(queueItem!.prompt).toContain('original-queued')
-
-      // 4. Edit the message while it's still in the queue.
-      await th.user(TEST_USER_ID).editMessage({
-        messageId: queuedMsg.id,
-        content: 'Reply with exactly: edited-queued. queue',
-      })
-
-      // 5. Verify the queue item was updated.
-      const updatedState = await waitForThreadState({
-        threadId: thread.id,
-        predicate: (state) => {
-          return state.queueItems.some((item) => {
-            return item.prompt.includes('edited-queued')
-          })
-        },
-        timeout: 4_000,
-        description: 'queue item updated after edit',
-      })
-      const updatedItem = updatedState.queueItems.find((item) => {
-        return item.sourceMessageId === queuedMsg.id
-      })
-      expect(updatedItem).toBeTruthy()
-      expect(updatedItem!.prompt).toContain('edited-queued')
-      expect(updatedItem!.prompt).not.toContain('original-queued')
-
-      // 6. Wait for the queue to drain and verify the edited prompt was dispatched.
-      // The drain indicator is a silent reply to the user's queued message.
-      const indicator = await waitForBotReplyTo({
-        discord,
-        threadId: thread.id,
-        replyToMessageId: queuedMsg.id,
-        timeout: 8_000,
-      })
-      expect(indicator.content).toBe('-# Executing queued prompt')
-
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 8_000,
-        afterMessageId: indicator.id,
-      })
-
-      expect(await th.text()).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        SLOW_BUSY_MARKER Reply with exactly: edit-queue-setup
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        --- from: user (queue-tester)
-        Reply with exactly: edited-queued. queue
-        --- from: assistant (TestBot)
-        -# Queued at position 1. Edit or delete your message to update the queue
-        -# **queue-tester** edited queued message
-        slow-busy-reply
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
-        -# Executing queued prompt
-        ok
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-
-      const finalText = await th.text()
-      expect(finalText).toContain('edited-queued')
-      expect(finalText).not.toContain('original-queued')
-    },
-    12_000,
-  )
-
-  test(
-    'editing a queued message to remove queue suffix removes it from queue',
-    async () => {
-      // 1. Start a session with a slow matcher (2s busy) to keep it busy.
-      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
-        content: 'SLOW_BUSY_MARKER Reply with exactly: remove-queue-setup',
-      })
-
-      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
-        timeout: 4_000,
-        predicate: (t) => {
-          return t.name === 'SLOW_BUSY_MARKER Reply with exactly: remove-queue-setup'
-        },
-      })
-
-      const th = discord.thread(thread.id)
-
-      // Wait for the bot to start replying so the session is busy and
-      // the user message appears after the first bot message in the thread.
-      await th.waitForBotReply({ timeout: 4_000 })
-
-      // 2. Queue a message with queue suffix while session is busy.
-      const queuedMsg = await th.user(TEST_USER_ID).sendMessage({
-        content: 'Reply with exactly: will-be-removed. queue',
-      })
-
-      // 3. Verify the message is in the queue.
-      await waitForThreadState({
-        threadId: thread.id,
-        predicate: (state) => {
-          return state.queueItems.some((item) => {
-            return item.sourceMessageId === queuedMsg.id
-          })
-        },
-        timeout: 4_000,
-        description: 'queue has item to be removed',
-      })
-
-      // 4. Edit the message to remove the queue suffix.
-      await th.user(TEST_USER_ID).editMessage({
-        messageId: queuedMsg.id,
-        content: 'Reply with exactly: will-be-removed',
-      })
-
-      // 5. Verify the item was removed from the queue.
-      // Poll briefly since the MessageUpdate event is async.
-      for (let i = 0; i < 20; i++) {
-        const state = await waitForThreadState({
-          threadId: thread.id,
-          predicate: () => true,
-          timeout: 100,
-          description: 'check queue after edit',
-        })
-        const stillQueued = state.queueItems.some((item) => {
-          return item.sourceMessageId === queuedMsg.id
-        })
-        if (!stillQueued) break
-        await new Promise((r) => setTimeout(r, 50))
-      }
-
-      const finalState = await waitForThreadState({
-        threadId: thread.id,
-        predicate: () => true,
-        timeout: 100,
-        description: 'final queue check',
-      })
-      const removedItem = finalState.queueItems.find((item) => {
-        return item.sourceMessageId === queuedMsg.id
-      })
-      expect(removedItem).toBeUndefined()
-
-      // 6. Wait for the slow session to finish and verify the removed
-      // message was never dispatched as a queue drain (no drain indicator).
-      await waitForFooterMessage({
-        discord,
-        threadId: thread.id,
-        timeout: 8_000,
-      })
-
-      const finalText = await th.text()
-      // The user message text appears in the thread, but the queue dispatch
-      // indicator should NOT appear because the item was removed from the
-      // queue before drain.
-      expect(finalText).not.toContain('Executing queued prompt')
-      expect(finalText).toMatchInlineSnapshot(`
-        "--- from: user (queue-tester)
-        SLOW_BUSY_MARKER Reply with exactly: remove-queue-setup
-        --- from: assistant (TestBot)
-        -# *using deterministic-provider/deterministic-v2*
-        --- from: user (queue-tester)
-        Reply with exactly: will-be-removed
-        --- from: assistant (TestBot)
-        -# Queued at position 1. Edit or delete your message to update the queue
-        -# **queue-tester** removed message from queue
-        slow-busy-reply
-        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
-      `)
-    },
-    12_000,
-  )
-
-})