@desplega.ai/agent-swarm 1.67.3 → 1.67.4

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.67.3",
+    "version": "1.67.4",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.67.3",
+  "version": "1.67.4",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/slack/handlers.ts

@@ -13,7 +13,7 @@ import { resolveTemplate } from "../prompts/resolver";
 import { workflowEventBus } from "../workflows/event-bus";
 import { buildTreeBlocks, type TreeNode } from "./blocks";
 import type { SlackFile } from "./files";
-import { extractTaskFromMessage, routeMessage } from "./router";
+import { extractTaskFromMessage, hasOtherUserMention, routeMessage } from "./router";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
 import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
@@ -162,6 +162,12 @@ interface MessageEvent {
  * - `bot_id` present (newer Slack API, may lack subtype)
  * - `user` matches the bot's own user ID (catches edge cases where
  *    messages posted with `username` override lack `bot_id`)
+ *
+ * Note: intentionally does NOT filter on `app_id`/`bot_profile`/`username` —
+ * those signals also appear on human messages sent via Slack apps that proxy
+ * a user (e.g. Claude.ai's Slack integration sends with `app_id` + `bot_profile`
+ * set, but the poster is still a real human). Filtering those drops legitimate
+ * human @mentions of the swarm.
  */
 export function isBotMessage(
   event: { subtype?: string; bot_id?: string; user?: string },
@@ -439,8 +445,17 @@ export function registerMessageHandler(app: App): void {
       }
     }
 
-    // ADDITIVE_SLACK: Buffer non-mention thread messages
+    // ADDITIVE_SLACK: Buffer non-mention thread messages.
+    // Skip if the message @-mentions someone other than our bot (e.g. "@Devin wdyt?"):
+    // that message is directed at a different bot/user and must not be fed to
+    // the swarm as an implicit follow-up.
     if (additiveSlack && !botMentioned && msg.thread_ts && !requireMentionForThreadFollowup) {
+      if (hasOtherUserMention(effectiveText, botUserId)) {
+        console.log(
+          `[Slack] Skipping ADDITIVE buffer in ${msg.channel}/${msg.thread_ts}: message mentions another user`,
+        );
+        return;
+      }
       // Check if this thread has any swarm activity (existing tasks)
       const hasSwarmActivity = getAgentWorkingOnThread(msg.channel, msg.thread_ts) !== null;
 

package/src/slack/router.ts

@@ -6,6 +6,15 @@ export interface ThreadContext {
   threadTs: string;
 }
 
+/**
+ * Returns true if the text contains a `<@U...>` mention of anyone other than our bot.
+ * Exported for testing.
+ */
+export function hasOtherUserMention(text: string, botUserId: string): boolean {
+  const mentions = text.match(/<@([A-Z0-9]+)>/g) ?? [];
+  return mentions.some((m) => m !== `<@${botUserId}>`);
+}
+
 /**
  * Routes a Slack message to the appropriate agent(s) based on mentions.
  *
@@ -16,7 +25,7 @@ export interface ThreadContext {
  */
 export function routeMessage(
   text: string,
-  _botUserId: string,
+  botUserId: string,
   botMentioned: boolean,
   threadContext?: ThreadContext,
 ): AgentMatch[] {
@@ -46,8 +55,17 @@ export function routeMessage(
     }
   }
 
-  // Thread follow-up — route to agent already working in this thread
+  // Thread follow-up — route to agent already working in this thread.
+  // Skip if the message @-mentions someone other than our bot (e.g. "@Devin wdyt?")
+  // and does not mention our bot: that message is directed at a different bot/user,
+  // not a follow-up intended for the swarm.
   if (matches.length === 0 && threadContext && (!requireMentionForThreadFollowup || botMentioned)) {
+    if (!botMentioned && hasOtherUserMention(text, botUserId)) {
+      console.log(
+        `[Slack] Skipping thread follow-up in ${threadContext.channelId}/${threadContext.threadTs}: message mentions another user`,
+      );
+      return matches;
+    }
     const workingAgent = getAgentWorkingOnThread(threadContext.channelId, threadContext.threadTs);
     if (workingAgent && workingAgent.status !== "offline") {
       console.log(

package/src/tests/slack-bot-filter.test.ts

@@ -0,0 +1,156 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import { closeDb, createAgent, createTaskExtended, initDb } from "../be/db";
+import { isBotMessage } from "../slack/handlers";
+import { hasOtherUserMention, routeMessage } from "../slack/router";
+import type { Agent } from "../types";
+
+const TEST_DB_PATH = "./test-slack-bot-filter.sqlite";
+
+let leadAgent: Agent;
+let workerAgent: Agent;
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  leadAgent = createAgent({
+    name: "filter-lead",
+    isLead: true,
+    status: "idle",
+    capabilities: [],
+  });
+  workerAgent = createAgent({
+    name: "filter-worker",
+    isLead: false,
+    status: "idle",
+    capabilities: [],
+  });
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+});
+
+describe("isBotMessage", () => {
+  const BOT_ID = "UBOT123";
+
+  test("plain human message → false", () => {
+    expect(isBotMessage({ user: "UHUMAN" }, BOT_ID)).toBe(false);
+  });
+
+  test("subtype bot_message → true", () => {
+    expect(isBotMessage({ subtype: "bot_message", user: "UHUMAN" }, BOT_ID)).toBe(true);
+  });
+
+  test("bot_id present → true", () => {
+    expect(isBotMessage({ bot_id: "B001", user: "UHUMAN" }, BOT_ID)).toBe(true);
+  });
+
+  test("own bot user ID (self-posted) → true", () => {
+    expect(isBotMessage({ user: BOT_ID }, BOT_ID)).toBe(true);
+  });
+
+  test("empty event with no bot signals → false", () => {
+    expect(isBotMessage({ user: "UHUMAN" }, BOT_ID)).toBe(false);
+  });
+});
+
+describe("hasOtherUserMention", () => {
+  const BOT_ID = "UBOT123";
+
+  test("no mentions → false", () => {
+    expect(hasOtherUserMention("hello everyone", BOT_ID)).toBe(false);
+  });
+
+  test("only our bot mentioned → false", () => {
+    expect(hasOtherUserMention(`hey <@${BOT_ID}> pls`, BOT_ID)).toBe(false);
+  });
+
+  test("different user mentioned → true", () => {
+    expect(hasOtherUserMention("hey <@UDEVIN01> wdyt", BOT_ID)).toBe(true);
+  });
+
+  test("our bot AND another user mentioned → true", () => {
+    expect(hasOtherUserMention(`<@${BOT_ID}> and <@UDEVIN01> hi`, BOT_ID)).toBe(true);
+  });
+});
+
+describe("routeMessage — thread follow-up skips messages aimed at other users", () => {
+  const BOT_ID = "UBOT123";
+
+  test("plain follow-up (no mentions) still routes to active worker", () => {
+    const channelId = "C_BF_100";
+    const threadTs = "1100.0001";
+    createTaskExtended("original", {
+      agentId: workerAgent.id,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      slackUserId: "U_HUMAN",
+    });
+
+    const matches = routeMessage("and also the weather", BOT_ID, false, {
+      channelId,
+      threadTs,
+    });
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].agent.id).toBe(workerAgent.id);
+  });
+
+  test("follow-up mentioning another bot (Devin) does NOT route", () => {
+    const channelId = "C_BF_200";
+    const threadTs = "1200.0001";
+    createTaskExtended("original", {
+      agentId: workerAgent.id,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      slackUserId: "U_HUMAN",
+    });
+
+    const matches = routeMessage("<@UDEVIN01> wdyt?", BOT_ID, false, {
+      channelId,
+      threadTs,
+    });
+
+    expect(matches).toHaveLength(0);
+  });
+
+  test("follow-up mentioning BOTH our bot and another bot routes to swarm", () => {
+    const channelId = "C_BF_300";
+    const threadTs = "1300.0001";
+    createTaskExtended("original", {
+      agentId: workerAgent.id,
+      source: "slack",
+      slackChannelId: channelId,
+      slackThreadTs: threadTs,
+      slackUserId: "U_HUMAN",
+    });
+
+    const matches = routeMessage(`<@${BOT_ID}> and <@UDEVIN01> please coordinate`, BOT_ID, true, {
+      channelId,
+      threadTs,
+    });
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].agent.id).toBe(workerAgent.id);
+  });
+
+  test("no thread activity + only another bot mentioned → no match", () => {
+    const matches = routeMessage("<@UDEVIN01> hi", BOT_ID, false, {
+      channelId: "C_BF_400",
+      threadTs: "1400.0001",
+    });
+
+    expect(matches).toHaveLength(0);
+    // Silence unused lead warning — lead exists but should not be routed to
+    expect(leadAgent.id).toBeDefined();
+  });
+});