@desplega.ai/agent-swarm 1.115.0 → 1.117.0

package/src/tests/slack-routing-guard.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, test } from "bun:test";
+import { linearContextKey, slackContextKey } from "../tasks/context-key";
+import { checkSlackRoutingCoherence, slackChannelFromContextKey } from "../tasks/slack-routing";
+
+describe("slackChannelFromContextKey", () => {
+  test("extracts channel/thread from a slack-family key", () => {
+    const key = slackContextKey({ channelId: "C_ABC", threadTs: "111.222" });
+    expect(slackChannelFromContextKey(key)).toEqual({ channelId: "C_ABC", threadTs: "111.222" });
+  });
+
+  test("returns null for a non-slack family key", () => {
+    const key = linearContextKey({ issueIdentifier: "DES-42" });
+    expect(slackChannelFromContextKey(key)).toBeNull();
+  });
+
+  test("returns null for a malformed key instead of throwing", () => {
+    expect(slackChannelFromContextKey("not-a-context-key")).toBeNull();
+  });
+
+  test("returns null for undefined/null input", () => {
+    expect(slackChannelFromContextKey(undefined)).toBeNull();
+    expect(slackChannelFromContextKey(null)).toBeNull();
+  });
+});
+
+describe("checkSlackRoutingCoherence", () => {
+  test("no explicit unit → ok (nothing to check)", () => {
+    const result = checkSlackRoutingCoherence({ explicit: {} });
+    expect(result.verdict).toBe("ok");
+  });
+
+  test("channel without threadTs → partial-unit", () => {
+    const result = checkSlackRoutingCoherence({ explicit: { channelId: "C_A" } });
+    expect(result.verdict).toBe("partial-unit");
+  });
+
+  test("threadTs without channel → partial-unit", () => {
+    const result = checkSlackRoutingCoherence({ explicit: { threadTs: "111.222" } });
+    expect(result.verdict).toBe("partial-unit");
+  });
+
+  test("userId alone (no channel/thread) → ok — attribution only", () => {
+    const result = checkSlackRoutingCoherence({ explicit: { userId: "U_SOMEONE" } });
+    expect(result.verdict).toBe("ok");
+  });
+
+  test("no parent, no contextKey → complete explicit unit accepted (new Slack root)", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_NEW", threadTs: "111.222" },
+    });
+    expect(result.verdict).toBe("ok");
+  });
+
+  test("explicit unit matches parent's slackChannelId and slackThreadTs → ok", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_PARENT", threadTs: "111.222" },
+      parent: { slackChannelId: "C_PARENT", slackThreadTs: "111.222", contextKey: null },
+    });
+    expect(result.verdict).toBe("ok");
+  });
+
+  test("explicit channelId matches parent's but threadTs diverges → mismatch (source: parent)", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_PARENT", threadTs: "999.999" },
+      parent: { slackChannelId: "C_PARENT", slackThreadTs: "111.222", contextKey: null },
+    });
+    expect(result.verdict).toBe("mismatch");
+    if (result.verdict === "mismatch") {
+      expect(result.field).toBe("slackThreadTs");
+      expect(result.expectedSource).toBe("parent");
+      expect(result.expected).toBe("111.222");
+      expect(result.got).toBe("999.999");
+    }
+  });
+
+  test("explicit channelId mismatches parent's slackChannelId → mismatch (source: parent)", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_WRONG", threadTs: "111.222" },
+      parent: { slackChannelId: "C_PARENT", slackThreadTs: "999.999", contextKey: null },
+    });
+    expect(result.verdict).toBe("mismatch");
+    if (result.verdict === "mismatch") {
+      expect(result.field).toBe("slackChannelId");
+      expect(result.expectedSource).toBe("parent");
+      expect(result.expected).toBe("C_PARENT");
+      expect(result.got).toBe("C_WRONG");
+    }
+  });
+
+  test("explicit channelId mismatches the inherited slack contextKey → mismatch (source: contextKey)", () => {
+    const contextKey = slackContextKey({ channelId: "C_GEROLD", threadTs: "111.222" });
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_DANIEL", threadTs: "111.222" },
+      inheritedContextKey: contextKey,
+    });
+    expect(result.verdict).toBe("mismatch");
+    if (result.verdict === "mismatch") {
+      expect(result.field).toBe("slackChannelId");
+      expect(result.expectedSource).toBe("contextKey");
+      expect(result.expected).toBe("C_GEROLD");
+      expect(result.got).toBe("C_DANIEL");
+    }
+  });
+
+  test("explicit threadTs mismatches the inherited slack contextKey's thread → mismatch", () => {
+    const contextKey = slackContextKey({ channelId: "C_GEROLD", threadTs: "111.222" });
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_GEROLD", threadTs: "333.444" },
+      inheritedContextKey: contextKey,
+    });
+    expect(result.verdict).toBe("mismatch");
+    if (result.verdict === "mismatch") {
+      expect(result.field).toBe("slackThreadTs");
+      expect(result.expectedSource).toBe("contextKey");
+      expect(result.expected).toBe("111.222");
+      expect(result.got).toBe("333.444");
+    }
+  });
+
+  test("incident replay: explicit unit disagrees with BOTH parent and contextKey → rejects on parent first", () => {
+    const contextKey = slackContextKey({ channelId: "D0ATCHCQR4M", threadTs: "1783596696.921879" });
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "D0ASZJS6HUN", threadTs: "1783596696.921879" },
+      parent: { slackChannelId: "D0ATCHCQR4M", slackThreadTs: "1783596696.921879", contextKey },
+      inheritedContextKey: contextKey,
+    });
+    expect(result.verdict).toBe("mismatch");
+    if (result.verdict === "mismatch") {
+      expect(result.expectedSource).toBe("parent");
+      expect(result.expected).toBe("D0ATCHCQR4M");
+      expect(result.got).toBe("D0ASZJS6HUN");
+    }
+  });
+
+  test("parent has non-slack contextKey → only parent-field comparison applies, unit accepted", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_NEW", threadTs: "111.222" },
+      parent: {
+        slackChannelId: null,
+        slackThreadTs: null,
+        contextKey: linearContextKey({ issueIdentifier: "DES-1" }),
+      },
+      inheritedContextKey: linearContextKey({ issueIdentifier: "DES-1" }),
+    });
+    expect(result.verdict).toBe("ok");
+  });
+
+  test("malformed inherited contextKey degrades to parent-only comparison, no throw", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_PARENT", threadTs: "111.222" },
+      parent: { slackChannelId: "C_PARENT", slackThreadTs: "111.222", contextKey: "garbage" },
+      inheritedContextKey: "garbage",
+    });
+    expect(result.verdict).toBe("ok");
+  });
+
+  test("explicit unit identical to parent's (verbatim-copy pattern) → ok, no behavior change", () => {
+    const result = checkSlackRoutingCoherence({
+      explicit: { channelId: "C_SAME", threadTs: "111.222", userId: "U_SAME" },
+      parent: { slackChannelId: "C_SAME", slackThreadTs: "111.222", contextKey: null },
+    });
+    expect(result.verdict).toBe("ok");
+  });
+});

package/src/tools/send-task.ts

@@ -13,6 +13,7 @@ import {
   hasCapacity,
 } from "@/be/db";
 import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
+import { checkSlackRoutingCoherence } from "@/tasks/slack-routing";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
@@ -25,91 +26,113 @@ import {
   splitLegacyModelAlias,
 } from "@/types";
 
-export const sendTaskInputSchema = z.object({
-  agentId: z
-    .uuid()
-    .optional()
-    .describe("The agent to assign/offer task to. Omit to create unassigned task for pool."),
-  task: z.string().min(1).describe("The task description to send."),
-  offerMode: z
-    .boolean()
-    .default(false)
-    .describe("If true, offer the task instead of direct assign (agent must accept/reject)."),
-  taskType: z.string().max(50).optional().describe("Task type (e.g., 'bug', 'feature', 'review')."),
-  tags: z
-    .array(z.string())
-    .optional()
-    .describe("Tags for filtering (e.g., ['urgent', 'frontend'])."),
-  requiredCapabilities: z
-    .array(z.string())
-    .optional()
-    .describe(
-      "Capabilities a claiming agent must have (declared via join-swarm/update-profile) to be pool-eligible for this task. Written into the created task's routingAffinity (role is left unset — only enforced when the pool auto-claim/claim-tool paths check it). Most useful when omitting agentId (unassigned pool task); a no-op for a task with an explicit agentId, which bypasses the pool gate entirely.",
+export const sendTaskInputSchema = z
+  .object({
+    agentId: z
+      .uuid()
+      .optional()
+      .describe("The agent to assign/offer task to. Omit to create unassigned task for pool."),
+    task: z.string().min(1).describe("The task description to send."),
+    offerMode: z
+      .boolean()
+      .default(false)
+      .describe("If true, offer the task instead of direct assign (agent must accept/reject)."),
+    taskType: z
+      .string()
+      .max(50)
+      .optional()
+      .describe("Task type (e.g., 'bug', 'feature', 'review')."),
+    tags: z
+      .array(z.string())
+      .optional()
+      .describe("Tags for filtering (e.g., ['urgent', 'frontend'])."),
+    requiredCapabilities: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "Capabilities a claiming agent must have (declared via join-swarm/update-profile) to be pool-eligible for this task. Written into the created task's routingAffinity (role is left unset — only enforced when the pool auto-claim/claim-tool paths check it). Most useful when omitting agentId (unassigned pool task); a no-op for a task with an explicit agentId, which bypasses the pool gate entirely.",
+      ),
+    priority: z.number().int().min(0).max(100).optional().describe("Priority 0-100 (default: 50)."),
+    dependsOn: z.array(z.uuid()).optional().describe("Task IDs this task depends on."),
+    parentTaskId: z
+      .uuid()
+      .optional()
+      .describe(
+        "Parent task ID for session continuity. Child task will resume the parent's Claude session. Auto-routes to the same worker unless agentId is explicitly provided.",
+      ),
+    dir: z
+      .string()
+      .min(1)
+      .startsWith("/")
+      .optional()
+      .describe(
+        "Working directory (absolute path) for the agent to start in. If the directory doesn't exist, falls back to the default working directory.",
+      ),
+    vcsRepo: z
+      .string()
+      .optional()
+      .describe(
+        "VCS repo identifier (e.g., 'desplega-ai/agent-swarm' for GitHub or 'group/project' for GitLab). Links the task to a registered repo for workspace context.",
+      ),
+    model: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe(
+        "Concrete model override for this task, interpreted by the assignee's harness/provider. This does not switch providers. Prefer modelTier for portable intent.",
+      ),
+    modelTier: ModelTierSchema.optional().describe(
+      "Portable model tier for this task: 'smol', 'regular', 'smart', or 'ultra'. Resolved at claim/run time using the assignee's harness/provider. Legacy model shortnames map as haiku→smol, sonnet→regular, opus→smart, fable→ultra.",
     ),
-  priority: z.number().int().min(0).max(100).optional().describe("Priority 0-100 (default: 50)."),
-  dependsOn: z.array(z.uuid()).optional().describe("Task IDs this task depends on."),
-  parentTaskId: z
-    .uuid()
-    .optional()
-    .describe(
-      "Parent task ID for session continuity. Child task will resume the parent's Claude session. Auto-routes to the same worker unless agentId is explicitly provided.",
+    effort: ReasoningEffortSchema.optional().describe(
+      "Reasoning effort for this task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. If omitted, the assignee's REASONING_EFFORT_OVERRIDE/default applies.",
     ),
-  dir: z
-    .string()
-    .min(1)
-    .startsWith("/")
-    .optional()
-    .describe(
-      "Working directory (absolute path) for the agent to start in. If the directory doesn't exist, falls back to the default working directory.",
+    allowDuplicate: z
+      .boolean()
+      .default(false)
+      .describe(
+        "If true, skip duplicate detection and create the task even if a similar one exists.",
+      ),
+    slackChannelId: z
+      .string()
+      .optional()
+      .describe(
+        "Slack channel ID to post progress updates to. Use this to propagate Slack context when delegating from a Slack thread.",
+      ),
+    slackThreadTs: z
+      .string()
+      .optional()
+      .describe("Slack thread timestamp. Required with slackChannelId for thread-level updates."),
+    slackUserId: z.string().optional().describe("Slack user ID of the original requester."),
+    overrideSlackContext: z
+      .boolean()
+      .default(false)
+      .describe(
+        "Explicitly route this task's Slack updates to a different channel/thread than its parent/contextKey. Requires slackChannelId AND slackThreadTs. Use only for deliberate cross-channel dispatch (e.g. escalation to another human's DM); logged for audit. Without this flag, a slackChannelId/slackThreadTs that disagrees with the parent task or inherited contextKey is rejected — omit the three Slack fields to inherit them from the parent as a unit instead.",
+      ),
+    requestedByUserId: z
+      .string()
+      .uuid()
+      .optional()
+      .describe(
+        "ID of the human user who originally requested this task chain. When omitted, inherited from the caller's current task so the attribution flows through multi-hop delegation automatically.",
+      ),
+    followUpConfig: FollowUpConfigSchema.optional().describe(
+      "Control the lead follow-up created when this task finishes. When to use `followUpConfig`: set `disabled: true` when you'll wait for this task to complete inline and no follow-up is needed; set `onCompleted` / `onFailed` with specific instructions when you need to follow up effectively on a particular outcome of a long-running flow; for normal one-shot tasks, leave it unset because defaults are fine. It is most valuable for long-running / complex flows.",
     ),
-  vcsRepo: z
-    .string()
-    .optional()
-    .describe(
-      "VCS repo identifier (e.g., 'desplega-ai/agent-swarm' for GitHub or 'group/project' for GitLab). Links the task to a registered repo for workspace context.",
-    ),
-  model: z
-    .string()
-    .trim()
-    .min(1)
-    .optional()
-    .describe(
-      "Concrete model override for this task, interpreted by the assignee's harness/provider. This does not switch providers. Prefer modelTier for portable intent.",
-    ),
-  modelTier: ModelTierSchema.optional().describe(
-    "Portable model tier for this task: 'smol', 'regular', 'smart', or 'ultra'. Resolved at claim/run time using the assignee's harness/provider. Legacy model shortnames map as haiku→smol, sonnet→regular, opus→smart, fable→ultra.",
-  ),
-  effort: ReasoningEffortSchema.optional().describe(
-    "Reasoning effort for this task: 'off', 'low', 'medium', 'high', 'xhigh', or 'max'. If omitted, the assignee's REASONING_EFFORT_OVERRIDE/default applies.",
-  ),
-  allowDuplicate: z
-    .boolean()
-    .default(false)
-    .describe(
-      "If true, skip duplicate detection and create the task even if a similar one exists.",
-    ),
-  slackChannelId: z
-    .string()
-    .optional()
-    .describe(
-      "Slack channel ID to post progress updates to. Use this to propagate Slack context when delegating from a Slack thread.",
-    ),
-  slackThreadTs: z
-    .string()
-    .optional()
-    .describe("Slack thread timestamp. Required with slackChannelId for thread-level updates."),
-  slackUserId: z.string().optional().describe("Slack user ID of the original requester."),
-  requestedByUserId: z
-    .string()
-    .uuid()
-    .optional()
-    .describe(
-      "ID of the human user who originally requested this task chain. When omitted, inherited from the caller's current task so the attribution flows through multi-hop delegation automatically.",
-    ),
-  followUpConfig: FollowUpConfigSchema.optional().describe(
-    "Control the lead follow-up created when this task finishes. When to use `followUpConfig`: set `disabled: true` when you'll wait for this task to complete inline and no follow-up is needed; set `onCompleted` / `onFailed` with specific instructions when you need to follow up effectively on a particular outcome of a long-running flow; for normal one-shot tasks, leave it unset because defaults are fine. It is most valuable for long-running / complex flows.",
-  ),
-});
+  })
+  .superRefine((data, ctx) => {
+    const hasChannel = !!data.slackChannelId;
+    const hasThread = !!data.slackThreadTs;
+    if (hasChannel !== hasThread) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "slackChannelId and slackThreadTs must both be set, or both omitted.",
+        path: [hasChannel ? "slackThreadTs" : "slackChannelId"],
+      });
+    }
+  });
 
 export const sendTaskOutputSchema = z.object({
   yourAgentId: z.string().uuid().optional(),
@@ -175,6 +198,7 @@ export async function sendTaskHandler(
     slackChannelId,
     slackThreadTs,
     slackUserId,
+    overrideSlackContext,
     requestedByUserId: inputRequestedByUserId,
     followUpConfig,
   }: SendTaskArgs,
@@ -226,6 +250,42 @@ export async function sendTaskHandler(
   const effectiveParentTaskId = parentTaskId ?? sourceTaskId;
   const effectiveParentTask = effectiveParentTaskId ? getTaskById(effectiveParentTaskId) : null;
 
+  // Slack-routing coherence guard: reject a hand-typed slackChannelId/slackThreadTs
+  // that disagrees with the parent task or the contextKey this child will inherit.
+  // A mismatch here silently misroutes a worker's completion summary into the
+  // wrong human's Slack DM (see swarm memory
+  // dispatch-slack-channel-must-match-parent-context-2026-07-10). Omitting the
+  // three Slack fields lets inheritance do the right thing; overrideSlackContext
+  // opts into a deliberate cross-channel dispatch.
+  if (!overrideSlackContext) {
+    // send-task never passes contextKey explicitly, so the child inherits the
+    // parent's contextKey verbatim (createTaskExtended, src/be/db.ts:3556-3558).
+    const inheritedContextKey = effectiveParentTask?.contextKey;
+    const routingCheck = checkSlackRoutingCoherence({
+      explicit: { channelId: slackChannelId, threadTs: slackThreadTs, userId: slackUserId },
+      parent: effectiveParentTask,
+      inheritedContextKey,
+    });
+    if (routingCheck.verdict !== "ok") {
+      const msg =
+        routingCheck.verdict === "partial-unit"
+          ? `Slack routing rejected: ${routingCheck.detail}`
+          : `Slack routing mismatch: you passed ${routingCheck.field}="${routingCheck.got}" but the ${routingCheck.expectedSource} task says "${routingCheck.expected}". Omit the three Slack fields to inherit them from the parent as a unit (preferred), or pass overrideSlackContext: true if the cross-channel routing is deliberate.`;
+      return {
+        content: [{ type: "text", text: msg }],
+        structuredContent: {
+          yourAgentId: creatorAgentId,
+          success: false,
+          message: msg,
+        },
+      };
+    }
+  } else if (slackChannelId || slackThreadTs) {
+    console.log(
+      `[send-task] slack-context override: creatorAgentId=${creatorAgentId ?? "n/a"} slackChannelId=${slackChannelId ?? "n/a"} slackThreadTs=${slackThreadTs ?? "n/a"} parentTaskId=${effectiveParentTaskId ?? "n/a"}`,
+    );
+  }
+
   // Auto-route to parent's worker if parentTaskId is set and no explicit agentId
   let effectiveAgentId = agentId;
   if (effectiveParentTaskId && !agentId) {
@@ -345,6 +405,7 @@ export async function sendTaskHandler(
         slackChannelId,
         slackThreadTs,
         slackUserId,
+        overrideSlackContext,
         followUpConfig,
         // Only meaningful here: a pool task's routingAffinity gates
         // claimTask/autoAssignPoolTasks. offer/direct-assign below bypass the
@@ -412,6 +473,7 @@ export async function sendTaskHandler(
         slackChannelId,
         slackThreadTs,
         slackUserId,
+        overrideSlackContext,
         followUpConfig,
       });
       transferTrackerSyncToResumeChild({
@@ -446,6 +508,7 @@ export async function sendTaskHandler(
       slackChannelId,
       slackThreadTs,
       slackUserId,
+      overrideSlackContext,
       followUpConfig,
     });
     transferTrackerSyncToResumeChild({