@desplega.ai/agent-swarm 1.100.2 → 1.100.3

package/src/tests/slack-channel-join.test.ts

@@ -10,21 +10,70 @@ function makePlatformError(code: string): Error {
   return err;
 }
 
+type ChannelShape = {
+  is_ext_shared?: boolean;
+  is_pending_ext_shared?: boolean;
+};
+
+function makeClient(opts: {
+  channel?: ChannelShape;
+  infoResult?: () => unknown;
+  joinResult?: () => unknown;
+}): {
+  client: WebClient;
+  infoFn: ReturnType<typeof mock>;
+  joinFn: ReturnType<typeof mock>;
+} {
+  const infoFn = mock(
+    opts.infoResult
+      ? opts.infoResult
+      : () => Promise.resolve({ channel: opts.channel ?? { is_ext_shared: false } }),
+  );
+  const joinFn = mock(opts.joinResult ? opts.joinResult : () => Promise.resolve({}));
+  const client = {
+    conversations: { info: infoFn, join: joinFn },
+  } as unknown as WebClient;
+  return { client, infoFn, joinFn };
+}
+
 describe("withAutoJoin", () => {
-  test("success: fn called once, join not called", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+  test("success: fn called once, join and info not called", async () => {
+    const { client, infoFn, joinFn } = makeClient({});
     const fn = mock(() => Promise.resolve("ok"));
 
     const result = await withAutoJoin(client, "C123", fn);
     expect(result).toBe("ok");
     expect(fn).toHaveBeenCalledTimes(1);
+    expect(infoFn).not.toHaveBeenCalled();
     expect(joinFn).not.toHaveBeenCalled();
   });
 
-  test("not_in_channel: calls join then retries fn exactly once", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+  test("not_in_channel on internal channel: fetches info, calls join, retries fn exactly once", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "retried-ok";
+    });
+
+    const result = await withAutoJoin(client, "CPUB", fn);
+    expect(result).toBe("retried-ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(infoFn).toHaveBeenCalledTimes(1);
+    expect(infoFn).toHaveBeenCalledWith({ channel: "CPUB" });
+    expect(joinFn).toHaveBeenCalledTimes(1);
+    expect(joinFn).toHaveBeenCalledWith({ channel: "CPUB" });
+  });
+
+  test("info failure falls back to join and retries fn", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      infoResult: () => {
+        throw makePlatformError("channel_not_found");
+      },
+    });
     let callCount = 0;
     const fn = mock(async () => {
       callCount++;
@@ -35,46 +84,131 @@ describe("withAutoJoin", () => {
     const result = await withAutoJoin(client, "CPUB", fn);
     expect(result).toBe("retried-ok");
     expect(fn).toHaveBeenCalledTimes(2);
+    expect(infoFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledWith({ channel: "CPUB" });
   });
 
-  test("private channel: join fails with method_not_supported_for_channel_type → descriptive error", async () => {
-    const joinFn = mock(() => {
-      throw makePlatformError("method_not_supported_for_channel_type");
+  test("private channel: info returns internal, join fails with method_not_supported → descriptive error", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+      joinResult: () => {
+        throw makePlatformError("method_not_supported_for_channel_type");
+      },
     });
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
     const fn = mock(() => {
       throw makePlatformError("not_in_channel");
     });
 
     await expect(withAutoJoin(client, "CPRIV", fn)).rejects.toThrow("invite the bot");
+    expect(infoFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledTimes(1);
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
-  test("non-not_in_channel error: rethrown without join", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
+  test("info failure preserves private-channel invite error from join", async () => {
+    const { client, infoFn, joinFn } = makeClient({
+      infoResult: () => {
+        throw makePlatformError("not_in_channel");
+      },
+      joinResult: () => {
+        throw makePlatformError("method_not_supported_for_channel_type");
+      },
+    });
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CPRIV", fn)).rejects.toThrow("invite the bot");
+    expect(infoFn).toHaveBeenCalledTimes(1);
+    expect(joinFn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  test("non-not_in_channel error: rethrown without info or join", async () => {
+    const { client, infoFn, joinFn } = makeClient({});
     const fn = mock(() => {
       throw makePlatformError("channel_not_found");
     });
 
     await expect(withAutoJoin(client, "C123", fn)).rejects.toThrow("channel_not_found");
+    expect(infoFn).not.toHaveBeenCalled();
     expect(joinFn).not.toHaveBeenCalled();
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
   test("retry is bounded: second fn error propagates without another join", async () => {
-    const joinFn = mock(() => Promise.resolve({}));
-    const client = { conversations: { join: joinFn } } as unknown as WebClient;
-    // Every call throws not_in_channel, but we only join once and retry once
+    const { client, infoFn, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
     const fn = mock(() => {
       throw makePlatformError("not_in_channel");
     });
 
     await expect(withAutoJoin(client, "C123", fn)).rejects.toThrow("not_in_channel");
     expect(fn).toHaveBeenCalledTimes(2);
+    expect(infoFn).toHaveBeenCalledTimes(1);
     expect(joinFn).toHaveBeenCalledTimes(1); // no infinite loop
   });
+
+  // --- External channel guard tests ---
+
+  test("external guard: is_ext_shared=true → throws invite error, join not called", async () => {
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: true },
+    });
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CEXT", fn)).rejects.toThrow("invite the bot");
+    expect(joinFn).not.toHaveBeenCalled();
+  });
+
+  test("external guard: is_pending_ext_shared=true → throws invite error, join not called", async () => {
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: false, is_pending_ext_shared: true },
+    });
+    const fn = mock(() => {
+      throw makePlatformError("not_in_channel");
+    });
+
+    await expect(withAutoJoin(client, "CPENDING", fn)).rejects.toThrow("invite the bot");
+    expect(joinFn).not.toHaveBeenCalled();
+  });
+
+  test("external guard: internal public channel (is_ext_shared:false) → join proceeds", async () => {
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "joined-ok";
+    });
+
+    const result = await withAutoJoin(client, "CPUB", fn);
+    expect(result).toBe("joined-ok");
+    expect(joinFn).toHaveBeenCalledTimes(1);
+  });
+
+  test("external guard: Enterprise Grid org-shared channel (is_ext_shared:false, multiple teams) → join proceeds, no false-positive", async () => {
+    // An internal org-shared channel on Enterprise Grid legitimately lists multiple
+    // internal team IDs. The guard must rely solely on is_ext_shared/is_pending_ext_shared
+    // — not team-ID comparison — to avoid false-positives here.
+    const { client, joinFn } = makeClient({
+      channel: { is_ext_shared: false },
+    });
+    let callCount = 0;
+    const fn = mock(async () => {
+      callCount++;
+      if (callCount === 1) throw makePlatformError("not_in_channel");
+      return "joined-ok";
+    });
+
+    const result = await withAutoJoin(client, "CGRID", fn);
+    expect(result).toBe("joined-ok");
+    expect(joinFn).toHaveBeenCalledTimes(1);
+  });
 });

package/src/tools/send-task.ts

@@ -11,10 +11,11 @@ import {
   getTaskById,
   hasCapacity,
 } from "@/be/db";
+import { repointTrackerSyncBySwarmId } from "@/be/db-queries/tracker";
 import { findDuplicateTask } from "@/tools/task-dedup";
 import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
-import { AgentTaskSchema, FollowUpConfigSchema } from "@/types";
+import { type AgentTask, AgentTaskSchema, FollowUpConfigSchema } from "@/types";
 import { ModelTierSchema, splitLegacyModelAlias } from "../model-tiers";
 
 export const sendTaskInputSchema = z.object({
@@ -103,6 +104,40 @@ export const sendTaskOutputSchema = z.object({
 
 type SendTaskArgs = z.infer<typeof sendTaskInputSchema>;
 
+const TRACKER_OWNERSHIP_TRANSFER_PARENT_STATUSES = new Set([
+  "superseded",
+  "completed",
+  "failed",
+  "cancelled",
+]);
+
+/**
+ * When `send-task` creates a `resume` task whose parent is in a terminal state,
+ * move the parent's `tracker_sync` rows (Linear / Jira / GitHub outbound link)
+ * onto the new resume child so the re-delegated work keeps its external-tracker
+ * completion link. General-correct for any Lead re-delegation of a resume;
+ * specifically it completes the DES-523 tracker chain on the gone-agent path:
+ * original → R1 (pin) → R1 → original (reaper) → original → R2 (here). No-op for
+ * non-resume tasks or when the parent has no tracker_sync rows.
+ */
+function transferTrackerSyncToResumeChild(args: {
+  parentTaskId?: string;
+  taskType?: string;
+  child: AgentTask;
+}): void {
+  if (args.taskType !== "resume" || !args.parentTaskId) return;
+
+  const parent = getTaskById(args.parentTaskId);
+  if (!parent || !TRACKER_OWNERSHIP_TRANSFER_PARENT_STATUSES.has(parent.status)) return;
+
+  const repointed = repointTrackerSyncBySwarmId(parent.id, args.child.id);
+  if (repointed > 0) {
+    console.log(
+      `[send-task] Repointed ${repointed} tracker_sync row(s) from terminal parent ${parent.id.slice(0, 8)} to resume child ${args.child.id.slice(0, 8)}`,
+    );
+  }
+}
+
 export async function sendTaskHandler(
   ctx: ToolCtx,
   {
@@ -278,6 +313,11 @@ export async function sendTaskHandler(
         slackUserId,
         followUpConfig,
       });
+      transferTrackerSyncToResumeChild({
+        parentTaskId: effectiveParentTaskId,
+        taskType,
+        child: newTask,
+      });
 
       return {
         success: true,
@@ -332,6 +372,11 @@ export async function sendTaskHandler(
         slackUserId,
         followUpConfig,
       });
+      transferTrackerSyncToResumeChild({
+        parentTaskId: effectiveParentTaskId,
+        taskType,
+        child: newTask,
+      });
 
       return {
         success: true,
@@ -360,6 +405,11 @@ export async function sendTaskHandler(
       slackUserId,
       followUpConfig,
     });
+    transferTrackerSyncToResumeChild({
+      parentTaskId: effectiveParentTaskId,
+      taskType,
+      child: newTask,
+    });
 
     return {
       success: true,

package/src/tools/templates.ts

@@ -160,3 +160,64 @@ Use \`get-task-details\` with taskId "{{task_id}}" for full details.`,
   ],
   category: "task_lifecycle",
 });
+
+// ============================================================================
+// Reroute-decision follow-up (Lead-routed crash-recovery, DES-523)
+//
+// Created by the heartbeat's stale-resume reaper when a crash-recovery resume
+// was pinned to its original agent but never reclaimed within the grace window
+// (the agent that looked recoverable never returned). Hands the Lead a DECISION
+// task — not the raw work — telling it to re-delegate via `send-task` with an
+// EXPLICIT agentId. The crashed agent's identity is provided as routing context
+// only; the Lead picks who takes over. This work never falls back to the pool.
+// ============================================================================
+
+registerTemplate({
+  eventType: "task.reroute.decision",
+  header: "",
+  defaultBody: `Reroute decision: a crashed worker's task needs a new owner.
+
+Crashed agent: {{original_agent_name}}
+Identity / specialization: {{original_agent_identity}}
+Original task ID: {{original_task_id}}
+Trigger: {{reason}}
+Task: "{{task_desc}}"
+
+Resume generation: {{generation_next}} of {{max_generations}} (max).{{artifacts_block}}
+
+## Your job
+
+The worker that was handling this task crashed and did not come back within the grace window, so its pinned resume was never reclaimed. Pick an agent to take this work over and RE-DELEGATE it — do NOT execute it yourself, and do NOT leave routing to the default.
+
+Use the crashed agent's identity above as context for who was on it and what kind of work it is. You may re-delegate to the same kind of agent, a peer, or whoever you judge appropriate — the choice is yours, but you MUST choose explicitly.
+
+Dispatch via \`send-task\` with ALL of:
+- an explicit \`agentId\` (the chosen worker) — REQUIRED. If you omit it, \`send-task\` auto-routes to the original task's agent, which is the dead worker, and the work re-strands.
+- \`taskType: "resume"\`
+- the tag \`resume-generation:{{generation_next}}\`
+- \`parentTaskId: {{original_task_id}}\`
+- do NOT inherit the original task's \`model\` (the new worker runs on its own).
+
+This work will NOT fall back to the unassigned pool — you are the only re-delegation path.`,
+  variables: [
+    { name: "original_agent_name", description: "Name or ID prefix of the crashed agent" },
+    {
+      name: "original_agent_identity",
+      description:
+        "Identity/specialization slice of the crashed agent (from identityMd), or a placeholder when none is recorded",
+    },
+    { name: "original_task_id", description: "ID of the superseded original task" },
+    { name: "reason", description: "Reroute trigger reason (e.g. crash_recovery)" },
+    { name: "task_desc", description: "Original task description (truncated to 200 chars)" },
+    {
+      name: "generation_next",
+      description: "Next resume generation number (must be set on the dispatched resume)",
+    },
+    { name: "max_generations", description: "Maximum resume generations before budget exhaustion" },
+    {
+      name: "artifacts_block",
+      description: "Formatted attachment list from the original task, or empty string",
+    },
+  ],
+  category: "task_lifecycle",
+});