clawmini 0.0.3 → 0.0.5

package/src/adapter-discord/index.test.ts

@@ -12,6 +12,13 @@ const { mockClientInstance } = vi.hoisted(() => ({
   },
 }));
 
+vi.mock('./state.js', () => ({
+  readDiscordState: vi
+    .fn()
+    .mockResolvedValue({ channelChatMap: { 'channel-123': { chatId: 'default' } } }),
+  updateDiscordState: vi.fn().mockResolvedValue(undefined),
+}));
+
 vi.mock('discord.js', () => {
   return {
     Client: class {
@@ -22,6 +29,24 @@ vi.mock('discord.js', () => {
     Events: {
       ClientReady: 'ready',
       MessageCreate: 'messageCreate',
+      InteractionCreate: 'interactionCreate',
+    },
+    ActionRowBuilder: class {
+      addComponents = vi.fn().mockReturnThis();
+    },
+    ModalBuilder: class {
+      setCustomId = vi.fn().mockReturnThis();
+      setTitle = vi.fn().mockReturnThis();
+      addComponents = vi.fn().mockReturnThis();
+    },
+    TextInputBuilder: class {
+      setCustomId = vi.fn().mockReturnThis();
+      setLabel = vi.fn().mockReturnThis();
+      setStyle = vi.fn().mockReturnThis();
+      setRequired = vi.fn().mockReturnThis();
+    },
+    TextInputStyle: {
+      Paragraph: 2,
     },
     GatewayIntentBits: {
       Guilds: 1,
@@ -38,6 +63,7 @@ vi.mock('./config.js', () => ({
   readDiscordConfig: vi.fn(),
   initDiscordConfig: vi.fn(),
   isAuthorized: vi.fn(),
+  getDiscordConfigPath: vi.fn(),
 }));
 
 vi.mock('./client.js', () => ({
@@ -59,6 +85,8 @@ describe('Discord Adapter Entry Point', () => {
       botToken: 'test-token',
       authorizedUserId: 'user-123',
       chatId: 'default',
+      maxAttachmentSizeMB: 25,
+      requireMention: false,
     });
 
     // Reset the mock implementation to return the instance
@@ -101,6 +129,8 @@ describe('Discord Adapter Entry Point', () => {
       author: { id: 'user-123', tag: 'user#1234' },
       content: 'Hello daemon!',
       guild: null,
+      channelId: 'channel-123',
+      reply: vi.fn(),
       attachments: new Map(),
     };
 
@@ -153,6 +183,8 @@ describe('Discord Adapter Entry Point', () => {
         author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
         content: 'message 1',
         guild: null,
+        channelId: 'channel-123',
+        reply: vi.fn(),
         attachments: new Map(),
       } as unknown as import('discord.js').Message);
       await messageHandler({
@@ -160,6 +192,8 @@ describe('Discord Adapter Entry Point', () => {
         author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
         content: 'message 2',
         guild: null,
+        channelId: 'channel-123',
+        reply: vi.fn(),
         attachments: new Map(),
       } as unknown as import('discord.js').Message);
     }
@@ -209,6 +243,8 @@ describe('Discord Adapter Entry Point', () => {
       author: { id: 'user-evil', tag: 'evil#666' },
       content: 'Hack the daemon!',
       guild: null,
+      channelId: 'channel-123',
+      reply: vi.fn(),
     };
 
     const { isAuthorized } = await import('./config.js');
@@ -221,6 +257,123 @@ describe('Discord Adapter Entry Point', () => {
     expect(mockTrpc.sendMessage.mutate).not.toHaveBeenCalled();
   });
 
+  it('should process non-DM (guild) messages if requireMention is false', async () => {
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const mockMessage = {
+      author: { id: 'user-123', tag: 'user#1234' },
+      content: 'Hack the daemon!',
+      guild: { id: 'guild-123' },
+      channelId: 'channel-123',
+      reply: vi.fn(),
+      attachments: new Map(),
+    };
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    if (messageHandler) {
+      await messageHandler(mockMessage as unknown as import('discord.js').Message);
+    }
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalled();
+  });
+
+  it('should NOT process non-DM (guild) messages if channel requireMention is true and not mentioned', async () => {
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const mockMessage = {
+      author: { id: 'user-123', tag: 'user#1234' },
+      content: 'Hack the daemon!',
+      guild: { id: 'guild-123' },
+      channelId: 'channel-123',
+      reply: vi.fn(),
+      mentions: { has: vi.fn().mockReturnValue(false) },
+      attachments: new Map(),
+    };
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    const { readDiscordState } = await import('./state.js');
+    vi.mocked(readDiscordState).mockResolvedValue({
+      channelChatMap: { 'channel-123': { chatId: 'default', requireMention: true } },
+    });
+
+    if (messageHandler) {
+      await messageHandler(mockMessage as unknown as import('discord.js').Message);
+    }
+
+    expect(mockTrpc.sendMessage.mutate).not.toHaveBeenCalled();
+  });
+
+  it('should process non-DM (guild) messages if channel requireMention is true and IS mentioned', async () => {
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const mockMessage = {
+      author: { id: 'user-123', tag: 'user#1234' },
+      content: 'Hack the daemon!',
+      guild: { id: 'guild-123' },
+      channelId: 'channel-123',
+      reply: vi.fn(),
+      mentions: { has: vi.fn().mockReturnValue(true) },
+      attachments: new Map(),
+    };
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    const { readDiscordState } = await import('./state.js');
+    vi.mocked(readDiscordState).mockResolvedValue({
+      channelChatMap: { 'channel-123': { chatId: 'default', requireMention: true } },
+    });
+
+    if (messageHandler) {
+      await messageHandler(mockMessage as unknown as import('discord.js').Message);
+    }
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalled();
+  });
+
   it('should download attachments and forward their paths', async () => {
     vi.useFakeTimers();
     let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
@@ -259,6 +412,8 @@ describe('Discord Adapter Entry Point', () => {
         author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
         content: 'Check out this file',
         guild: null,
+        channelId: 'channel-123',
+        reply: vi.fn(),
         attachments,
       } as unknown as import('discord.js').Message);
     }
@@ -319,6 +474,7 @@ describe('Discord Adapter Entry Point', () => {
         author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
         content: 'Check out this huge file',
         guild: null,
+        channelId: 'channel-123',
         attachments,
         reply: replyMock,
       } as unknown as import('discord.js').Message);
@@ -375,6 +531,8 @@ describe('Discord Adapter Entry Point', () => {
         content: "Yes, I'm in!",
         guild: null,
         attachments: new Map(),
+        channelId: 'channel-123',
+        reply: vi.fn(),
         reference: { messageId: '12345' },
         fetchReference: vi.fn().mockResolvedValue(mockReferencedMessage),
       } as unknown as import('discord.js').Message);
@@ -396,4 +554,124 @@ describe('Discord Adapter Entry Point', () => {
     });
     vi.useRealTimers();
   });
+
+  describe('Interaction Handling', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let interactionHandler: ((interaction: any) => Promise<void>) | undefined;
+
+    beforeEach(async () => {
+      vi.mocked(mockClientInstance.on).mockImplementation(
+        (event: string, cb: (...args: unknown[]) => void) => {
+          if (event === 'interactionCreate') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            interactionHandler = cb as any;
+          }
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return mockClientInstance as any;
+        }
+      );
+      const { main } = await import('./index.js');
+      await main();
+      const { isAuthorized } = await import('./config.js');
+      vi.mocked(isAuthorized).mockReturnValue(true);
+    });
+
+    it('should ignore non-button and non-modal interactions', async () => {
+      const mockInteraction = {
+        isButton: () => false,
+        isModalSubmit: () => false,
+      };
+      if (interactionHandler) await interactionHandler(mockInteraction);
+      expect(mockTrpc.sendMessage.mutate).not.toHaveBeenCalled();
+    });
+
+    it('should ignore unauthorized interactions', async () => {
+      const { isAuthorized } = await import('./config.js');
+      vi.mocked(isAuthorized).mockReturnValue(false);
+      const mockInteraction = {
+        isButton: () => true,
+        isModalSubmit: () => false,
+        isRepliable: () => true,
+        user: { id: 'unauth' },
+        reply: vi.fn(),
+      };
+      if (interactionHandler) await interactionHandler(mockInteraction);
+      expect(mockInteraction.reply).toHaveBeenCalledWith({
+        content: 'You are not authorized to perform this action.',
+        ephemeral: true,
+      });
+      expect(mockTrpc.sendMessage.mutate).not.toHaveBeenCalled();
+    });
+
+    it('should handle approve button interaction', async () => {
+      const mockInteraction = {
+        isButton: () => true,
+        isModalSubmit: () => false,
+        user: { id: 'user-123' },
+        customId: 'approve_123',
+        update: vi.fn(),
+        followUp: vi.fn(),
+      };
+      if (interactionHandler) await interactionHandler(mockInteraction);
+      expect(mockInteraction.update).toHaveBeenCalledWith({ components: [] });
+      expect(mockInteraction.followUp).toHaveBeenCalledWith({
+        content: 'Approving policy 123...',
+        ephemeral: true,
+      });
+      expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: '/approve 123',
+          chatId: 'default',
+          adapter: 'discord',
+          noWait: true,
+        },
+      });
+    });
+
+    it('should handle reject button interaction by showing a modal', async () => {
+      const mockInteraction = {
+        isButton: () => true,
+        isModalSubmit: () => false,
+        user: { id: 'user-123' },
+        customId: 'reject_123',
+        showModal: vi.fn(),
+      };
+      if (interactionHandler) await interactionHandler(mockInteraction);
+      expect(mockInteraction.showModal).toHaveBeenCalled();
+    });
+
+    it('should handle reject modal submit interaction', async () => {
+      const mockInteraction = {
+        isButton: () => false,
+        isModalSubmit: () => true,
+        isFromMessage: () => true,
+        user: { id: 'user-123' },
+        customId: 'modal_reject_123',
+        fields: {
+          getTextInputValue: vi.fn().mockReturnValue('bad policy'),
+        },
+        reply: vi.fn(),
+        update: vi.fn(),
+        followUp: vi.fn(),
+      };
+      if (interactionHandler) await interactionHandler(mockInteraction);
+      expect(mockInteraction.update).toHaveBeenCalledWith({ components: [] });
+      expect(mockInteraction.followUp).toHaveBeenCalledWith({
+        content: 'Rejecting policy 123...',
+        ephemeral: true,
+      });
+      expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: '/reject 123 bad policy',
+          chatId: 'default',
+          adapter: 'discord',
+          noWait: true,
+        },
+      });
+    });
+  });
 });

package/src/adapter-discord/index.ts

@@ -2,11 +2,16 @@
 
 import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
 import { readDiscordConfig, isAuthorized, initDiscordConfig } from './config.js';
+import { readDiscordState, updateDiscordState } from './state.js';
+import { handleDiscordInteraction } from './interactions.js';
 import { getTRPCClient } from './client.js';
 import { startDaemonToDiscordForwarder } from './forwarder.js';
 import { getClawminiDir } from '../shared/workspace.js';
+import { handleAdapterCommand, type CommandTrpcClient } from '../shared/adapters/commands.js';
+import { formatMessage, type FilteringConfig } from '../shared/adapters/filtering.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { handleRoutingCommand, type RoutingTrpcClient } from '../shared/adapters/routing.js';
 
 export async function main() {
   const args = process.argv.slice(2);
@@ -29,27 +34,69 @@ export async function main() {
   const trpc = getTRPCClient();
 
   const client = new Client({
-    intents: [GatewayIntentBits.DirectMessages, GatewayIntentBits.MessageContent],
+    intents: [
+      GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+    ],
     partials: [Partials.Channel],
   });
 
+  const state = await readDiscordState();
+  const filteringConfig: FilteringConfig = { filters: state.filters };
+
   client.once(Events.ClientReady, (readyClient) => {
     console.log(`Ready! Logged in as ${readyClient.user.tag}`);
 
     // Start forwarding from daemon to Discord
-    startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, config.chatId).catch(
-      (error) => {
-        console.error('Error in daemon-to-discord forwarder:', error);
-      }
-    );
+    startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, {
+      chatId: config.chatId,
+      config: filteringConfig,
+    }).catch((error) => {
+      console.error('Error in daemon-to-discord forwarder:', error);
+    });
   });
 
   client.on(Events.MessageCreate, async (message) => {
     // Ignore messages from the bot itself
     if (message.author.id === client.user?.id) return;
+    if (message.author.bot) return;
+
+    const externalContextId = message.channelId;
+    const currentState = await readDiscordState();
+    const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
+    const isRoutingCommand =
+      message.content.startsWith('/chat') || message.content.startsWith('/agent');
+
+    // Enforce requireMention config for guild messages
+    if (message.guild) {
+      const channelConfig = currentState.channelChatMap?.[externalContextId];
+      const requiresMention =
+        channelConfig?.requireMention !== undefined
+          ? channelConfig.requireMention
+          : config.requireMention;
+
+      if (requiresMention) {
+        const isMentioned = message.mentions.has(client.user!.id);
+        let isReplyToBot = false;
 
-    // Only handle DM messages
-    if (message.guild) return;
+        if (message.reference && message.reference.messageId) {
+          try {
+            const referencedMessage = await message.channel.messages.fetch(
+              message.reference.messageId
+            );
+            isReplyToBot = referencedMessage.author.id === client.user!.id;
+          } catch (err) {
+            console.error('Failed to fetch referenced message for mention check:', err);
+          }
+        }
+
+        if (!isMentioned && !isReplyToBot) {
+          return;
+        }
+      }
+    }
 
     // Check if the user is authorized
     if (!isAuthorized(message.author.id, config.authorizedUserId)) {
@@ -61,6 +108,102 @@ export async function main() {
 
     console.log(`Received message from ${message.author.tag}: ${message.content}`);
 
+    if (isRoutingCommand) {
+      const stringChatMap = Object.fromEntries(
+        Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ''])
+      );
+      const routingResult = await handleRoutingCommand(
+        message.content,
+        externalContextId,
+        stringChatMap,
+        'discord',
+        trpc as unknown as RoutingTrpcClient
+      );
+
+      if (routingResult) {
+        if (routingResult.type === 'mapped') {
+          await updateDiscordState((latestState) => ({
+            channelChatMap: {
+              ...(latestState.channelChatMap || {}),
+              [externalContextId]: {
+                ...(latestState.channelChatMap?.[externalContextId] || {}),
+                chatId: routingResult.newChatId,
+              },
+            },
+          }));
+        }
+        await message.reply(routingResult.text);
+        return;
+      }
+    }
+
+    let targetChatId = mappedChatId;
+
+    if (!targetChatId && !isRoutingCommand) {
+      const isFirstEverMessage =
+        !currentState.channelChatMap ||
+        Object.values(currentState.channelChatMap).every((entry) => !entry.chatId);
+
+      if (isFirstEverMessage) {
+        targetChatId = config.chatId || 'default';
+        console.log(
+          `First contact detected. Automatically mapping channel ${externalContextId} to chat ${targetChatId}.`
+        );
+        await updateDiscordState((latestState) => ({
+          channelChatMap: {
+            ...(latestState.channelChatMap || {}),
+            [externalContextId]: {
+              ...(latestState.channelChatMap?.[externalContextId] || {}),
+              chatId: targetChatId as string,
+            },
+          },
+        }));
+      } else {
+        const isDirectMessage = !message.guild;
+        const isMentioned = message.mentions.has(client.user!.id);
+        const isSlashCommand = message.content.startsWith('/');
+        if (isDirectMessage || isMentioned || isSlashCommand) {
+          console.log(`Unmapped channel ${externalContextId}, sending first contact warning.`);
+          await message.reply(
+            'This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it.'
+          );
+        } else {
+          console.log(
+            `Unmapped channel ${externalContextId}, silently ignoring background message.`
+          );
+        }
+        return;
+      }
+    }
+
+    // Fallback typing safeguard
+    if (!targetChatId) targetChatId = config.chatId || 'default';
+
+    const commandResult = await handleAdapterCommand(
+      message.content,
+      filteringConfig,
+      trpc as unknown as CommandTrpcClient,
+      targetChatId
+    );
+
+    if (commandResult) {
+      if (commandResult.type === 'text') {
+        if (commandResult.newConfig) {
+          filteringConfig.filters = commandResult.newConfig.filters;
+          await updateDiscordState({ filters: filteringConfig.filters });
+        }
+        await message.reply(commandResult.text);
+      } else if (commandResult.type === 'debug') {
+        const formatted =
+          commandResult.messages.length === 0
+            ? 'No ignored background messages found.'
+            : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` +
+              commandResult.messages.map((msg) => formatMessage(msg)).join('\n\n---\n\n');
+        await message.reply(formatted);
+      }
+      return;
+    }
+
     const downloadedFiles: string[] = [];
     if (message.attachments.size > 0) {
       const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'discord');
@@ -121,7 +264,7 @@ export async function main() {
         client: 'cli',
         data: {
           message: finalContent,
-          chatId: config.chatId,
+          chatId: targetChatId,
           files: downloadedFiles.length > 0 ? downloadedFiles : undefined,
           adapter: 'discord',
           noWait: true,
@@ -133,6 +276,10 @@ export async function main() {
     }
   });
 
+  client.on(Events.InteractionCreate, async (interaction) => {
+    await handleDiscordInteraction(interaction, config, trpc as unknown as CommandTrpcClient);
+  });
+
   try {
     await client.login(config.botToken);
   } catch (error) {
@@ -141,24 +288,7 @@ export async function main() {
   }
 }
 
-import { fileURLToPath } from 'node:url';
-
-const isMainModule = (() => {
-  try {
-    if (typeof process === 'undefined' || !process.argv || process.argv.length < 2) return false;
-    const argv1 = process.argv[1];
-    if (!argv1) return false;
-    const p1 = path.resolve(argv1);
-    const p2 = path.resolve(fileURLToPath(import.meta.url));
-    return p1 === p2;
-  } catch {
-    return false;
-  }
-})();
-
-if (isMainModule) {
-  main().catch((error) => {
-    console.error('Unhandled error in Discord Adapter:', error);
-    process.exit(1);
-  });
-}
+main().catch((error) => {
+  console.error('Unhandled error in Discord Adapter:', error);
+  process.exit(1);
+});

package/src/adapter-discord/interactions.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleDiscordInteraction } from './interactions.js';
+import { readDiscordState } from './state.js';
+
+vi.mock('./state.js', () => ({
+  readDiscordState: vi.fn(),
+}));
+
+describe('handleDiscordInteraction', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let mockTrpc: any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let mockInteraction: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockTrpc = {
+      sendMessage: {
+        mutate: vi.fn().mockResolvedValue({}),
+      },
+    };
+    mockInteraction = {
+      isButton: vi.fn().mockReturnValue(true),
+      isModalSubmit: vi.fn().mockReturnValue(false),
+      user: { id: 'user-1' },
+      customId: '',
+      channelId: 'channel-1',
+      update: vi.fn().mockResolvedValue({}),
+      followUp: vi.fn().mockResolvedValue({}),
+      showModal: vi.fn().mockResolvedValue({}),
+    };
+    vi.mocked(readDiscordState).mockResolvedValue({});
+  });
+
+  const config = {
+    authorizedUserId: 'user-1',
+    botToken: 'token',
+    clientId: 'client',
+    chatId: 'default',
+    maxAttachmentSizeMB: 10,
+    requireMention: false,
+  };
+
+  it('routes approve to explicit chat if provided', async () => {
+    mockInteraction.customId = 'approve|policy-1|explicit-chat';
+    await handleDiscordInteraction(mockInteraction, config, mockTrpc);
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          chatId: 'explicit-chat',
+        }),
+      })
+    );
+  });
+
+  it('routes approve to channel mapped chat if explicit not provided', async () => {
+    mockInteraction.customId = 'approve_policy-1';
+    vi.mocked(readDiscordState).mockResolvedValue({
+      channelChatMap: { 'channel-1': { chatId: 'mapped-chat' } },
+    });
+    await handleDiscordInteraction(mockInteraction, config, mockTrpc);
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          chatId: 'mapped-chat',
+        }),
+      })
+    );
+  });
+
+  it('routes modal_reject to mapped chat if explicit chat ID is empty string', async () => {
+    mockInteraction.isButton.mockReturnValue(false);
+    mockInteraction.isModalSubmit.mockReturnValue(true);
+    mockInteraction.isFromMessage = vi.fn().mockReturnValue(true);
+    mockInteraction.fields = {
+      getTextInputValue: vi.fn().mockReturnValue('nope'),
+    };
+    mockInteraction.customId = 'modal_reject|policy-1|';
+
+    vi.mocked(readDiscordState).mockResolvedValue({
+      channelChatMap: { 'channel-1': { chatId: 'mapped-chat' } },
+    });
+
+    await handleDiscordInteraction(mockInteraction, config, mockTrpc);
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          chatId: 'mapped-chat',
+        }),
+      })
+    );
+  });
+});