opencode-discord-bot 0.0.1

package/src/Main.test.ts

@@ -0,0 +1,273 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Effect, Redacted, Stream } from "effect"
+import { defaultConfig } from "./Config.ts"
+import type { DiscordGatewayClient, DiscordGatewayOptions } from "./Discord/DiscordGateway.ts"
+import { DiscordError, type DiscordService } from "./Discord/DiscordPort.ts"
+import { makeMemoryDiscord } from "./Discord/MemoryDiscord.ts"
+import { liveRuntimeFactories, makeApplication, makeProgram, type RuntimeFactories } from "./Main.ts"
+import { makeMemoryOpencode } from "./Opencode/MemoryOpencode.ts"
+import { OpencodeError, type OpencodeService } from "./Opencode/OpencodePort.ts"
+import type { DiscordMessage } from "./Schema.ts"
+
+const makeFakeGatewayClient = (): DiscordGatewayClient => {
+  const client: DiscordGatewayClient = {
+    user: { id: "self" },
+    application: { commands: { create: () => Promise.resolve({}) } },
+    channels: { fetch: () => Promise.resolve(null) },
+    on: () => client,
+    once: () => client,
+    login: () => Promise.resolve("token"),
+    destroy: () => Promise.resolve()
+  }
+  return client
+}
+
+const mentionMessage = {
+  id: "m1",
+  guildId: "g1",
+  channelId: "c1",
+  author: { id: "u1", displayName: "Alice", isBot: false },
+  content: "hello <@self>",
+  timestamp: "2026-06-05T14:03:00.000Z",
+  mentions: ["self"],
+  roleMentions: [],
+  everyoneMention: false,
+  hereMention: false,
+  attachments: [],
+  reactions: [],
+  channelType: "guild"
+} satisfies DiscordMessage
+
+describe("makeProgram", () => {
+  test("runs Bun preflight, loads config, and scaffolds generated Discord tools", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-program-"))
+    const discord = makeMemoryDiscord()
+    const opencode = makeMemoryOpencode([])
+    const factories: RuntimeFactories = {
+      makeDiscord: () => discord,
+      makeOpencode: () => opencode,
+      startGateway: () => Effect.succeed({ bot: { userId: "self" }, client: makeFakeGatewayClient() }),
+      keepAlive: Effect.void
+    }
+
+    try {
+      await Effect.runPromise(makeProgram(projectDir, { DISCORD_TOKEN: "token", OPENCODE_PROJECT_DIR: projectDir }, factories))
+      const tool = await readFile(join(projectDir, ".opencode", "tools", "discord-bridge.ts"), "utf8")
+
+      expect(tool).toContain("Generated by opencode-discord-bot")
+      expect(tool).toContain("http://127.0.0.1:8787/tool")
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("makeApplication", () => {
+  test("starts the loopback server through the application facade", async () => {
+    const app = makeApplication({
+      bot: { userId: "self" },
+      config: defaultConfig,
+      discord: makeMemoryDiscord(),
+      opencode: makeMemoryOpencode([])
+    })
+
+    const server = await Effect.runPromise(app.startLoopback(0).pipe(Effect.scoped))
+
+    expect(server.url).toStartWith("http://127.0.0.1:")
+    expect(server.port).toBeGreaterThan(0)
+  })
+})
+
+describe("liveRuntimeFactories", () => {
+  test("constructs live opencode through runtime factories", () => {
+    expect(liveRuntimeFactories.makeOpencode(defaultConfig)).toBeDefined()
+  })
+})
+
+describe("makeApplication startup", () => {
+  test("reports application start scaffolding failures", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-start-fail-"))
+    const blockedPath = join(projectDir, "blocked")
+    await writeFile(blockedPath, "not a directory")
+    const app = makeApplication({
+      bot: { userId: "self" },
+      config: { ...defaultConfig, opencode: { ...defaultConfig.opencode, projectDir: blockedPath } },
+      discord: makeMemoryDiscord(),
+      opencode: makeMemoryOpencode([])
+    })
+
+    try {
+      await expect(Effect.runPromise(app.start)).rejects.toBeDefined()
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+
+  test("swallows failed message turns from gateway dispatch", async () => {
+    const failingDiscord: DiscordService = {
+      fetchContext: () => Effect.fail(new DiscordError({ message: "context failed" })),
+      fetchHistory: () => Effect.succeed([]),
+      sendTyping: () => Effect.void,
+      postMessage: () => Effect.succeed({ id: "posted" }),
+      editMessage: () => Effect.void,
+      addReaction: () => Effect.void,
+      removeReaction: () => Effect.void,
+      attachFile: () => Effect.succeed({ path: "out.txt" }),
+      createThread: () => Effect.succeed({ id: "thread" }),
+      deleteMessage: () => Effect.void,
+      postChannelMessage: () => Effect.succeed({ id: "posted" }),
+      pinMessage: () => Effect.void,
+      unpinMessage: () => Effect.void
+    }
+    const app = makeApplication({
+      bot: { userId: "self" },
+      config: defaultConfig,
+      discord: failingDiscord,
+      opencode: makeMemoryOpencode([])
+    })
+
+    await expect(Effect.runPromise(app.startMessageTurn(mentionMessage))).resolves.toBeUndefined()
+    await new Promise((resolve) => setTimeout(resolve, 0))
+  })
+})
+
+describe("makeProgram callbacks", () => {
+  test("routes gateway callbacks through the initialized application", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-callbacks-"))
+    const discord = makeMemoryDiscord({ context: [mentionMessage] })
+    const opencode = makeMemoryOpencode([{ type: "text-delta", text: "callback ok" }, { type: "idle" }])
+    let gatewayOptions: DiscordGatewayOptions | undefined
+    const factories: RuntimeFactories = {
+      makeDiscord: () => discord,
+      makeOpencode: () => opencode,
+      startGateway: (options) =>
+        Effect.sync(() => {
+          gatewayOptions = options
+          return { bot: { userId: "self" }, client: makeFakeGatewayClient() }
+        }),
+      keepAlive: Effect.void
+    }
+
+    try {
+      await Effect.runPromise(makeProgram(projectDir, { DISCORD_TOKEN: "token", OPENCODE_PROJECT_DIR: projectDir }, factories))
+      if (gatewayOptions === undefined) throw new Error("gateway options were not captured")
+
+      await Effect.runPromise(gatewayOptions.onMessage(mentionMessage, { userId: "self" }))
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      await Effect.runPromise(gatewayOptions.onStop({ guildId: "g1", channelId: "c1" }, { userId: "self" }))
+
+      expect(opencode.prompts).toHaveLength(1)
+      expect(discord.messages.map((item) => item.content)).toContain("callback ok")
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("makeApplication facade", () => {
+  test("handles Discord tool requests through the application facade", async () => {
+    const discord = makeMemoryDiscord({ context: [mentionMessage] })
+    let releaseTurn: (() => void) | undefined
+    const waiting = new Promise<void>((resolve) => {
+      releaseTurn = resolve
+    })
+    const opencode: OpencodeService = {
+      checkHealth: Effect.void,
+      abort: () => Stream.empty,
+      runPrompt: () =>
+        Stream.fromAsyncIterable(
+          (async function* () {
+            await waiting
+            yield { type: "idle" as const }
+          })(),
+          () => new OpencodeError({ message: "stream failed" })
+        )
+    }
+    const app = makeApplication({
+      bot: { userId: "self" },
+      config: defaultConfig,
+      discord,
+      opencode
+    })
+
+    const running = Effect.runPromise(app.handleMessage(mentionMessage))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    const response = await Effect.runPromise(
+      app.handleTool({
+        action: "followUpMessage",
+        target: { guildId: "g1", channelId: "c1" },
+        args: { content: "hello @everyone <@&123>" }
+      })
+    )
+    releaseTurn?.()
+    await running
+
+    expect(response).toEqual({ ok: true, result: { id: "posted-1" } })
+    expect(discord.messages.map((item) => item.content)).toEqual(["hello @ everyone <@& 123>"])
+  })
+
+  test("runs message turns and stop commands through the application facade", async () => {
+    const discord = makeMemoryDiscord({
+      context: [
+        {
+          id: "m1",
+          guildId: "g1",
+          channelId: "c1",
+          author: { id: "u1", displayName: "Alice", isBot: false },
+          content: "hello <@self>",
+          timestamp: "2026-06-05T14:03:00.000Z",
+          mentions: ["self"],
+          roleMentions: [],
+          everyoneMention: false,
+          hereMention: false,
+          attachments: [],
+          reactions: [],
+          channelType: "guild"
+        }
+      ]
+    })
+    const opencode = makeMemoryOpencode([{ type: "text-delta", text: "ok" }, { type: "idle" }])
+    const app = makeApplication({
+      bot: { userId: "self" },
+      config: defaultConfig,
+      discord,
+      opencode
+    })
+    const trigger = discord.context[0]
+    if (trigger === undefined) throw new Error("missing trigger fixture")
+
+    await Effect.runPromise(app.startMessageTurn(trigger))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    await Effect.runPromise(app.handleStop({ guildId: "g1", channelId: "c1" }))
+
+    expect(discord.messages.map((item) => item.content)).toEqual(["ok", "There is no known active turn in this process."])
+    expect(opencode.aborted).toEqual([])
+  })
+})
+
+describe("liveRuntimeFactories Discord", () => {
+  test("uses chat-sdk Discord when production config includes a public key", () => {
+    const service = liveRuntimeFactories.makeDiscord(
+      { bot: { userId: "app-1" }, client: makeFakeGatewayClient() },
+      {
+        ...defaultConfig,
+        discordToken: Redacted.make("token"),
+        discord: { applicationId: "app-1", publicKey: "0".repeat(64) }
+      }
+    )
+
+    expect(service).toBeDefined()
+  })
+
+  test("uses chat-sdk Discord output even when no public key is configured", () => {
+    const service = liveRuntimeFactories.makeDiscord(
+      { bot: { userId: "app-1" }, client: makeFakeGatewayClient() },
+      { ...defaultConfig, discordToken: Redacted.make("token") }
+    )
+
+    expect(service).toBeDefined()
+  })
+})

package/src/Main.ts

@@ -0,0 +1,192 @@
+#!/usr/bin/env bun
+import { BunRuntime } from "@effect/platform-bun"
+import { Effect, Redacted, type Scope } from "effect"
+import { startLoopbackServer } from "./Bridge/LoopbackServer.ts"
+import { handleToolRequest } from "./Bridge/ToolControl.ts"
+import { defaultConfig, loadConfig, type RuntimeConfig } from "./Config.ts"
+import { makeLiveChatSdkDiscord } from "./Discord/ChatSdkDiscord.ts"
+import { type ChatGatewayIntake, makeChatGatewayIntake } from "./Discord/ChatSdkGatewayIntake.ts"
+import { type DiscordGateway, type DiscordGatewayOptions, startDiscordGateway } from "./Discord/DiscordGateway.ts"
+import type { DiscordService } from "./Discord/DiscordPort.ts"
+import type { OpencodeService } from "./Opencode/OpencodePort.ts"
+import { makeLiveSdkOpencode } from "./Opencode/SdkOpencode.ts"
+import { handleDiscordMessage } from "./Orchestrator/Orchestrator.ts"
+import { handleStopCommand } from "./Orchestrator/StopCommand.ts"
+import { shouldTriggerTurn, toDiscordScope } from "./Orchestrator/Triggering.ts"
+import { createTurnManager, type TurnManager } from "./Orchestrator/TurnManager.ts"
+import type { BotIdentity, DiscordMessage, DiscordScope, ToolRequest } from "./Schema.ts"
+import { ensureDiscordTools } from "./Tools/Scaffolding.ts"
+
+type ApplicationOptions = {
+  readonly bot: BotIdentity
+  readonly config: RuntimeConfig
+  readonly discord: DiscordService
+  readonly opencode: OpencodeService
+  readonly turns?: TurnManager | undefined
+}
+
+type QueuedMessage = {
+  readonly latest: DiscordMessage
+  readonly skipped: ReadonlyArray<DiscordMessage>
+}
+
+export const makeApplication = (options: ApplicationOptions) => {
+  const activeToolScopes = new Map<string, DiscordScope>()
+  const queuedMessages = new Map<string, QueuedMessage>()
+  const turns =
+    options.turns ??
+    createTurnManager(options.opencode, options.discord, {
+      strategy: options.config.concurrency.strategy,
+      globalMaxActiveTurns: options.config.concurrency.globalMaxActiveTurns,
+      maxTurn: options.config.guards.maxTurn
+    })
+  const activeScopeKey = (scope: DiscordScope): string => `${scope.guildId}:${scope.channelId}:${scope.threadId ?? ""}`
+  const handleMessage = (message: DiscordMessage, skippedMessages: ReadonlyArray<DiscordMessage> = []) => {
+    const scope = toDiscordScope(message)
+    const key = activeScopeKey(scope)
+    return Effect.gen(function* () {
+      yield* Effect.sync(() => activeToolScopes.set(key, scope))
+      return yield* handleDiscordMessage(message, options, skippedMessages)
+    }).pipe(Effect.ensuring(Effect.sync(() => activeToolScopes.delete(key))))
+  }
+
+  const runQueuedMessage = (key: string) =>
+    Effect.gen(function* () {
+      const queued = yield* Effect.sync(() => queuedMessages.get(key))
+      if (queued === undefined) return
+      yield* Effect.sync(() => queuedMessages.delete(key))
+      yield* handleMessage(queued.latest, queued.skipped).pipe(
+        Effect.asVoid,
+        Effect.catch(() => Effect.void)
+      )
+    }).pipe(Effect.asVoid)
+
+  const queueMessage = (key: string, message: DiscordMessage, skippedMessages: ReadonlyArray<DiscordMessage>) =>
+    Effect.sync(() => {
+      const existing = queuedMessages.get(key)
+      const skipped = (existing === undefined ? skippedMessages : [...existing.skipped, existing.latest, ...skippedMessages]).slice(
+        -options.config.context.messages
+      )
+      queuedMessages.set(key, { latest: message, skipped })
+    })
+
+  return {
+    start: Effect.tryPromise({
+      try: () =>
+        ensureDiscordTools({
+          projectDir: options.config.opencode.projectDir,
+          bridgePort: options.config.bridge.port,
+          enabled: options.config.tools.enabled,
+          autoInstall: options.config.tools.autoInstall
+        }),
+      catch: (cause) => cause
+    }),
+    handleMessage,
+    startMessageTurn: (message: DiscordMessage, skippedMessages: ReadonlyArray<DiscordMessage> = []) => {
+      const scope = toDiscordScope(message)
+      const key = activeScopeKey(scope)
+      return Effect.gen(function* () {
+        const busy = activeToolScopes.has(key) || queuedMessages.has(key) || (yield* turns.isActive(scope))
+        if (options.config.concurrency.strategy === "queue" && busy) {
+          if (!shouldTriggerTurn(message, options.bot, message.threadId !== undefined)) return
+          yield* queueMessage(key, message, skippedMessages)
+          return yield* turns.startTurn(scope, undefined, runQueuedMessage(key)).pipe(Effect.asVoid)
+        }
+        return yield* turns
+          .startTurn(
+            scope,
+            undefined,
+            handleMessage(message, skippedMessages).pipe(
+              Effect.asVoid,
+              Effect.catch(() => Effect.void)
+            )
+          )
+          .pipe(Effect.asVoid)
+      })
+    },
+    handleStop: (scope: DiscordScope) => handleStopCommand(scope, turns, options.discord),
+    handleTool: (request: ToolRequest) =>
+      handleToolRequest(request, options.config, options.config.opencode.projectDir, options.discord, {
+        allowedScopes: [...activeToolScopes.values()],
+        botId: options.bot.userId
+      }),
+    startLoopback: (port = options.config.bridge.port) =>
+      startLoopbackServer({
+        port,
+        config: options.config,
+        projectDir: options.config.opencode.projectDir,
+        discord: options.discord,
+        getAllowedScopes: () => [...activeToolScopes.values()],
+        botId: options.bot.userId
+      })
+  }
+}
+
+const preflight = Effect.sync(() => {
+  if (typeof Bun === "undefined") throw new Error("opencode-discord-bot requires the Bun runtime")
+})
+
+export type RuntimeFactories = {
+  readonly makeOpencode: (config: RuntimeConfig) => OpencodeService
+  readonly makeDiscord: (gateway: DiscordGateway, config: RuntimeConfig) => DiscordService
+  readonly startGateway: (options: DiscordGatewayOptions) => Effect.Effect<DiscordGateway, unknown, Scope.Scope>
+  readonly keepAlive: Effect.Effect<void>
+}
+
+const makeProductionDiscord = (gateway: DiscordGateway, config: RuntimeConfig): DiscordService => {
+  return makeLiveChatSdkDiscord({
+    botToken: Redacted.value(config.discordToken),
+    applicationId: config.discord.applicationId ?? gateway.bot.userId,
+    ...(config.discord.publicKey === undefined ? {} : { publicKey: config.discord.publicKey })
+  })
+}
+
+export const liveRuntimeFactories: RuntimeFactories = {
+  makeOpencode: (config) => makeLiveSdkOpencode({ baseUrl: config.opencode.baseUrl, projectDir: config.opencode.projectDir }),
+  makeDiscord: makeProductionDiscord,
+  startGateway: startDiscordGateway,
+  keepAlive: Effect.never
+}
+
+export const makeProgram = (
+  cwd: string,
+  env: Readonly<Record<string, string | undefined>>,
+  factories: RuntimeFactories = liveRuntimeFactories
+) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      yield* preflight
+      const config = yield* loadConfig({ cwd, env })
+      const opencode = factories.makeOpencode(config)
+      yield* opencode.checkHealth
+
+      let app: ReturnType<typeof makeApplication> | undefined
+      let intake: ChatGatewayIntake | undefined
+      const gateway = yield* factories.startGateway({
+        token: Redacted.value(config.discordToken),
+        guildId: config.discord.guildId,
+        onMessage: (message) => intake?.processMessage(message) ?? app?.startMessageTurn(message) ?? Effect.void,
+        onStop: (scope) => app?.handleStop(scope) ?? Effect.void
+      })
+      const discord = factories.makeDiscord(gateway, config)
+      app = makeApplication({ bot: gateway.bot, config, discord, opencode })
+      intake = makeChatGatewayIntake({
+        bot: gateway.bot,
+        onMessage: (message, skippedMessages) => app?.startMessageTurn(message, skippedMessages) ?? Effect.void
+      })
+
+      const scaffoldedTools = yield* app.start
+      const loopback = yield* app.startLoopback()
+      const tools = scaffoldedTools.length === 0 ? "none" : scaffoldedTools.join(", ")
+      yield* Effect.logInfo(
+        `ready: Discord gateway connected as <@${gateway.bot.userId}>, opencode ${config.opencode.baseUrl}, bridge ${loopback.url}, tools ${tools}`
+      )
+      yield* factories.keepAlive
+    })
+  )
+
+if (import.meta.main) {
+  BunRuntime.runMain(makeProgram(process.cwd(), process.env), { disableErrorReporting: true })
+}
+
+export { defaultConfig }

package/src/MainQueue.test.ts

@@ -0,0 +1,124 @@
+import { expect, test } from "bun:test"
+import { Effect, Stream } from "effect"
+import { defaultConfig } from "./Config.ts"
+import { makeMemoryDiscord } from "./Discord/MemoryDiscord.ts"
+import { makeApplication } from "./Main.ts"
+import { OpencodeError, type OpencodeService } from "./Opencode/OpencodePort.ts"
+import type { DiscordMessage } from "./Schema.ts"
+
+const mentionMessage = {
+  id: "m1",
+  guildId: "g1",
+  channelId: "c1",
+  author: { id: "u1", displayName: "Alice", isBot: false },
+  content: "first <@self>",
+  timestamp: "2026-06-05T14:03:00.000Z",
+  mentions: ["self"],
+  roleMentions: [],
+  everyoneMention: false,
+  hereMention: false,
+  attachments: [],
+  reactions: [],
+  channelType: "guild"
+} satisfies DiscordMessage
+
+test("queues only the latest busy-scope message and surfaces skipped context", async () => {
+  const secondMessage = { ...mentionMessage, id: "m2", content: "second <@self>" } satisfies DiscordMessage
+  const thirdMessage = { ...mentionMessage, id: "m3", content: "third <@self>" } satisfies DiscordMessage
+  const discord = makeMemoryDiscord({ context: [mentionMessage, secondMessage, thirdMessage] })
+  let releaseFirst: (() => void) | undefined
+  let markFirstPromptStarted: (() => void) | undefined
+  let markQueuedPromptStarted: (() => void) | undefined
+  const firstTurn = new Promise<void>((resolve) => {
+    releaseFirst = resolve
+  })
+  const firstPromptStarted = new Promise<void>((resolve) => {
+    markFirstPromptStarted = resolve
+  })
+  const queuedPromptStarted = new Promise<void>((resolve) => {
+    markQueuedPromptStarted = resolve
+  })
+  const prompts: Array<string> = []
+  const opencode: OpencodeService = {
+    checkHealth: Effect.void,
+    abort: () => Stream.empty,
+    runPrompt: (input) => {
+      prompts.push(input.prompt)
+      if (prompts.length === 1) {
+        markFirstPromptStarted?.()
+        return Stream.fromAsyncIterable(
+          (async function* () {
+            yield { type: "text-delta" as const, text: "first" }
+            await firstTurn
+            yield { type: "idle" as const }
+          })(),
+          () => new OpencodeError({ message: "stream failed" })
+        )
+      }
+      markQueuedPromptStarted?.()
+      return Stream.fromIterable([{ type: "text-delta", text: "queued" }, { type: "idle" }])
+    }
+  }
+  const app = makeApplication({ bot: { userId: "self" }, config: defaultConfig, discord, opencode })
+
+  await Effect.runPromise(app.startMessageTurn(mentionMessage))
+  await firstPromptStarted
+  await Effect.runPromise(app.startMessageTurn(secondMessage))
+  await Effect.runPromise(app.startMessageTurn(thirdMessage))
+  releaseFirst?.()
+  await queuedPromptStarted
+
+  const queuedPrompt = prompts[1]
+  if (queuedPrompt === undefined) throw new Error("missing queued prompt")
+  expect(prompts).toHaveLength(2)
+  expect(queuedPrompt).toContain("(queued intermediate message)")
+  expect(queuedPrompt).toContain("second <@self>")
+  expect(queuedPrompt).toContain("third <@self>")
+  expect(queuedPrompt.indexOf("second <@self>")).toBeLessThan(queuedPrompt.indexOf("third <@self>"))
+})
+
+test("does not let ignored busy-scope messages replace a queued mention", async () => {
+  const queuedMention = { ...mentionMessage, id: "m2", content: "queued <@self>" } satisfies DiscordMessage
+  const ignored = { ...mentionMessage, id: "m3", content: "noise", mentions: [] } satisfies DiscordMessage
+  const discord = makeMemoryDiscord({ context: [mentionMessage, queuedMention, ignored] })
+  let releaseFirst: (() => void) | undefined
+  let markQueuedPromptStarted: (() => void) | undefined
+  const firstTurn = new Promise<void>((resolve) => {
+    releaseFirst = resolve
+  })
+  const queuedPromptStarted = new Promise<void>((resolve) => {
+    markQueuedPromptStarted = resolve
+  })
+  const prompts: Array<string> = []
+  const opencode: OpencodeService = {
+    checkHealth: Effect.void,
+    abort: () => Stream.empty,
+    runPrompt: (input) => {
+      prompts.push(input.prompt)
+      if (prompts.length === 1) {
+        return Stream.fromAsyncIterable(
+          (async function* () {
+            await firstTurn
+            yield { type: "idle" as const }
+          })(),
+          () => new OpencodeError({ message: "stream failed" })
+        )
+      }
+      markQueuedPromptStarted?.()
+      return Stream.fromIterable([{ type: "idle" }])
+    }
+  }
+  const app = makeApplication({ bot: { userId: "self" }, config: defaultConfig, discord, opencode })
+
+  await Effect.runPromise(app.startMessageTurn(mentionMessage))
+  await Effect.runPromise(app.startMessageTurn(queuedMention))
+  await Effect.runPromise(app.startMessageTurn(ignored))
+  releaseFirst?.()
+  await queuedPromptStarted
+
+  const queuedPrompt = prompts[1]
+  if (queuedPrompt === undefined) throw new Error("missing queued prompt")
+  expect(prompts).toHaveLength(2)
+  expect(queuedPrompt).toContain("queued <@self>")
+  expect(queuedPrompt.indexOf("noise")).toBeLessThan(queuedPrompt.indexOf("queued <@self>"))
+})