@desplega.ai/agent-swarm 2.7.5 → 2.7.6

package/src/tests/seed-scripts.test.ts

@@ -217,6 +217,32 @@ describe("seed-scripts catalog", () => {
     ).toHaveLength(200);
   });
 
+  test.each([
+    ["Incomplete response returned, reason: max_output_tokens", "output-limit"],
+    ["Stopped: max_tokens", "output-limit"],
+    ["Maximum output length exceeded", "output-limit"],
+    ["Output token limit reached", "output-limit"],
+    ["401 Unauthorized", "auth/credentials"],
+    ["invalid token", "auth/credentials"],
+    ["Resource not accessible by personal access token", "auth/credentials"],
+    ["Processed 100 tokens", "other"],
+    ["max_input_tokens exceeded", "other"],
+  ])("task-failure-audit classifies %s as %s", async (failureReason, expectedKey) => {
+    const result = await taskFailureAudit(
+      { publishPage: false },
+      {
+        swarm: {
+          async task_list() {
+            return { data: { tasks: [{ id: "failed-task", failureReason }] } };
+          },
+        },
+      },
+    );
+
+    expect(result.groups).toHaveLength(1);
+    expect(result.groups[0].key).toBe(expectedKey);
+  });
+
   test("task-failure-audit projects failure reasons into schedule-group samples", async () => {
     let projectionArgs: Record<string, unknown> | undefined;
     const result = await taskFailureAudit(

package/src/tests/slack-leave-thread.test.ts

@@ -9,6 +9,7 @@ import {
   createTaskExtended,
   createWorkflow,
   deleteSwarmConfig,
+  getKv,
   getSlackTasksInThread,
   initDb,
   updateWorkflow,
@@ -19,9 +20,14 @@ import { invokeToolInProcess, resetBridgeServerForTesting } from "../http/mcp-br
 import { handleTasks } from "../http/tasks";
 import { reservedNamespaceError } from "../kv-reserved-namespaces";
 import { createServer as createMcpServer } from "../server";
+import { registerCommandHandler } from "../slack/commands";
 import { registerMessageHandler, resetSlackHandlerCachesForTesting } from "../slack/handlers";
-import { isSlackThreadLeft, SLACK_LEFT_THREAD_KV_NAMESPACE } from "../slack/left-threads";
-import { bufferThreadMessage, instantFlush } from "../slack/thread-buffer";
+import {
+  isSlackThreadLeft,
+  SLACK_LEFT_THREAD_CONFIRMATION,
+  SLACK_LEFT_THREAD_KV_NAMESPACE,
+} from "../slack/left-threads";
+import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "../slack/thread-buffer";
 import { slackContextKey } from "../tasks/context-key";
 import { registerSlackLeaveThreadTool } from "../tools/slack-leave-thread";
 import type { Agent, AgentTask } from "../types";
@@ -45,6 +51,8 @@ const previousEnv = {
 
 type Handler = (args: Record<string, unknown>) => Promise<void>;
 const handlers = new Map<string, Handler>();
+const commands = new Map<string, Handler>();
+const ephemerals: Array<Record<string, unknown>> = [];
 
 const client = {
   auth: { test: async () => ({ user_id: BOT_USER_ID, bot_id: "B_LEAVE_BOT" }) },
@@ -52,7 +60,13 @@ const client = {
     info: async () => ({ ok: true, channel: {} }),
     replies: async () => ({ ok: true, messages: [] }),
   },
-  chat: { postMessage: async () => ({ ok: true, ts: "1.1" }) },
+  chat: {
+    postMessage: async () => ({ ok: true, ts: "1.1" }),
+    postEphemeral: async (args: Record<string, unknown>) => {
+      ephemerals.push(args);
+      return { ok: true };
+    },
+  },
   reactions: { add: async () => ({ ok: true }) },
   users: { info: async () => ({ ok: true, user: { profile: {} } }) },
 };
@@ -99,10 +113,10 @@ let lead: Agent;
 let worker: Agent;
 let otherWorker: Agent;
 
-async function seedThread(channel: string, threadTs: string) {
+async function seedThread(channel: string, threadTs: string, opts: { unassigned?: boolean } = {}) {
   // As the Slack handlers create it: only Slack ingress writes slackTriggerMessageTs.
   return createTaskExtended("original ask", {
-    agentId: worker.id,
+    agentId: opts.unassigned ? undefined : worker.id,
     source: "slack",
     slackChannelId: channel,
     slackThreadTs: threadTs,
@@ -158,6 +172,11 @@ beforeAll(async () => {
       handlers.set(type, handler);
     },
   } as never);
+  registerCommandHandler({
+    command: (name: string, handler: Handler) => {
+      commands.set(name, handler);
+    },
+  } as never);
 
   routeServer = createServer(async (req, res) => {
     setRequestAuth(req, { kind: "operator", fingerprint: "test-key" });
@@ -192,6 +211,7 @@ afterAll(async () => {
 
 beforeEach(() => {
   resetSlackHandlerCachesForTesting();
+  ephemerals.length = 0;
 });
 
 describe("slack-leave-thread", () => {
@@ -429,3 +449,123 @@ describe("SLACK_LEAVE_THREAD_DISABLE", () => {
     }
   });
 });
+
+describe("!leave", () => {
+  test("leaves the thread in code: no task, no workflow event, an ephemeral confirmation", async () => {
+    const emitted: unknown[] = [];
+    const listener = (payload: unknown) => emitted.push(payload);
+    workflowEventBus.on("slack.message", listener);
+    try {
+      await seedThread("C_BANG_A", "3000.0001");
+      expect(await sendThreadReply("C_BANG_A", "3000.0001", "!leave")).toHaveLength(1);
+      expect(emitted).toHaveLength(0);
+    } finally {
+      workflowEventBus.off("slack.message", listener);
+    }
+
+    expect(await isSlackThreadLeft("C_BANG_A", "3000.0001")).toBe(true);
+    const entry = await getKv(SLACK_LEFT_THREAD_KV_NAMESPACE, "C_BANG_A:3000.0001");
+    expect(entry?.value).toMatchObject({ slackUserId: HUMAN });
+    expect(entry?.value).not.toHaveProperty("agentId");
+    expect(ephemerals).toEqual([
+      {
+        channel: "C_BANG_A",
+        user: HUMAN,
+        thread_ts: "3000.0001",
+        text: SLACK_LEFT_THREAD_CONFIRMATION,
+      },
+    ]);
+
+    expect(await sendThreadReply("C_BANG_A", "3000.0001", "chatting among ourselves")).toHaveLength(
+      1,
+    );
+    expect(
+      await sendThreadReply("C_BANG_A", "3000.0001", `<@${BOT_USER_ID}> back please`),
+    ).toHaveLength(2);
+    expect(await isSlackThreadLeft("C_BANG_A", "3000.0001")).toBe(false);
+  });
+
+  test("an @mention before !leave leaves instead of rejoining, also in a left thread", async () => {
+    await seedThread("C_BANG_B", "3100.0001");
+    await sendThreadReply("C_BANG_B", "3100.0001", "!leave");
+    expect(await sendThreadReply("C_BANG_B", "3100.0001", `<@${BOT_USER_ID}> !leave`)).toHaveLength(
+      1,
+    );
+    expect(await isSlackThreadLeft("C_BANG_B", "3100.0001")).toBe(true);
+    expect(ephemerals).toHaveLength(2);
+  });
+
+  test("with ADDITIVE_SLACK the !leave message is never buffered", async () => {
+    process.env.ADDITIVE_SLACK = "true";
+    try {
+      await seedThread("C_BANG_C", "3200.0001");
+      await sendThreadReply("C_BANG_C", "3200.0001", "!leave");
+      expect(getBufferMessageCount("C_BANG_C:3200.0001")).toBe(0);
+      expect(await isSlackThreadLeft("C_BANG_C", "3200.0001")).toBe(true);
+    } finally {
+      process.env.ADDITIVE_SLACK = "false";
+    }
+  });
+
+  test.each([
+    ["!leave", "3600.0001"],
+    [`<@${BOT_USER_ID}> !leave`, "3600.0002"],
+  ])("leaves a human-rooted thread whose only task is unassigned: %s", async (text, threadTs) => {
+    const emitted: unknown[] = [];
+    const listener = (payload: unknown) => emitted.push(payload);
+    workflowEventBus.on("slack.message", listener);
+    try {
+      const seeded = await seedThread("C_BANG_G", threadTs, { unassigned: true });
+      expect(seeded.agentId).toBeNull();
+      expect(await sendThreadReply("C_BANG_G", threadTs, text)).toHaveLength(1);
+      expect(emitted).toHaveLength(0);
+    } finally {
+      workflowEventBus.off("slack.message", listener);
+    }
+    expect(await isSlackThreadLeft("C_BANG_G", threadTs)).toBe(true);
+    expect(ephemerals).toHaveLength(1);
+  });
+
+  test("a task in another thread of the channel does not make !leave a command", async () => {
+    await seedThread("C_BANG_H", "3700.0001", { unassigned: true });
+    await sendThreadReply("C_BANG_H", "3700.0002", "!leave");
+    expect(await isSlackThreadLeft("C_BANG_H", "3700.0002")).toBe(false);
+    expect(ephemerals).toHaveLength(0);
+  });
+
+  test("is not a command outside a swarm thread, when addressed elsewhere, or with extra text", async () => {
+    await sendThreadReply("C_BANG_D", "3300.0001", "!leave");
+    expect(await isSlackThreadLeft("C_BANG_D", "3300.0001")).toBe(false);
+
+    await seedThread("C_BANG_E", "3400.0001");
+    await sendThreadReply("C_BANG_E", "3400.0001", "<@U_SOMEONE_ELSE> !leave");
+    await sendThreadReply("C_BANG_E", "3400.0001", "!leave it to me");
+    expect(await isSlackThreadLeft("C_BANG_E", "3400.0001")).toBe(false);
+    expect(ephemerals).toHaveLength(0);
+  });
+
+  test("SLACK_LEAVE_THREAD_DISABLE makes !leave an ordinary message and hides it from help", async () => {
+    async function helpText(): Promise<string> {
+      let text = "";
+      await commands.get("/agent-swarm-help")!({
+        ack: async () => {},
+        respond: async (reply: { blocks: Array<{ text: { text: string } }> }) => {
+          text = reply.blocks.map((b) => b.text.text).join("\n");
+        },
+      });
+      return text;
+    }
+    expect(await helpText()).toContain("`!leave` in a thread");
+
+    process.env.SLACK_LEAVE_THREAD_DISABLE = "true";
+    try {
+      await seedThread("C_BANG_F", "3500.0001");
+      expect(await sendThreadReply("C_BANG_F", "3500.0001", "!leave")).toHaveLength(2);
+      expect(await isSlackThreadLeft("C_BANG_F", "3500.0001")).toBe(false);
+      expect(ephemerals).toHaveLength(0);
+      expect(await helpText()).not.toContain("!leave");
+    } finally {
+      delete process.env.SLACK_LEAVE_THREAD_DISABLE;
+    }
+  });
+});

package/src/tests/slack-render-v2-query-plans.test.ts

@@ -1,3 +1,4 @@
+import { Database } from "bun:sqlite";
 import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import {
   closeDb,
@@ -6,6 +7,7 @@ import {
   getDb,
   getDbClient,
   getResolvableDeferralOutcomes,
+  getSlackTreeMessages,
   initDb,
   recordSlackMessage,
 } from "../be/db";
@@ -93,12 +95,32 @@ describe("slack render-v2 watcher queries", () => {
     closeDb();
   });
 
+  test("the tree sweep tests thread tasks in the covering index, not task rows", async () => {
+    const sql = await capturedSql(() => getSlackTreeMessages());
+    const detail = plan(sql);
+    const uses = "SEARCH task USING COVERING INDEX idx_agent_tasks_slack_thread_cover";
+    expect(detail.split(uses).length - 1).toBe(3);
+    // Control: without migration 264 the same tests read the task rows.
+    const copy = Database.deserialize(getDb().serialize());
+    try {
+      copy.run("DROP INDEX idx_agent_tasks_slack_thread_cover");
+      const reverted = copy
+        .query<{ detail: string }, []>(`EXPLAIN QUERY PLAN ${sql}`)
+        .all()
+        .map((row) => row.detail)
+        .join("\n");
+      expect(reverted).not.toContain(uses);
+    } finally {
+      copy.close();
+    }
+  });
+
   test("deferral resolution drives from the chain, not from every task", async () => {
     const sql = await capturedSql(() => getResolvableDeferralOutcomes());
     const detail = plan(sql, [50]);
-    // Either parentTaskId-led index is a seek on the chain's children.
+    // Any parentTaskId-led index is a seek on the chain's children.
     expect(detail).toMatch(
-      /SEARCH wake USING INDEX idx_agent_tasks_parentTaskId(_source)? \(parentTaskId=\?\)/,
+      /SEARCH wake USING INDEX idx_agent_tasks_parentTaskId(_source|_id)? \(parentTaskId=\?\)/,
     );
     expect(detail).not.toContain("idx_agent_tasks_taskType");
     expect(detail).not.toContain("idx_agent_tasks_status_last_updated");

package/src/tests/status.test.ts

@@ -87,6 +87,8 @@ const ENV_KEYS_TO_RESET = [
   "SWARM_BRAND_COLOR",
   "SWARM_MARKETING_URL",
   "SWARM_HIDE_CLOUD_PROMO",
+  "APP_URL",
+  "DASHBOARD_URL",
   "HARNESS_PROVIDER",
   "ANTHROPIC_API_KEY",
   "CLAUDE_CODE_OAUTH_TOKEN",
@@ -191,6 +193,7 @@ describe("buildStatusPayload — identity", () => {
       marketing_url: null,
       hide_cloud_promo: false,
       org_id: null,
+      dashboard_url: null,
     });
   });
 
@@ -212,9 +215,17 @@ describe("buildStatusPayload — identity", () => {
       marketing_url: "https://swarm.acme.example",
       hide_cloud_promo: true,
       org_id: "org_acme_123",
+      dashboard_url: null,
     });
   });
 
+  test("reports the configured dashboard URL: the first APP_URL entry, else DASHBOARD_URL", async () => {
+    process.env.DASHBOARD_URL = "https://old.example.com";
+    expect((await buildStatusPayload()).identity.dashboard_url).toBe("https://old.example.com");
+    process.env.APP_URL = "https://swarm.example.com/, https://other.example.com";
+    expect((await buildStatusPayload()).identity.dashboard_url).toBe("https://swarm.example.com");
+  });
+
   test("treats SWARM_CLOUD=1 the same as 'true'", async () => {
     process.env.SWARM_CLOUD = "1";
     const payload = await buildStatusPayload();

package/src/tests/tasks-readable-row.test.ts

@@ -0,0 +1,155 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getAllTasks, getDb, getDbClient, initDb } from "../be/db";
+import { readableSessionCondition } from "../be/db/tasks/read";
+
+const TEST_DB_PATH = "./test-tasks-readable-row.sqlite";
+const AT = "2026-10-01T00:00:00.000Z";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"])
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
+}
+
+async function task(
+  id: string,
+  opts: { parent?: string; owner?: string; scheduleId?: string } = {},
+): Promise<void> {
+  await getDbClient().run(
+    `INSERT INTO agent_tasks (id, task, status, source, parentTaskId, requestedByUserId, scheduleId,
+       createdAt, lastUpdatedAt)
+     VALUES (?, ?, 'completed', 'api', ?, ?, ?, ?, ?)`,
+    [id, `task ${id}`, opts.parent ?? null, opts.owner ?? null, opts.scheduleId ?? null, AT, AT],
+  );
+}
+
+describe("readableSessionRowCondition", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+    for (const id of ["u1", "u2", "u3"]) {
+      await getDbClient().run(
+        "INSERT INTO users (id, name, role, status, createdAt, lastUpdatedAt) VALUES (?, ?, 'member', 'active', ?, ?)",
+        [id, id, AT, AT],
+      );
+    }
+    // u1's session, three deep.
+    await task("a", { owner: "u1" });
+    await task("a1", { parent: "a", owner: "u1" });
+    await task("a2", { parent: "a1" });
+    // u2's session, with a child that names u1.
+    await task("b", { owner: "u2" });
+    await task("b1", { parent: "b", owner: "u1" });
+    // u2's schedule run: everyone reads it.
+    await task("c", { owner: "u2", scheduleId: "schedule-1" });
+    await task("c1", { parent: "c" });
+    // u2's session shared with u1, and one shared with everyone.
+    await task("d", { owner: "u2" });
+    await task("d1", { parent: "d" });
+    await task("e", { owner: "u2" });
+    await getDbClient().run(
+      `INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt)
+       VALUES ('share-d', 'd', 'u1', 'read', ?), ('share-e', 'e', NULL, 'read', ?)`,
+      [AT, AT],
+    );
+    // A revoked share hides again.
+    await task("f", { owner: "u2" });
+    await getDbClient().run(
+      `INSERT INTO session_shares (id, rootTaskId, userId, access, createdAt, revokedAt)
+       VALUES ('share-f', 'f', 'u1', 'read', ?, ?)`,
+      [AT, AT],
+    );
+    // A session nobody owns.
+    await task("g");
+    await task("g1", { parent: "g", owner: "u2" });
+    // Orphan subtrees: the top's parent is gone, so the top is the root.
+    await task("h", { owner: "u2" });
+    await task("h1", { parent: "h" });
+    await task("h2", { parent: "h1", owner: "u1" });
+    await task("i", { owner: "u1" });
+    await task("i1", { parent: "i", owner: "u2" });
+    await task("i2", { parent: "i1" });
+    // Chains deeper than the walk's hop limit fall back to the set form.
+    for (const [root, owner] of [
+      ["deep-u1", "u1"],
+      ["deep-u2", "u2"],
+    ] as const) {
+      await task(root, { owner });
+      let parent: string = root;
+      for (let i = 1; i <= 70; i++) {
+        await task(`${root}-${i}`, { parent });
+        parent = `${root}-${i}`;
+      }
+    }
+    getDb().run("PRAGMA foreign_keys = OFF");
+    getDb().run("DELETE FROM agent_tasks WHERE id IN ('h', 'i')");
+    getDb().run("PRAGMA foreign_keys = ON");
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles();
+  });
+
+  for (const userId of ["u1", "u2", "u3", null]) {
+    test(`the page shows the rows the set form shows, for ${userId ?? "a guest"}`, async () => {
+      const set = readableSessionCondition(userId);
+      const expected = (
+        await getDbClient().query<{ id: string }>(
+          `SELECT id FROM agent_tasks WHERE ${set.sql} ORDER BY id`,
+          set.params,
+        )
+      ).map((row) => row.id);
+      const page = await getAllTasks({ readableBy: { userId }, limit: 1000 });
+      expect(page.map((t) => t.id).sort()).toEqual(expected);
+    });
+  }
+
+  test("u1 sees exactly the expected sessions", async () => {
+    const page = await getAllTasks({ readableBy: { userId: "u1" }, limit: 1000 });
+    const deep = Array.from({ length: 70 }, (_, i) => `deep-u1-${i + 1}`);
+    expect(page.map((t) => t.id).sort()).toEqual(
+      [
+        "a",
+        "a1",
+        "a2",
+        "c",
+        "c1",
+        "d",
+        "d1",
+        "e",
+        "g",
+        "g1",
+        "h1",
+        "h2",
+        "deep-u1",
+        ...deep,
+      ].sort(),
+    );
+  });
+
+  test("the page walks up from each row it reads", async () => {
+    const query = spyOn(getDbClient(), "query");
+    let sql = "";
+    let params: unknown[] = [];
+    try {
+      await getAllTasks({ status: "completed", readableBy: { userId: "u1" } });
+      [sql, params = []] = query.mock.calls.find(([s]) => s.includes("WITH page AS"))! as [
+        string,
+        unknown[]?,
+      ];
+    } finally {
+      query.mockRestore();
+    }
+    const plan = getDb()
+      .query<{ detail: string }, any[]>(`EXPLAIN QUERY PLAN ${sql}`)
+      .all(...(params as any[]))
+      .map((row) => row.detail)
+      .join("\n");
+    // The walk is a correlated lookup per row. The set form appears only as
+    // the fallback branch, which SQLite builds when a walk finds no root.
+    expect(plan).toContain("CORRELATED SCALAR SUBQUERY");
+    expect(plan).toContain("SEARCH u USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+    expect(plan).toContain("SEARCH p USING INDEX sqlite_autoindex_agent_tasks_1 (id=?)");
+  });
+});

package/src/tools/send-task.ts

@@ -5,9 +5,7 @@ import { resolveTaskAuditUserId } from "@/be/audit-user";
 import {
   createTaskExtended,
   extensionAgentAssignmentError,
-  findCompletedTaskInThread,
   findExistingLinearTrackerContextWork,
-  findRecentCancelledTaskInThread,
   getActiveTaskCount,
   getAgentById,
   getDbClient,
@@ -23,6 +21,10 @@ import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { explicitModelErrorForAgent } from "@/be/model-validation";
 import { applyPreTaskCreate } from "@/extensions/apply-task-create";
 import { can } from "@/rbac";
+import {
+  evaluateFollowUpRedelegation,
+  followUpThreadForSourceTask,
+} from "@/tasks/follow-up-redelegation-guard";
 import { checkSlackRoutingCoherence } from "@/tasks/slack-routing";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
@@ -163,7 +165,13 @@ export const sendTaskInputSchema = z
       .boolean()
       .default(false)
       .describe(
-        "If true, skip duplicate detection and create the task even if a similar one exists.",
+        "If true, skip duplicate detection and create the task even if a similar one exists. Does not bypass the follow-up re-delegation guard; see allowRedelegation.",
+      ),
+    allowRedelegation: z
+      .boolean()
+      .default(false)
+      .describe(
+        "Only matters when you call send-task from a follow-up task in a Slack thread. Such a dispatch is blocked when it repeats a task already completed in that thread (same-work rule, unless a task there was cancelled or failed after that completion), or when you already dispatched 10 tasks into the thread in the last 6 hours (loop-cap rule). Set true to dispatch anyway; the override is logged. Use it only for deliberate re-runs or long chains, never to retry a block you have not read.",
       ),
     slackChannelId: z
       .string()
@@ -292,6 +300,7 @@ export async function sendTaskHandler(
     effort,
     profile,
     allowDuplicate,
+    allowRedelegation,
     slackChannelId,
     slackThreadTs,
     slackUserId,
@@ -316,6 +325,7 @@ export async function sendTaskHandler(
   const requestedLeadOnly = ctx.kind === "user" ? false : leadOnly;
   const requestedCapabilities = ctx.kind === "user" ? undefined : requiredCapabilities;
   const requestedAllowDuplicate = ctx.kind === "user" ? false : allowDuplicate;
+  const requestedAllowRedelegation = ctx.kind === "user" ? false : allowRedelegation;
   const requestedOverrideSlackContext = ctx.kind === "user" ? false : overrideSlackContext;
 
   // Defense in depth for direct TypeScript callers that bypass MCP schema parsing.
@@ -572,7 +582,9 @@ export async function sendTaskHandler(
   // Every read in this handler releases the FIFO lock, so two concurrent
   // send-task calls with the same creator and text otherwise both pass the
   // guards and both create a task (no UNIQUE index arbitrates them).
-  const evaluateDedupGuards = async (): Promise<{
+  const evaluateDedupGuards = async (
+    logOverride: boolean,
+  ): Promise<{
     ok: boolean;
     message: string;
     task?: AgentTask;
@@ -602,59 +614,35 @@ export async function sendTaskHandler(
       }
     }
 
-    // Guard: prevent re-delegation from follow-up tasks
-    // When the source task is a "follow-up" (worker completed/failed notification),
-    // check if there are completed tasks in the same Slack thread recently.
-    // This prevents the cycle: worker completes → follow-up → Lead re-delegates → repeat.
-    //
-    // Exception: if a MORE RECENT task in the same thread was cancelled (exit 130,
-    // status='cancelled', or status='failed' with failureReason containing
-    // "cancelled"), bypass the guard. A cancellation means the work was
-    // interrupted — re-dispatch is the correct response, not a deduped no-op.
-    // Without this bypass, a cancelled worker permanently jams the thread
-    // against re-delegation when an earlier completed sibling exists.
+    // Guard: prevent re-delegation from follow-up tasks (same-work and
+    // loop-cap rules, see src/tasks/follow-up-redelegation-guard.ts).
+    // allowRedelegation bypasses both and is logged.
     //
     // NOTE: `taskType === "resume"` (created by createResumeFollowUp on
     // supersede) is intentionally NOT in this guard — a resume IS the legitimate
     // re-dispatch and bypassing the check is correct. Do not add "resume" here.
-    if (sourceTaskId) {
-      const sourceTask = await getTaskById(sourceTaskId);
-      if (
-        sourceTask?.taskType === "follow-up" &&
-        sourceTask.slackThreadTs &&
-        sourceTask.slackChannelId
-      ) {
-        const recentCompleted = await findCompletedTaskInThread(
-          sourceTask.slackChannelId,
-          sourceTask.slackThreadTs,
-          2880, // 48 hours in minutes
+    const followUpThread = creatorAgentId ? await followUpThreadForSourceTask(sourceTaskId) : null;
+    if (followUpThread && creatorAgentId) {
+      const blocked = await evaluateFollowUpRedelegation({
+        ...followUpThread,
+        creatorAgentId,
+        taskDescription,
+        targetAgentId: taskOptions.agentId ?? taskOptions.offeredTo,
+      });
+      if (blocked && !requestedAllowRedelegation) {
+        return { ok: false, message: blocked.message };
+      }
+      if (blocked && logOverride) {
+        console.log(
+          `[send-task] follow-up re-delegation override: rule=${blocked.rule} creatorAgentId=${creatorAgentId} sourceTaskId=${sourceTaskId} thread=${followUpThread.channelId}/${followUpThread.threadTs}`,
         );
-        if (recentCompleted) {
-          const recentCancelled = await findRecentCancelledTaskInThread(
-            sourceTask.slackChannelId,
-            sourceTask.slackThreadTs,
-            2880,
-          );
-          const cancelledMoreRecent =
-            recentCancelled &&
-            new Date(recentCancelled.lastUpdatedAt).getTime() >
-              new Date(recentCompleted.lastUpdatedAt).getTime();
-          if (!cancelledMoreRecent) {
-            return {
-              ok: false,
-              message: `Blocked: re-delegation from follow-up task in a thread that already has completed work (task ${recentCompleted.id.slice(0, 8)}). The original request was already handled.`,
-            };
-          }
-          // else: fall through — the cancellation is more recent than the
-          // completion, so re-delegation is legitimate.
-        }
       }
     }
 
     return null;
   };
 
-  const guard = await evaluateDedupGuards();
+  const guard = await evaluateDedupGuards(true);
   if (guard) {
     const guardData = {
       yourAgentId: creatorAgentId,
@@ -669,7 +657,7 @@ export async function sendTaskHandler(
     // Authoritative re-check: the reads above are separated from the INSERT by
     // the whole handler, so only a guard inside this transaction can see a
     // concurrent send-task's committed task.
-    const raced = await evaluateDedupGuards();
+    const raced = await evaluateDedupGuards(false);
     if (raced) return { success: raced.ok, message: raced.message, task: raced.task };
 
     // This transaction already checked the tracker key, excluding the caller's

package/src/tools/slack-leave-thread.ts

@@ -94,7 +94,7 @@ export const registerSlackLeaveThreadTool = (server: McpServer) => {
         return toolErr("No Slack thread context available.");
       }
 
-      await leaveSlackThread(slackChannelId, slackThreadTs, agent.id);
+      await leaveSlackThread(slackChannelId, slackThreadTs, { agentId: agent.id });
       return toolOk(
         `Left Slack thread ${slackChannelId}/${slackThreadTs}. Messages there are ignored until someone @mentions the bot.`,
         { data: { channelId: slackChannelId, threadTs: slackThreadTs } },