opencode-discord-bot 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-discord-bot",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Discord bot bridge for a self-hosted opencode instance",
   "type": "module",
   "main": "src/Main.ts",

package/src/Bridge/LoopbackServer.ts

@@ -14,7 +14,6 @@ export type LoopbackServerOptions = {
   readonly projectDir: string
   readonly discord: DiscordService
   readonly getAllowedScopes?: (() => ReadonlyArray<DiscordScope>) | undefined
-  readonly botId?: string | undefined
 }
 
 type LoopbackServer = {
@@ -48,8 +47,7 @@ const toolApiLayer = (options: LoopbackServerOptions) =>
       Effect.gen(function* () {
         const toolRequest = yield* parseBody(request)
         return yield* handleToolRequest(toolRequest, options.config, options.projectDir, options.discord, {
-          allowedScopes: options.getAllowedScopes?.() ?? [],
-          botId: options.botId
+          allowedScopes: options.getAllowedScopes?.() ?? []
         })
       }).pipe(Effect.catch((error) => Effect.succeed(toolFailure(error))))
     )

package/src/Bridge/ToolControl.test.ts

@@ -137,14 +137,6 @@ describe("handleToolRequest action dispatch", () => {
           discord
         )
       )
-      const remove = await Effect.runPromise(
-        handleToolRequest(
-          { action: "removeReaction", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { emoji: "rocket" } },
-          defaultConfig,
-          projectDir,
-          discord
-        )
-      )
       const history = await Effect.runPromise(
         handleToolRequest(
           { action: "fetchHistory", target: { guildId: "g1", channelId: "c1" }, args: { limit: 1 } },
@@ -164,10 +156,9 @@ describe("handleToolRequest action dispatch", () => {
       const attachmentRealpath = await realpath(join(projectDir, "out", "report.txt"))
 
       expect(add).toEqual({ ok: true, result: { reacted: true } })
-      expect(remove).toEqual({ ok: true, result: { reacted: false } })
       expect(history.ok).toBe(true)
       expect(attach).toEqual({ ok: true, result: { path: attachmentRealpath } })
-      expect(discord.reactions.map((item) => item.op)).toEqual(["add", "remove"])
+      expect(discord.reactions.map((item) => item.op)).toEqual(["add"])
       expect(discord.attachments).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, path: attachmentRealpath }])
     } finally {
       await rm(projectDir, { recursive: true, force: true })

package/src/Bridge/ToolControl.ts

@@ -3,18 +3,15 @@ import { isAbsolute, resolve, sep } from "node:path"
 import { Effect } from "effect"
 import type { RuntimeConfig, ToolConfig } from "../Config.ts"
 import type { DiscordService } from "../Discord/DiscordPort.ts"
-import { sanitizeDiscordContent } from "../Discord/Safety.ts"
 import type { DiscordScope, ToolRequest, ToolResponse } from "../Schema.ts"
 
 type ToolRequestOptions = {
   readonly allowedScopes?: ReadonlyArray<DiscordScope> | undefined
-  readonly botId?: string | undefined
 }
 
 const actionFlag = (action: string): keyof ToolConfig | undefined => {
   switch (action) {
     case "addReaction":
-    case "removeReaction":
       return "reactions"
     case "attachFile":
       return "attachFiles"
@@ -22,12 +19,6 @@ const actionFlag = (action: string): keyof ToolConfig | undefined => {
       return "fetchHistory"
     case "createThread":
       return "createThread"
-    case "editOwnMessage":
-    case "deleteOwnMessage":
-      return "editDeleteOwn"
-    case "pin":
-    case "unpin":
-      return "pin"
     default:
       return undefined
   }
@@ -70,21 +61,12 @@ const attachmentPath = Effect.fn("attachmentPath")(function* (projectDir: string
 
 const disabled = (action: string): ToolResponse => ({ ok: false, error: `Action ${action} is disabled` })
 
-const reaction = Effect.fn("toolReaction")(function* (
-  request: ToolRequest,
-  scope: DiscordScope,
-  discord: DiscordService,
-  operation: "add" | "remove"
-) {
+const addReaction = Effect.fn("toolAddReaction")(function* (request: ToolRequest, scope: DiscordScope, discord: DiscordService) {
   const messageId = request.target.messageId
   const emoji = stringArg(request, "emoji")
   if (messageId === undefined || emoji === undefined) return { ok: false, error: "messageId and emoji are required" } satisfies ToolResponse
-  if (operation === "add") {
-    yield* discord.addReaction(scope, messageId, emoji)
-    return { ok: true, result: { reacted: true } } satisfies ToolResponse
-  }
-  yield* discord.removeReaction(scope, messageId, emoji)
-  return { ok: true, result: { reacted: false } } satisfies ToolResponse
+  yield* discord.addReaction(scope, messageId, emoji)
+  return { ok: true, result: { reacted: true } } satisfies ToolResponse
 })
 
 const fetchHistory = Effect.fn("toolFetchHistory")(function* (
@@ -120,69 +102,6 @@ const createThread = Effect.fn("toolCreateThread")(function* (request: ToolReque
   return { ok: true, result } satisfies ToolResponse
 })
 
-const ensureOwnMessage = Effect.fn("ensureOwnDiscordMessage")(function* (
-  messageId: string,
-  scope: DiscordScope,
-  config: RuntimeConfig,
-  discord: DiscordService,
-  options: ToolRequestOptions
-) {
-  if (options.botId === undefined) return "Bot identity is required to edit or delete bot-authored messages"
-  const history = yield* discord.fetchHistory(scope, config.context.messages)
-  const message = history.find((item) => item.id === messageId)
-  if (message?.author.id !== options.botId) return "messageId must refer to a bot-authored message"
-  return undefined
-})
-
-const editOwnMessage = Effect.fn("toolEditOwnMessage")(function* (
-  request: ToolRequest,
-  scope: DiscordScope,
-  config: RuntimeConfig,
-  discord: DiscordService,
-  options: ToolRequestOptions
-) {
-  const messageId = request.target.messageId
-  const content = stringArg(request, "content")
-  if (messageId === undefined || content === undefined || content.trim() === "") {
-    return { ok: false, error: "messageId and content are required" } satisfies ToolResponse
-  }
-  const ownMessageError = yield* ensureOwnMessage(messageId, scope, config, discord, options)
-  if (ownMessageError !== undefined) return { ok: false, error: ownMessageError } satisfies ToolResponse
-  yield* discord.editMessage(scope, messageId, sanitizeDiscordContent(content, config.guards))
-  return { ok: true, result: { edited: true } } satisfies ToolResponse
-})
-
-const deleteOwnMessage = Effect.fn("toolDeleteOwnMessage")(function* (
-  request: ToolRequest,
-  scope: DiscordScope,
-  config: RuntimeConfig,
-  discord: DiscordService,
-  options: ToolRequestOptions
-) {
-  const messageId = request.target.messageId
-  if (messageId === undefined) return { ok: false, error: "messageId is required" } satisfies ToolResponse
-  const ownMessageError = yield* ensureOwnMessage(messageId, scope, config, discord, options)
-  if (ownMessageError !== undefined) return { ok: false, error: ownMessageError } satisfies ToolResponse
-  yield* discord.deleteMessage(scope, messageId)
-  return { ok: true, result: { deleted: true } } satisfies ToolResponse
-})
-
-const pin = Effect.fn("toolPin")(function* (
-  request: ToolRequest,
-  scope: DiscordScope,
-  discord: DiscordService,
-  operation: "pin" | "unpin"
-) {
-  const messageId = request.target.messageId
-  if (messageId === undefined) return { ok: false, error: "messageId is required" } satisfies ToolResponse
-  if (operation === "pin") {
-    yield* discord.pinMessage(scope, messageId)
-    return { ok: true, result: { pinned: true } } satisfies ToolResponse
-  }
-  yield* discord.unpinMessage(scope, messageId)
-  return { ok: true, result: { pinned: false } } satisfies ToolResponse
-})
-
 export const handleToolRequest = Effect.fn("handleToolRequest")(function* (
   request: ToolRequest,
   config: RuntimeConfig,
@@ -203,23 +122,13 @@ export const handleToolRequest = Effect.fn("handleToolRequest")(function* (
 
   switch (request.action) {
     case "addReaction":
-      return yield* reaction(request, scope, discord, "add")
-    case "removeReaction":
-      return yield* reaction(request, scope, discord, "remove")
+      return yield* addReaction(request, scope, discord)
     case "fetchHistory":
       return yield* fetchHistory(request, scope, config, discord)
     case "attachFile":
       return yield* attachFile(request, scope, config, projectDir, discord)
     case "createThread":
       return yield* createThread(request, scope, discord)
-    case "editOwnMessage":
-      return yield* editOwnMessage(request, scope, config, discord, options)
-    case "deleteOwnMessage":
-      return yield* deleteOwnMessage(request, scope, config, discord, options)
-    case "pin":
-      return yield* pin(request, scope, discord, "pin")
-    case "unpin":
-      return yield* pin(request, scope, discord, "unpin")
   }
   return { ok: false, error: `Unknown action ${request.action}` } satisfies ToolResponse
 })

package/src/Bridge/ToolControlEdges.test.ts

@@ -24,22 +24,3 @@ test("rejects missing attachment files inside the project", async () => {
     await rm(projectDir, { recursive: true, force: true })
   }
 })
-
-test("rejects incomplete high-risk tool payloads before dispatch", async () => {
-  const config = {
-    ...defaultConfig,
-    tools: { ...defaultConfig.tools, editDeleteOwn: true }
-  }
-  const discord = makeMemoryDiscord()
-
-  const edit = await Effect.runPromise(
-    handleToolRequest(
-      { action: "editOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
-      config,
-      "/repo",
-      discord
-    )
-  )
-
-  expect(edit).toEqual({ ok: false, error: "messageId and content are required" })
-})

package/src/Bridge/ToolControlHighRisk.test.ts

@@ -11,120 +11,20 @@ const withTools = (tools: Partial<ToolConfig>): RuntimeConfig => ({
 })
 
 describe("handleToolRequest high-risk actions", () => {
-  test("dispatches opt-in high-risk actions through the Discord port", async () => {
-    const discord = makeMemoryDiscord({
-      context: [
-        {
-          id: "m1",
-          guildId: "g1",
-          channelId: "c1",
-          author: { id: "bot-1", displayName: "bot", isBot: true },
-          content: "old",
-          timestamp: "2026-06-05T14:03:00.000Z",
-          mentions: [],
-          roleMentions: [],
-          everyoneMention: false,
-          hereMention: false,
-          attachments: [],
-          reactions: [],
-          channelType: "guild"
-        }
-      ]
-    })
-    const config = withTools({ createThread: true, editDeleteOwn: true, pin: true })
+  test("dispatches opt-in thread creation through the Discord port", async () => {
+    const discord = makeMemoryDiscord()
+    const config = withTools({ createThread: true })
 
     const created = await Effect.runPromise(
       handleToolRequest(
         { action: "createThread", target: { guildId: "g1", channelId: "c1" }, args: { name: "work" } },
         config,
         "/repo",
-        discord,
-        { botId: "bot-1" }
-      )
-    )
-    const edited = await Effect.runPromise(
-      handleToolRequest(
-        { action: "editOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { content: "edited" } },
-        config,
-        "/repo",
-        discord,
-        { botId: "bot-1" }
-      )
-    )
-    const deleted = await Effect.runPromise(
-      handleToolRequest(
-        { action: "deleteOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
-        config,
-        "/repo",
-        discord,
-        { botId: "bot-1" }
-      )
-    )
-    const pinned = await Effect.runPromise(
-      handleToolRequest({ action: "pin", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} }, config, "/repo", discord)
-    )
-    const unpinned = await Effect.runPromise(
-      handleToolRequest(
-        { action: "unpin", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
-        config,
-        "/repo",
         discord
       )
     )
 
     expect(created).toEqual({ ok: true, result: { id: "thread-1" } })
-    expect(edited).toEqual({ ok: true, result: { edited: true } })
-    expect(deleted).toEqual({ ok: true, result: { deleted: true } })
-    expect(pinned).toEqual({ ok: true, result: { pinned: true } })
-    expect(unpinned).toEqual({ ok: true, result: { pinned: false } })
     expect(discord.threads).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, name: "work" }])
-    expect(discord.pins.map((item) => item.op)).toEqual(["pin", "unpin"])
-  })
-
-  test("rejects edit/delete requests for messages not authored by the bot", async () => {
-    const discord = makeMemoryDiscord({
-      context: [
-        {
-          id: "m1",
-          guildId: "g1",
-          channelId: "c1",
-          author: { id: "user-1", displayName: "user", isBot: false },
-          content: "user text",
-          timestamp: "2026-06-05T14:03:00.000Z",
-          mentions: [],
-          roleMentions: [],
-          everyoneMention: false,
-          hereMention: false,
-          attachments: [],
-          reactions: [],
-          channelType: "guild"
-        }
-      ]
-    })
-    const config = withTools({ editDeleteOwn: true })
-
-    const edited = await Effect.runPromise(
-      handleToolRequest(
-        { action: "editOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { content: "edited" } },
-        config,
-        "/repo",
-        discord,
-        { botId: "bot-1" }
-      )
-    )
-    const deleted = await Effect.runPromise(
-      handleToolRequest(
-        { action: "deleteOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
-        config,
-        "/repo",
-        discord,
-        { botId: "bot-1" }
-      )
-    )
-
-    expect(edited).toEqual({ ok: false, error: "messageId must refer to a bot-authored message" })
-    expect(deleted).toEqual({ ok: false, error: "messageId must refer to a bot-authored message" })
-    expect(discord.edits).toEqual([])
-    expect(discord.deletes).toEqual([])
   })
 })

package/src/Config.test.ts

@@ -24,7 +24,7 @@ describe("loadConfigFromSources", () => {
           "threads": { "activeByRecentBotParticipation": false },
           "concurrency": { "strategy": "burst", "globalMaxActiveTurns": 4 },
           "guards": { "ignoreBots": false, "stripMassMentions": false, "redactSecretsInErrors": false, "maxTurnMs": 1000 },
-          "tools": { "createThread": true, "pin": true, "followUpMessages": true, "postOtherChannels": true }
+          "tools": { "createThread": true, "editDeleteOwn": true, "pin": true, "followUpMessages": true, "postOtherChannels": true }
         }`
       })
     )
@@ -47,7 +47,8 @@ describe("loadConfigFromSources", () => {
     expect(config.guards.maxTurn).toEqual(Duration.millis(1000))
     expect(config.tools.reactions).toBe(true)
     expect(config.tools.createThread).toBe(true)
-    expect(config.tools.pin).toBe(true)
+    expect("editDeleteOwn" in config.tools).toBe(false)
+    expect("pin" in config.tools).toBe(false)
     expect("followUpMessages" in config.tools).toBe(false)
     expect("postOtherChannels" in config.tools).toBe(false)
   })
@@ -61,6 +62,8 @@ describe("loadConfigFromSources", () => {
     expect(config.bridge.port).toBe(8787)
     expect(config.context.messages).toBe(30)
     expect(config.tools.autoInstall).toBe(true)
+    expect("editDeleteOwn" in config.tools).toBe(false)
+    expect("pin" in config.tools).toBe(false)
     expect("followUpMessages" in config.tools).toBe(false)
     expect("postOtherChannels" in config.tools).toBe(false)
   })
@@ -106,11 +109,11 @@ describe("loadConfigFromSources", () => {
     const cwd = await mkdtemp(join(tmpdir(), "ocdb-config-"))
 
     try {
-      await writeFile(join(cwd, ".opencode-discord.jsonc"), `{ "contextMessages": 7, "tools": { "pin": true } }`)
+      await writeFile(join(cwd, ".opencode-discord.jsonc"), `{ "contextMessages": 7, "tools": { "createThread": true } }`)
       const config = await Effect.runPromise(loadConfig({ cwd, env: { DISCORD_TOKEN: "token" } }))
 
       expect(config.context.messages).toBe(7)
-      expect(config.tools.pin).toBe(true)
+      expect(config.tools.createThread).toBe(true)
     } finally {
       await rm(cwd, { recursive: true, force: true })
     }

package/src/Config.ts

@@ -18,8 +18,6 @@ export type ToolConfig = {
   readonly attachFiles: boolean
   readonly fetchHistory: boolean
   readonly createThread: boolean
-  readonly editDeleteOwn: boolean
-  readonly pin: boolean
 }
 
 export type RuntimeConfig = {
@@ -94,9 +92,7 @@ export const defaultConfig: RuntimeConfig = {
     reactions: true,
     attachFiles: true,
     fetchHistory: true,
-    createThread: false,
-    editDeleteOwn: false,
-    pin: false
+    createThread: false
   },
   streaming: {
     updateInterval: Duration.millis(500),
@@ -259,9 +255,7 @@ export const loadConfigFromSources = Effect.fn("loadConfigFromSources")(function
       reactions: readBoolean(tools, "reactions", defaultConfig.tools.reactions),
       attachFiles: readBoolean(tools, "attachFiles", defaultConfig.tools.attachFiles),
       fetchHistory: readBoolean(tools, "fetchHistory", defaultConfig.tools.fetchHistory),
-      createThread: readBoolean(tools, "createThread", defaultConfig.tools.createThread),
-      editDeleteOwn: readBoolean(tools, "editDeleteOwn", defaultConfig.tools.editDeleteOwn),
-      pin: readBoolean(tools, "pin", defaultConfig.tools.pin)
+      createThread: readBoolean(tools, "createThread", defaultConfig.tools.createThread)
     },
     streaming: {
       updateInterval: Duration.millis(readNumber(streaming, "updateIntervalMs", 500)),

package/src/ConfigSchema.ts

@@ -8,9 +8,7 @@ const RawToolsSchema = Schema.Struct({
   reactions: OptionalBoolean,
   attachFiles: OptionalBoolean,
   fetchHistory: OptionalBoolean,
-  createThread: OptionalBoolean,
-  editDeleteOwn: OptionalBoolean,
-  pin: OptionalBoolean
+  createThread: OptionalBoolean
 })
 
 export const RawConfigSchema = Schema.Struct({

package/src/Discord/ChatSdkDiscord.test.ts

@@ -47,11 +47,6 @@ class FakeDiscordAdapter {
     return Promise.resolve()
   }
 
-  removeReaction(threadId: string, messageId: string, emoji: string): Promise<void> {
-    this.calls.push(["removeReaction", { threadId, messageId, emoji }])
-    return Promise.resolve()
-  }
-
   fetchMessages(threadId: string): Promise<FetchResult<unknown>> {
     this.calls.push(["fetchMessages", { threadId }])
     return Promise.resolve({
@@ -82,7 +77,6 @@ describe("makeChatSdkDiscord", () => {
     await Effect.runPromise(discord.editMessage(scope, posted.id, "edited"))
     await Effect.runPromise(discord.sendTyping(scope))
     await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
-    await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
     const directory = await mkdtemp(join(tmpdir(), "ocdb-chat-"))
 
     try {
@@ -126,8 +120,6 @@ describe("makeChatSdkDiscord", () => {
       "encodeThreadId",
       "addReaction",
       "encodeThreadId",
-      "removeReaction",
-      "encodeThreadId",
       "postMessage"
     ])
   })
@@ -222,18 +214,12 @@ describe("makeChatSdkDiscord REST operations", () => {
 
       await Effect.runPromise(discord.deleteMessage(scope, "m1"))
       expect(await Effect.runPromise(discord.createThread(scope, "work"))).toEqual({ id: "thread-1" })
-      await Effect.runPromise(discord.pinMessage(scope, "m1"))
-      await Effect.runPromise(discord.unpinMessage(scope, "m1"))
     } finally {
       globalThis.fetch = originalFetch
     }
 
     expect(adapter.calls.map((item) => item[0])).toEqual(["encodeThreadId", "deleteMessage"])
-    expect(requests.map((request) => [request[0], request[1].method])).toEqual([
-      ["https://discord.test/api/channels/c1/threads", "POST"],
-      ["https://discord.test/api/channels/t1/pins/m1", "PUT"],
-      ["https://discord.test/api/channels/t1/pins/m1", "DELETE"]
-    ])
+    expect(requests.map((request) => [request[0], request[1].method])).toEqual([["https://discord.test/api/channels/c1/threads", "POST"]])
   })
 
   test("fails raw REST operations when no raw Discord client is configured", async () => {

package/src/Discord/ChatSdkDiscord.ts

@@ -13,7 +13,6 @@ type ChatDiscordAdapter = {
   readonly deleteMessage: (threadId: string, messageId: string) => Promise<void>
   readonly startTyping: (threadId: string, status?: string) => Promise<void>
   readonly addReaction: (threadId: string, messageId: string, emoji: string) => Promise<void>
-  readonly removeReaction: (threadId: string, messageId: string, emoji: string) => Promise<void>
   readonly fetchMessages: (threadId: string, options?: FetchOptions) => Promise<FetchResult<unknown>>
 }
 
@@ -223,8 +222,6 @@ export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordO
       tryAdapter(() => adapter.deleteMessage(threadIdFromScope(adapter, scope), messageId)).pipe(Effect.asVoid),
     addReaction: (scope, messageId, emoji) =>
       tryAdapter(() => adapter.addReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
-    removeReaction: (scope, messageId, emoji) =>
-      tryAdapter(() => adapter.removeReaction(threadIdFromScope(adapter, scope), messageId, emoji)).pipe(Effect.asVoid),
     attachFile: (scope, path) =>
       tryAdapter(async () => {
         const file: PostableRaw = { raw: "", files: [{ filename: basename(path), data: await readFile(path) }] }
@@ -235,11 +232,7 @@ export const makeChatSdkDiscord = (adapter: ChatDiscordAdapter, raw: RawDiscordO
       rawDiscord(raw, `/channels/${scope.channelId}/threads`, {
         method: "POST",
         body: JSON.stringify({ name, type: 11 })
-      }).pipe(Effect.map((data) => ({ id: isRecord(data) && typeof data.id === "string" ? data.id : "" }))),
-    pinMessage: (scope, messageId) =>
-      rawDiscord(raw, `/channels/${scope.threadId ?? scope.channelId}/pins/${messageId}`, { method: "PUT" }).pipe(Effect.asVoid),
-    unpinMessage: (scope, messageId) =>
-      rawDiscord(raw, `/channels/${scope.threadId ?? scope.channelId}/pins/${messageId}`, { method: "DELETE" }).pipe(Effect.asVoid)
+      }).pipe(Effect.map((data) => ({ id: isRecord(data) && typeof data.id === "string" ? data.id : "" })))
   }
 }
 

package/src/Discord/DiscordJsDiscord.test.ts

@@ -68,24 +68,11 @@ describe("makeDiscordJsDiscord", () => {
         calls.push(["delete", {}])
         return Promise.resolve({})
       },
-      pin: () => {
-        calls.push(["pin", {}])
-        return Promise.resolve({})
-      },
-      unpin: () => {
-        calls.push(["unpin", {}])
-        return Promise.resolve({})
-      },
       react: (emoji: string) => {
         calls.push(["react", emoji])
         return Promise.resolve({})
       },
-      reactions: {
-        cache: collection([{ emoji: { name: "rocket" }, count: 2 }]),
-        resolve: (emoji: string) => ({
-          users: { remove: (userId: string) => Promise.resolve(calls.push(["removeReaction", { emoji, userId }])) }
-        })
-      }
+      reactions: { cache: collection([{ emoji: { name: "rocket" }, count: 2 }]) }
     }
     const channel = {
       send: (content: unknown) => {
@@ -131,21 +118,15 @@ describe("makeDiscordJsDiscord", () => {
       await Effect.runPromise(discord.editMessage(scope, "m1", "edited"))
       await Effect.runPromise(discord.deleteMessage(scope, "m1"))
       await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
-      await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
       const attached = await Effect.runPromise(discord.attachFile(scope, file))
       expect(await Effect.runPromise(discord.createThread(scope, "work"))).toEqual({ id: "thread-1" })
-      await Effect.runPromise(discord.pinMessage(scope, "m1"))
-      await Effect.runPromise(discord.unpinMessage(scope, "m1"))
 
       expect(context).toHaveLength(1)
       expect(history).toHaveLength(1)
       expect(posted).toEqual({ id: "posted-1" })
       expect(attached).toEqual({ path: "posted-1" })
-      expect(calls.map((call) => call[0])).toContain("removeReaction")
       expect(calls.map((call) => call[0])).toContain("delete")
       expect(calls.map((call) => call[0])).toContain("createThread")
-      expect(calls.map((call) => call[0])).toContain("pin")
-      expect(calls.map((call) => call[0])).toContain("unpin")
     } finally {
       await rm(directory, { recursive: true, force: true })
     }
@@ -178,8 +159,7 @@ describe("makeDiscordJsDiscord", () => {
     const fetchedMessage = {
       ...baseMessage(),
       edit: () => Promise.resolve({}),
-      react: () => Promise.resolve({}),
-      reactions: { resolve: () => null }
+      react: () => Promise.resolve({})
     }
     const channel = {
       send: () => Promise.resolve({ id: "posted-1" }),
@@ -191,14 +171,6 @@ describe("makeDiscordJsDiscord", () => {
       _tag: "DiscordError",
       message: "Discord channel cannot create threads"
     })
-    await expect(Effect.runPromise(discord.pinMessage(scope, "m1"))).rejects.toMatchObject({
-      _tag: "DiscordError",
-      message: "Discord message is not pinnable"
-    })
-    await expect(Effect.runPromise(discord.unpinMessage(scope, "m1"))).rejects.toMatchObject({
-      _tag: "DiscordError",
-      message: "Discord message is not unpinnable"
-    })
     await expect(Effect.runPromise(discord.deleteMessage(scope, "m1"))).rejects.toMatchObject({
       _tag: "DiscordError",
       message: "Discord message is not deletable"

package/src/Discord/DiscordJsDiscord.ts

@@ -57,11 +57,6 @@ type DiscordFetchedMessageLike = DiscordJsMessageLike & {
   readonly edit: (content: string) => Promise<unknown>
   readonly react: (emoji: string) => Promise<unknown>
   readonly delete?: () => Promise<unknown>
-  readonly pin?: () => Promise<unknown>
-  readonly unpin?: () => Promise<unknown>
-  readonly reactions: DiscordJsMessageLike["reactions"] & {
-    readonly resolve: (emoji: string) => { readonly users: { readonly remove: (userId: string) => Promise<unknown> } } | null
-  }
 }
 
 export type DiscordJsChannelLike = {
@@ -227,12 +222,6 @@ export const makeDiscordJsDiscord = (client: DiscordJsClientLike): DiscordServic
       const message = yield* fetchMessage(client, scope, messageId)
       yield* tryDiscord(() => message.react(emoji))
     }),
-  removeReaction: (scope, messageId, emoji) =>
-    Effect.gen(function* () {
-      const message = yield* fetchMessage(client, scope, messageId)
-      const reaction = message.reactions.resolve(emoji)
-      if (reaction !== null && client.user !== null) yield* tryDiscord(() => reaction.users.remove(client.user?.id ?? ""))
-    }),
   attachFile: (scope, path) =>
     Effect.gen(function* () {
       const channel = yield* fetchTextChannel(client, scope)
@@ -245,17 +234,5 @@ export const makeDiscordJsDiscord = (client: DiscordJsClientLike): DiscordServic
       const channel = yield* fetchTextChannel(client, scope)
       if (channel.threads === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord channel cannot create threads" }))
       return yield* tryDiscord(() => channel.threads?.create({ name }) ?? Promise.resolve({ id: "" }))
-    }),
-  pinMessage: (scope, messageId) =>
-    Effect.gen(function* () {
-      const message = yield* fetchMessage(client, scope, messageId)
-      if (message.pin === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord message is not pinnable" }))
-      yield* tryDiscord(() => message.pin?.() ?? Promise.resolve())
-    }),
-  unpinMessage: (scope, messageId) =>
-    Effect.gen(function* () {
-      const message = yield* fetchMessage(client, scope, messageId)
-      if (message.unpin === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord message is not unpinnable" }))
-      yield* tryDiscord(() => message.unpin?.() ?? Promise.resolve())
     })
 })

package/src/Discord/DiscordPort.ts

@@ -17,13 +17,10 @@ export type DiscordService = {
   readonly postMessage: (scope: DiscordScope, content: string) => Effect.Effect<{ readonly id: string }, DiscordError>
   readonly editMessage: (scope: DiscordScope, messageId: string, content: string) => Effect.Effect<void, DiscordError>
   readonly addReaction: (scope: DiscordScope, messageId: string, emoji: string) => Effect.Effect<void, DiscordError>
-  readonly removeReaction: (scope: DiscordScope, messageId: string, emoji: string) => Effect.Effect<void, DiscordError>
   readonly fetchHistory: (scope: DiscordScope, limit: number) => Effect.Effect<ReadonlyArray<DiscordMessage>, DiscordError>
   readonly attachFile: (scope: DiscordScope, path: string) => Effect.Effect<{ readonly path: string }, DiscordError>
   readonly createThread: (scope: DiscordScope, name: string) => Effect.Effect<{ readonly id: string }, DiscordError>
   readonly deleteMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
-  readonly pinMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
-  readonly unpinMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
 }
 
 export const Discord = Context.Service<DiscordService>("opencode-discord-bot/Discord")

package/src/Discord/MemoryDiscord.test.ts

@@ -30,7 +30,6 @@ describe("makeMemoryDiscord", () => {
     const posted = await Effect.runPromise(discord.postMessage(scope, "hello"))
     await Effect.runPromise(discord.editMessage(scope, posted.id, "updated"))
     await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
-    await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
     const attached = await Effect.runPromise(discord.attachFile(scope, "/repo/out.txt"))
 
     expect(context.map((item) => item.id)).toEqual(["2"])
@@ -38,7 +37,7 @@ describe("makeMemoryDiscord", () => {
     expect(posted).toEqual({ id: "posted-1" })
     expect(discord.messages).toEqual([{ scope, content: "hello" }])
     expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "updated" }])
-    expect(discord.reactions.map((item) => item.op)).toEqual(["add", "remove"])
+    expect(discord.reactions.map((item) => item.op)).toEqual(["add"])
     expect(attached).toEqual({ path: "/repo/out.txt" })
   })
 })

package/src/Discord/MemoryDiscord.ts

@@ -15,12 +15,11 @@ export type MemoryDiscord = DiscordService & {
     readonly scope: DiscordScope
     readonly messageId: string
     readonly emoji: string
-    readonly op: "add" | "remove"
+    readonly op: "add"
   }>
   readonly attachments: Array<{ readonly scope: DiscordScope; readonly path: string }>
   readonly threads: Array<{ readonly scope: DiscordScope; readonly name: string }>
   readonly deletes: Array<{ readonly scope: DiscordScope; readonly messageId: string }>
-  readonly pins: Array<{ readonly scope: DiscordScope; readonly messageId: string; readonly op: "pin" | "unpin" }>
 }
 
 export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord => {
@@ -33,7 +32,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
   const attachments: MemoryDiscord["attachments"] = []
   const threads: MemoryDiscord["threads"] = []
   const deletes: MemoryDiscord["deletes"] = []
-  const pins: MemoryDiscord["pins"] = []
 
   return {
     context,
@@ -44,7 +42,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
     attachments,
     threads,
     deletes,
-    pins,
     fetchContext: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
     sendTyping: (scope) => Effect.sync(() => typingScopes.push(scope)).pipe(Effect.asVoid),
     postMessage: (scope, content) =>
@@ -55,8 +52,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
       }),
     editMessage: (scope, messageId, content) => Effect.sync(() => edits.push({ scope, messageId, content })).pipe(Effect.asVoid),
     addReaction: (scope, messageId, emoji) => Effect.sync(() => reactions.push({ scope, messageId, emoji, op: "add" })).pipe(Effect.asVoid),
-    removeReaction: (scope, messageId, emoji) =>
-      Effect.sync(() => reactions.push({ scope, messageId, emoji, op: "remove" })).pipe(Effect.asVoid),
     fetchHistory: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
     attachFile: (scope, path) =>
       Effect.sync(() => {
@@ -69,8 +64,6 @@ export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord =>
         threads.push({ scope, name })
         return { id: `thread-${nextId}` }
       }),
-    deleteMessage: (scope, messageId) => Effect.sync(() => deletes.push({ scope, messageId })).pipe(Effect.asVoid),
-    pinMessage: (scope, messageId) => Effect.sync(() => pins.push({ scope, messageId, op: "pin" })).pipe(Effect.asVoid),
-    unpinMessage: (scope, messageId) => Effect.sync(() => pins.push({ scope, messageId, op: "unpin" })).pipe(Effect.asVoid)
+    deleteMessage: (scope, messageId) => Effect.sync(() => deletes.push({ scope, messageId })).pipe(Effect.asVoid)
   }
 }

package/src/Main.test.ts

@@ -61,7 +61,7 @@ describe("makeProgram", () => {
 
     try {
       await Effect.runPromise(makeProgram(projectDir, makeTestEnv(projectDir, 18_787), factories))
-      const tool = await readFile(join(projectDir, ".opencode", "tools", "discord-bridge.ts"), "utf8")
+      const tool = await readFile(join(projectDir, ".opencode", "tools", "discord-add-reaction.ts"), "utf8")
 
       expect(tool).toContain("Generated by opencode-discord-bot")
       expect(tool).toContain("http://127.0.0.1:18787/tool")
@@ -120,12 +120,9 @@ describe("makeApplication startup", () => {
       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,
-      pinMessage: () => Effect.void,
-      unpinMessage: () => Effect.void
+      deleteMessage: () => Effect.void
     }
     const app = makeApplication({
       bot: { userId: "self" },

package/src/Main.ts

@@ -107,8 +107,7 @@ export const makeApplication = (options: ApplicationOptions) => {
     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
+        allowedScopes: [...activeToolScopes.values()]
       }),
     startLoopback: (port = options.config.bridge.port) =>
       startLoopbackServer({
@@ -116,8 +115,7 @@ export const makeApplication = (options: ApplicationOptions) => {
         config: options.config,
         projectDir: options.config.opencode.projectDir,
         discord: options.discord,
-        getAllowedScopes: () => [...activeToolScopes.values()],
-        botId: options.bot.userId
+        getAllowedScopes: () => [...activeToolScopes.values()]
       })
   }
 }

package/src/Orchestrator/ContextAssembly.test.ts

@@ -31,7 +31,7 @@ describe("context assembly", () => {
       })
     )
 
-    expect(rendered).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC | messageId=1]")
+    expect(rendered).toContain("[Nick 1 | 2026-06-05 14:03 UTC | messageId=1]")
     expect(rendered).toContain("Can you refactor this?")
     expect(rendered).toContain("(discord target: guildId=g1 channelId=c1)")
     expect(rendered).toContain("(attachments: screenshot.png [image/png; 12 bytes; https://cdn/a1])")
@@ -51,13 +51,17 @@ describe("context assembly", () => {
 
     expect(prompt.messages.map((item) => item.id)).toEqual(["1", "2", "3"])
     expect(prompt.text.match(/latest <@999>/g)).toHaveLength(1)
+    expect(prompt.text).toContain("(participants)\nNick 1 - <@u-1>\nNick 2 - <@u-2>\nNick 3 - <@u-3>")
+    expect(prompt.text.match(/<@u-3>/g)).toHaveLength(1)
     expect(prompt.text).toContain("Plain assistant text is streamed to Discord automatically")
     expect(prompt.text).toContain("do not use bridge tools to send messages")
     expect(prompt.text).toContain("<@id> pings that user in Discord")
+    expect(prompt.text).toContain("use the participants list to map server nicknames/display names")
+    expect(prompt.text).toContain("When a display name is shared")
     expect(prompt.text).toContain("combine the discord default scope or message target override with the header messageId")
     expect(prompt.text).toContain("Do not emit @everyone, @here, or role pings")
     expect(prompt.text).toContain("(discord default scope: guildId=g1 channelId=c1)")
-    expect(prompt.text).toContain("[Nick 3 | <@u-3> | 2026-06-05 14:03 UTC | messageId=3]")
+    expect(prompt.text).toContain("[Nick 3 | 2026-06-05 14:03 UTC | messageId=3]")
     expect(prompt.text).not.toContain("(discord target: guildId=g1 channelId=c1 messageId=3)")
   })
 
@@ -73,11 +77,32 @@ describe("context assembly", () => {
     })
 
     expect(prompt.text).toContain("(discord default scope: guildId=g1 channelId=c1)")
-    expect(prompt.text).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC | messageId=1]")
+    expect(prompt.text).toContain("[Nick 1 | 2026-06-05 14:03 UTC | messageId=1]")
     expect(prompt.text).toContain("(discord target: guildId=g1 channelId=c2 threadId=t2)")
     expect(prompt.text).not.toContain("(discord target: guildId=g1 channelId=c1)")
   })
 
+  test("keeps author ids in headers when participant labels collide", () => {
+    const first = makeMessage("1", "from first Sam", {
+      author: { id: "sam-1", displayName: "Sam", nickname: "Sam", isBot: false }
+    })
+    const second = makeMessage("2", "from second Sam", {
+      author: { id: "sam-2", displayName: "Sam", nickname: "Sam", isBot: false }
+    })
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [first],
+      triggerMessage: second,
+      maxMessages: 30,
+      maxChars: 10_000,
+      maxAttachmentBytes: 10_000
+    })
+
+    expect(prompt.text).toContain("(participants)\nSam - <@sam-1>\nSam - <@sam-2>")
+    expect(prompt.text).toContain("[Sam | <@sam-1> | 2026-06-05 14:03 UTC | messageId=1]")
+    expect(prompt.text).toContain("[Sam | <@sam-2> | 2026-06-05 14:03 UTC | messageId=2]")
+  })
+
   test("applies top-N and character budgets without dropping the trigger", () => {
     const trigger = makeMessage("5", "trigger")
     const prompt = assembleContextPrompt({

package/src/Orchestrator/ContextAssembly.ts

@@ -18,7 +18,7 @@ type ContextInput = {
 }
 
 const preamble = (botUserId: string) =>
-  `Discord bridge context for <@${botUserId}>. Plain assistant text is streamed to Discord automatically; do not use bridge tools to send messages. <@id> pings that user in Discord. For non-message bridge tools, combine the discord default scope or message target override with the header messageId. Do not emit @everyone, @here, or role pings unless explicitly allowed.`
+  `Discord bridge context for <@${botUserId}>. Plain assistant text is streamed to Discord automatically; do not use bridge tools to send messages. <@id> pings that user in Discord; use the participants list to map server nicknames/display names to their <@id> values. When a display name is shared, the message header also includes that author's <@id>. For non-message bridge tools, combine the discord default scope or message target override with the header messageId. Do not emit @everyone, @here, or role pings unless explicitly allowed.`
 
 const timestamp = (value: string): string => {
   const date = new Date(value)
@@ -72,10 +72,53 @@ const attachmentParts = (messages: ReadonlyArray<DiscordMessage>, maxBytes: numb
     })
   )
 
-export const formatDiscordMessage = (message: DiscordMessage, defaultScope?: DiscordScope): string => {
-  const label = message.author.nickname ?? message.author.displayName
+const authorLabel = (message: DiscordMessage): string => message.author.nickname ?? message.author.displayName
+
+type ParticipantsSummary = {
+  readonly text: string | undefined
+  readonly ambiguousAuthorIds: ReadonlySet<string>
+}
+
+const participantsSummary = (messages: ReadonlyArray<DiscordMessage>): ParticipantsSummary => {
+  const participants: Array<{ readonly id: string; readonly label: string }> = []
+  const seenAuthorIds = new Set<string>()
+  const authorIdsByLabel = new Map<string, Set<string>>()
+
+  for (const message of messages) {
+    const id = message.author.id
+    if (seenAuthorIds.has(id)) continue
+    seenAuthorIds.add(id)
+
+    const label = authorLabel(message)
+    participants.push({ id, label })
+
+    const authorIds = authorIdsByLabel.get(label)
+    if (authorIds === undefined) authorIdsByLabel.set(label, new Set([id]))
+    else authorIds.add(id)
+  }
+
+  const ambiguousAuthorIds = new Set<string>()
+  for (const authorIds of authorIdsByLabel.values()) {
+    if (authorIds.size <= 1) continue
+    for (const id of authorIds) ambiguousAuthorIds.add(id)
+  }
+
+  return {
+    ambiguousAuthorIds,
+    text:
+      participants.length === 0 ? undefined : `(participants)\n${participants.map((item) => `${item.label} - <@${item.id}>`).join("\n")}`
+  }
+}
+
+export const formatDiscordMessage = (
+  message: DiscordMessage,
+  defaultScope?: DiscordScope,
+  ambiguousAuthorIds?: ReadonlySet<string>
+): string => {
+  const label = authorLabel(message)
+  const author = ambiguousAuthorIds?.has(message.author.id) === true ? `${label} | <@${message.author.id}>` : label
   const scope = scopeOf(message)
-  const lines = [`[${label} | <@${message.author.id}> | ${timestamp(message.timestamp)} | messageId=${message.id}]`, message.content]
+  const lines = [`[${author} | ${timestamp(message.timestamp)} | messageId=${message.id}]`, message.content]
   if (defaultScope === undefined || !sameScope(scope, defaultScope)) lines.push(targetSummary(scope))
   const attachments = attachmentSummary(message)
   const reactions = reactionSummary(message)
@@ -115,11 +158,14 @@ const renderPrompt = (
   const skippedIds = new Set(skippedMessages.map((message) => message.id))
   const latestMessage = messages.at(-1)
   const defaultScope = latestMessage === undefined ? undefined : scopeOf(latestMessage)
+  const participants = participantsSummary(messages)
   return [
     preamble(botUserId),
+    ...(participants.text === undefined ? [] : [participants.text]),
     ...(defaultScope === undefined ? [] : [defaultScopeSummary(defaultScope)]),
     ...messages.map(
-      (message) => `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message, defaultScope)}`
+      (message) =>
+        `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message, defaultScope, participants.ambiguousAuthorIds)}`
     )
   ].join("\n\n")
 }

package/src/Tools/DiscordAddReactionTool.ts

@@ -0,0 +1,29 @@
+import { tool } from "@opencode-ai/plugin"
+
+const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
+
+const targetSchema = tool.schema
+  .object({
+    guildId: tool.schema.string().describe("Discord guild ID."),
+    channelId: tool.schema.string().describe("Discord channel ID."),
+    threadId: tool.schema.string().optional().describe("Discord thread ID, when targeting a thread."),
+    messageId: tool.schema.string().describe("Discord message ID to react to.")
+  })
+  .describe("Discord message target for the reaction.")
+
+export default tool({
+  description: "Add an emoji reaction to a Discord message through the local opencode-discord-bot process.",
+  args: {
+    target: targetSchema,
+    emoji: tool.schema.string().describe("Emoji to add as a reaction.")
+  },
+  async execute(request) {
+    const response = await fetch(loopbackToolUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ action: "addReaction", target: request.target, args: { emoji: request.emoji } })
+    })
+    const payload = await response.json()
+    return JSON.stringify(payload, null, 2) ?? String(payload)
+  }
+})

package/src/Tools/DiscordAttachFileTool.ts

@@ -0,0 +1,28 @@
+import { tool } from "@opencode-ai/plugin"
+
+const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
+
+const targetSchema = tool.schema
+  .object({
+    guildId: tool.schema.string().describe("Discord guild ID."),
+    channelId: tool.schema.string().describe("Discord channel ID."),
+    threadId: tool.schema.string().optional().describe("Discord thread ID, when targeting a thread.")
+  })
+  .describe("Discord channel or thread target for file attachment.")
+
+export default tool({
+  description: "Attach a generated project file to Discord through the local opencode-discord-bot process.",
+  args: {
+    target: targetSchema,
+    path: tool.schema.string().describe("Project-relative file path to attach.")
+  },
+  async execute(request) {
+    const response = await fetch(loopbackToolUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ action: "attachFile", target: request.target, args: { path: request.path } })
+    })
+    const payload = await response.json()
+    return JSON.stringify(payload, null, 2) ?? String(payload)
+  }
+})

package/src/Tools/DiscordCreateThreadTool.ts

@@ -0,0 +1,28 @@
+import { tool } from "@opencode-ai/plugin"
+
+const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
+
+const targetSchema = tool.schema
+  .object({
+    guildId: tool.schema.string().describe("Discord guild ID."),
+    channelId: tool.schema.string().describe("Discord channel ID."),
+    threadId: tool.schema.string().optional().describe("Discord parent thread ID, when creating inside a thread context.")
+  })
+  .describe("Discord channel target for thread creation.")
+
+export default tool({
+  description: "Create a Discord thread through the local opencode-discord-bot process.",
+  args: {
+    target: targetSchema,
+    name: tool.schema.string().describe("Name for the new Discord thread.")
+  },
+  async execute(request) {
+    const response = await fetch(loopbackToolUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ action: "createThread", target: request.target, args: { name: request.name } })
+    })
+    const payload = await response.json()
+    return JSON.stringify(payload, null, 2) ?? String(payload)
+  }
+})

package/src/Tools/DiscordFetchHistoryTool.ts

@@ -0,0 +1,28 @@
+import { tool } from "@opencode-ai/plugin"
+
+const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
+
+const targetSchema = tool.schema
+  .object({
+    guildId: tool.schema.string().describe("Discord guild ID."),
+    channelId: tool.schema.string().describe("Discord channel ID."),
+    threadId: tool.schema.string().optional().describe("Discord thread ID, when targeting a thread.")
+  })
+  .describe("Discord channel or thread target for history fetching.")
+
+export default tool({
+  description: "Fetch recent Discord message history through the local opencode-discord-bot process.",
+  args: {
+    target: targetSchema,
+    limit: tool.schema.number().int().positive().optional().describe("Maximum number of recent messages to fetch.")
+  },
+  async execute(request) {
+    const response = await fetch(loopbackToolUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ action: "fetchHistory", target: request.target, args: { limit: request.limit } })
+    })
+    const payload = await response.json()
+    return JSON.stringify(payload, null, 2) ?? String(payload)
+  }
+})

package/src/Tools/Scaffolding.test.ts

@@ -1,56 +1,85 @@
 import { describe, expect, test } from "bun:test"
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 import { ensureDiscordTools, renderDiscordToolFile } from "./Scaffolding.ts"
 
+const toolFiles = ["discord-add-reaction.ts", "discord-fetch-history.ts", "discord-attach-file.ts", "discord-create-thread.ts"] as const
+
+const sourceUrls = [
+  new URL("./DiscordAddReactionTool.ts", import.meta.url),
+  new URL("./DiscordFetchHistoryTool.ts", import.meta.url),
+  new URL("./DiscordAttachFileTool.ts", import.meta.url),
+  new URL("./DiscordCreateThreadTool.ts", import.meta.url)
+] as const
+
+const exists = async (path: string): Promise<boolean> =>
+  stat(path).then(
+    () => true,
+    () => false
+  )
+
 describe("Discord tool scaffolding", () => {
-  test("renders a generated opencode tool file with the injected loopback URL", async () => {
-    const source = await renderDiscordToolFile("http://127.0.0.1:8787")
-
-    expect(source).toContain("Generated by opencode-discord-bot")
-    expect(source).toContain("http://127.0.0.1:8787/tool")
-    expect(source).toContain('import { tool } from "@opencode-ai/plugin"')
-    expect(source).toContain("export default tool({")
-    expect(source).toContain("args: {")
-    expect(source).toContain(".enum([")
-    expect(source).toContain('"fetchHistory"')
-    expect(source).toContain('"addReaction"')
-    expect(source).not.toContain('"followUpMessage"')
-    expect(source).not.toContain('"postOtherChannel"')
-    expect(source).toContain(".record(tool.schema.string(), tool.schema.unknown())")
-    expect(source).toContain("fetch")
-    expect(source).not.toContain("export const parameters")
-    expect(source).not.toContain("__OPENCODE_DISCORD_BOT_LOOPBACK_URL__")
+  test("renders generated split opencode tool files with typed action arguments", async () => {
+    const sources = await Promise.all(sourceUrls.map((sourceUrl) => renderDiscordToolFile(sourceUrl, "http://127.0.0.1:8787")))
+    const combined = sources.join("\n")
+
+    for (const source of sources) {
+      expect(source).toContain("Generated by opencode-discord-bot")
+      expect(source).toContain("http://127.0.0.1:8787/tool")
+      expect(source).toContain('import { tool } from "@opencode-ai/plugin"')
+      expect(source).toContain("export default tool({")
+      expect(source).toContain("target: targetSchema")
+      expect(source).toContain("fetch")
+      expect(source).not.toContain("export const parameters")
+      expect(source).not.toContain("__OPENCODE_DISCORD_BOT_LOOPBACK_URL__")
+      expect(source).not.toContain("tool.schema.unknown")
+      expect(source).not.toContain(".record(")
+    }
+
+    expect(combined).toContain('action: "addReaction"')
+    expect(combined).toContain('action: "fetchHistory"')
+    expect(combined).toContain('action: "attachFile"')
+    expect(combined).toContain('action: "createThread"')
+    expect(combined).toContain("emoji:")
+    expect(combined).toContain("limit:")
+    expect(combined).toContain("path:")
+    expect(combined).toContain("name:")
+    expect(combined).not.toContain("removeReaction")
+    expect(combined).not.toContain("editOwnMessage")
+    expect(combined).not.toContain("deleteOwnMessage")
+    expect(combined).not.toContain('action: "pin"')
+    expect(combined).not.toContain('action: "unpin"')
   })
 
-  test("creates and regenerates the tool file on every run", async () => {
+  test("creates and regenerates split tool files on every run", async () => {
     const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tools-"))
 
     try {
       const created = await ensureDiscordTools({ projectDir, bridgePort: 8787, enabled: true, autoInstall: true })
-      const toolPath = join(projectDir, ".opencode", "tools", "discord-bridge.ts")
-      const first = await readFile(toolPath, "utf8")
+      const toolPaths = toolFiles.map((file) => join(projectDir, ".opencode", "tools", file))
+      const first = await readFile(toolPaths[0] ?? "", "utf8")
 
-      expect(created).toEqual([toolPath])
+      expect(created).toEqual(toolPaths)
       expect(first).toContain("http://127.0.0.1:8787/tool")
 
       await ensureDiscordTools({ projectDir, bridgePort: 9999, enabled: true, autoInstall: true })
-      expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:9999/tool")
+      for (const toolPath of toolPaths) expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:9999/tool")
 
-      await writeFile(toolPath, "// operator file\n")
+      await writeFile(toolPaths[0] ?? "", "// operator file\n")
       const regenerated = await ensureDiscordTools({ projectDir, bridgePort: 7777, enabled: true, autoInstall: true })
 
-      expect(regenerated).toEqual([toolPath])
-      expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:7777/tool")
-      expect(await readFile(toolPath, "utf8")).not.toContain("// operator file")
+      expect(regenerated).toEqual(toolPaths)
+      expect(await readFile(toolPaths[0] ?? "", "utf8")).toContain("http://127.0.0.1:7777/tool")
+      expect(await readFile(toolPaths[0] ?? "", "utf8")).not.toContain("// operator file")
 
-      await writeFile(toolPath, "// Generated by opencode-discord-bot. DO NOT EDIT.\nexport const parameters = {}\n")
+      const deprecatedToolPath = join(projectDir, ".opencode", "tools", "discord-bridge.ts")
+      await writeFile(deprecatedToolPath, "// Generated by opencode-discord-bot. DO NOT EDIT.\nexport const parameters = {}\n")
       const migrated = await ensureDiscordTools({ projectDir, bridgePort: 6666, enabled: true, autoInstall: true })
 
-      expect(migrated).toEqual([toolPath])
-      expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:6666/tool")
-      expect(await readFile(toolPath, "utf8")).not.toContain("export const parameters")
+      expect(migrated).toEqual(toolPaths)
+      for (const toolPath of toolPaths) expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:6666/tool")
+      expect(await exists(deprecatedToolPath)).toBe(false)
     } finally {
       await rm(projectDir, { recursive: true, force: true })
     }

package/src/Tools/Scaffolding.ts

@@ -1,9 +1,16 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises"
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 
 const header = "// Generated by opencode-discord-bot. DO NOT EDIT."
 const loopbackUrlPlaceholder = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__"
-const discordToolSourceUrl = new URL("./DiscordBridgeTool.ts", import.meta.url)
+const deprecatedDiscordBridgeFile = "discord-bridge.ts"
+
+const discordToolSources = [
+  { fileName: "discord-add-reaction.ts", sourceUrl: new URL("./DiscordAddReactionTool.ts", import.meta.url) },
+  { fileName: "discord-fetch-history.ts", sourceUrl: new URL("./DiscordFetchHistoryTool.ts", import.meta.url) },
+  { fileName: "discord-attach-file.ts", sourceUrl: new URL("./DiscordAttachFileTool.ts", import.meta.url) },
+  { fileName: "discord-create-thread.ts", sourceUrl: new URL("./DiscordCreateThreadTool.ts", import.meta.url) }
+] as const
 
 export type ToolScaffoldOptions = {
   readonly projectDir: string
@@ -12,18 +19,37 @@ export type ToolScaffoldOptions = {
   readonly autoInstall: boolean
 }
 
-export const renderDiscordToolFile = async (loopbackUrl: string): Promise<string> => {
-  const source = await readFile(discordToolSourceUrl, "utf8")
+const isMissingFile = (cause: unknown): boolean => typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT"
+
+const removeDeprecatedGeneratedTool = async (toolsDir: string): Promise<void> => {
+  const toolPath = join(toolsDir, deprecatedDiscordBridgeFile)
+  try {
+    const current = await readFile(toolPath, "utf8")
+    if (current.startsWith(header)) await unlink(toolPath)
+  } catch (cause) {
+    if (!isMissingFile(cause)) throw cause
+  }
+}
+
+export const renderDiscordToolFile = async (sourceUrl: URL, loopbackUrl: string): Promise<string> => {
+  const source = await readFile(sourceUrl, "utf8")
   return `${header}\n${source.replaceAll(loopbackUrlPlaceholder, loopbackUrl)}`
 }
 
 export const ensureDiscordTools = async (options: ToolScaffoldOptions): Promise<ReadonlyArray<string>> => {
   if (!options.enabled || !options.autoInstall) return []
   const toolsDir = join(options.projectDir, ".opencode", "tools")
-  const toolPath = join(toolsDir, "discord-bridge.ts")
-  const next = await renderDiscordToolFile(`http://127.0.0.1:${options.bridgePort}`)
+  const loopbackUrl = `http://127.0.0.1:${options.bridgePort}`
 
   await mkdir(toolsDir, { recursive: true })
-  await writeFile(toolPath, next)
-  return [toolPath]
+  await removeDeprecatedGeneratedTool(toolsDir)
+
+  const toolPaths: Array<string> = []
+  for (const source of discordToolSources) {
+    const toolPath = join(toolsDir, source.fileName)
+    const next = await renderDiscordToolFile(source.sourceUrl, loopbackUrl)
+    await writeFile(toolPath, next)
+    toolPaths.push(toolPath)
+  }
+  return toolPaths
 }

package/src/Tools/DiscordBridgeTool.ts

@@ -1,42 +0,0 @@
-import { tool } from "@opencode-ai/plugin"
-
-const loopbackToolUrl = "__OPENCODE_DISCORD_BOT_LOOPBACK_URL__/tool"
-
-export default tool({
-  description: "Perform non-message Discord bridge actions through the local opencode-discord-bot process.",
-  args: {
-    action: tool.schema
-      .enum([
-        "addReaction",
-        "removeReaction",
-        "fetchHistory",
-        "attachFile",
-        "createThread",
-        "editOwnMessage",
-        "deleteOwnMessage",
-        "pin",
-        "unpin"
-      ])
-      .describe("Discord bridge action to perform."),
-    target: tool.schema
-      .object({
-        guildId: tool.schema.string().optional(),
-        channelId: tool.schema.string().optional(),
-        threadId: tool.schema.string().optional(),
-        messageId: tool.schema.string().optional()
-      })
-      .describe("Discord target for the action."),
-    args: tool.schema
-      .record(tool.schema.string(), tool.schema.unknown())
-      .describe("Action-specific arguments, such as emoji, limit, path, name, or replacement content for editOwnMessage.")
-  },
-  async execute(request) {
-    const response = await fetch(loopbackToolUrl, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(request)
-    })
-    const payload: unknown = await response.json()
-    return JSON.stringify(payload, null, 2) ?? String(payload)
-  }
-})