Slack: register typed channel/group message event handlers

src/slack/monitor/events/messages.test.ts

@@ -33,6 +33,8 @@ function createMessageHandlers(overrides?: SlackSystemEventTestOverrides) {
   });
   return {
     handler: harness.getHandler("message") as MessageHandler | null,
+    channelHandler: harness.getHandler("message.channels") as MessageHandler | null,
+    groupHandler: harness.getHandler("message.groups") as MessageHandler | null,
     handleSlackMessage,
   };
 }
@@ -156,4 +158,38 @@ describe("registerSlackMessageEvents", () => {
     expect(handleSlackMessage).toHaveBeenCalledTimes(1);
     expect(messageQueueMock).not.toHaveBeenCalled();
   });
+
+  it("registers and forwards message.channels and message.groups events", async () => {
+    messageQueueMock.mockClear();
+    messageAllowMock.mockReset().mockResolvedValue([]);
+    const { channelHandler, groupHandler, handleSlackMessage } = createMessageHandlers({
+      dmPolicy: "open",
+      channelType: "channel",
+    });
+
+    expect(channelHandler).toBeTruthy();
+    expect(groupHandler).toBeTruthy();
+
+    const channelMessage = {
+      type: "message",
+      channel: "C1",
+      channel_type: "channel",
+      user: "U1",
+      text: "hello channel",
+      ts: "123.100",
+    };
+    await channelHandler!({ event: channelMessage, body: {} });
+    await groupHandler!({
+      event: {
+        ...channelMessage,
+        channel_type: "group",
+        channel: "G1",
+        ts: "123.200",
+      },
+      body: {},
+    });
+
+    expect(handleSlackMessage).toHaveBeenCalledTimes(2);
+    expect(messageQueueMock).not.toHaveBeenCalled();
+  });
 });

src/slack/monitor/events/messages.ts

@@ -27,7 +27,7 @@ export function registerSlackMessageEvents(params: {
   const resolveThreadBroadcastSenderId = (thread: SlackThreadBroadcastEvent): string | undefined =>
     thread.user ?? thread.message?.user ?? thread.message?.bot_id;
 
-  ctx.app.event("message", async ({ event, body }: SlackEventMiddlewareArgs<"message">) => {
+  const handleIncomingMessageEvent = async ({ event, body }: { event: unknown; body: unknown }) => {
     try {
       if (ctx.shouldDropMismatchedSlackEvent(body)) {
         return;
@@ -95,6 +95,18 @@ export function registerSlackMessageEvents(params: {
     } catch (err) {
       ctx.runtime.error?.(danger(`slack handler failed: ${String(err)}`));
     }
+  };
+
+  ctx.app.event("message", async ({ event, body }: SlackEventMiddlewareArgs<"message">) => {
+    await handleIncomingMessageEvent({ event, body });
+  });
+  // Slack may dispatch channel/group message subscriptions under typed event
+  // names. Register explicit handlers so both delivery styles are supported.
+  ctx.app.event("message.channels", async ({ event, body }: SlackEventMiddlewareArgs) => {
+    await handleIncomingMessageEvent({ event, body });
+  });
+  ctx.app.event("message.groups", async ({ event, body }: SlackEventMiddlewareArgs) => {
+    await handleIncomingMessageEvent({ event, body });
   });
 
   ctx.app.event("app_mention", async ({ event, body }: SlackEventMiddlewareArgs<"app_mention">) => {