@desplega.ai/agent-swarm 1.69.0 → 1.70.0

package/src/tests/sibling-block.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "bun:test";
+import {
+  formatRelativeTime,
+  pickResumeParent,
+  prependSiblingBlock,
+  renderSiblingBlock,
+  type SiblingTaskInfo,
+  stripSiblingBlock,
+  truncateForBlock,
+} from "../tasks/sibling-block";
+
+const NOW = Date.parse("2026-04-22T12:00:00.000Z");
+
+function sibling(overrides: Partial<SiblingTaskInfo> = {}): SiblingTaskInfo {
+  return {
+    id: "00000000-0000-0000-0000-000000000001",
+    status: "in_progress",
+    agentId: "agent-A",
+    agentName: "Picateclas",
+    description: "Do the thing",
+    updatedAt: new Date(NOW - 60_000).toISOString(),
+    ...overrides,
+  };
+}
+
+describe("truncateForBlock", () => {
+  test("returns string unchanged when under limit", () => {
+    expect(truncateForBlock("hello world")).toBe("hello world");
+  });
+
+  test("collapses internal whitespace", () => {
+    expect(truncateForBlock("hello\n\n  world\t!")).toBe("hello world !");
+  });
+
+  test("truncates to max length and appends ellipsis", () => {
+    const long = "a".repeat(250);
+    const out = truncateForBlock(long, 200);
+    expect(out.endsWith("…")).toBe(true);
+    expect(out.length).toBeLessThanOrEqual(201);
+  });
+
+  test("handles non-string input gracefully", () => {
+    // @ts-expect-error — runtime safety
+    expect(truncateForBlock(undefined)).toBe("");
+    // @ts-expect-error — runtime safety
+    expect(truncateForBlock(null)).toBe("");
+  });
+});
+
+describe("formatRelativeTime", () => {
+  test("seconds", () => {
+    expect(formatRelativeTime(NOW - 30_000, NOW)).toBe("30s");
+  });
+  test("minutes", () => {
+    expect(formatRelativeTime(NOW - 5 * 60_000, NOW)).toBe("5m");
+  });
+  test("hours", () => {
+    expect(formatRelativeTime(NOW - 3 * 3600_000, NOW)).toBe("3h");
+  });
+  test("days", () => {
+    expect(formatRelativeTime(NOW - 2 * 86_400_000, NOW)).toBe("2d");
+  });
+  test("treats future timestamps as 0s, not negative", () => {
+    expect(formatRelativeTime(NOW + 60_000, NOW)).toBe("0s");
+  });
+  test("returns 'unknown time' for unparseable input", () => {
+    expect(formatRelativeTime("not a date", NOW)).toBe("unknown time");
+  });
+});
+
+describe("renderSiblingBlock", () => {
+  test("returns empty string when there are no siblings", () => {
+    expect(renderSiblingBlock("task:slack:C1:1", [], NOW)).toBe("");
+  });
+
+  test("renders one sibling with all expected fields", () => {
+    const out = renderSiblingBlock("task:slack:C1:1", [sibling()], NOW);
+    expect(out).toContain("<sibling_tasks_in_progress>");
+    expect(out).toContain("</sibling_tasks_in_progress>");
+    expect(out).toContain("contextKey: task:slack:C1:1");
+    expect(out).toContain("[in_progress] task:00000000-0000-0000-0000-000000000001");
+    expect(out).toContain("agent:Picateclas");
+    expect(out).toContain("started 1m ago");
+    expect(out).toContain('"Do the thing"');
+  });
+
+  test("renders multiple siblings as separate bullets", () => {
+    const out = renderSiblingBlock(
+      "task:slack:C1:1",
+      [
+        sibling({ id: "id-1", description: "first" }),
+        sibling({
+          id: "id-2",
+          status: "pending",
+          description: "second",
+          updatedAt: new Date(NOW - 3600_000).toISOString(),
+        }),
+      ],
+      NOW,
+    );
+    expect(out).toContain("[in_progress] task:id-1");
+    expect(out).toContain("[pending] task:id-2");
+    expect(out).toContain("started 1h ago");
+  });
+
+  test("falls back to agent:unassigned when no agent info", () => {
+    const out = renderSiblingBlock(
+      "task:slack:C1:1",
+      [sibling({ agentId: null, agentName: null })],
+      NOW,
+    );
+    expect(out).toContain("agent:unassigned");
+  });
+
+  test("falls back to agentId when agentName missing", () => {
+    const out = renderSiblingBlock(
+      "task:slack:C1:1",
+      [sibling({ agentName: null, agentId: "agent-XYZ" })],
+      NOW,
+    );
+    expect(out).toContain("agent:agent-XYZ");
+  });
+
+  test("truncates long descriptions to 200 chars + ellipsis", () => {
+    const long = "x".repeat(500);
+    const out = renderSiblingBlock("task:slack:C1:1", [sibling({ description: long })], NOW);
+    expect(out).toContain("…");
+    // Per-description line: bullet has the truncated description in quotes.
+    const descLine = out.split("\n").find((l) => l.includes('"x'));
+    expect(descLine).toBeDefined();
+    expect((descLine as string).length).toBeLessThan(220);
+  });
+});
+
+describe("prependSiblingBlock", () => {
+  test("prepends the block with a blank line separator", () => {
+    const out = prependSiblingBlock("Original task body", "task:slack:C1:1", [sibling()], NOW);
+    expect(out.startsWith("<sibling_tasks_in_progress>")).toBe(true);
+    expect(out.endsWith("Original task body")).toBe(true);
+    expect(out).toContain("</sibling_tasks_in_progress>\n\nOriginal task body");
+  });
+
+  test("returns the description unchanged when there are no siblings", () => {
+    expect(prependSiblingBlock("Original", "task:slack:C1:1", [], NOW)).toBe("Original");
+  });
+});
+
+describe("stripSiblingBlock", () => {
+  test("returns description unchanged when no block", () => {
+    expect(stripSiblingBlock("Just a body")).toBe("Just a body");
+  });
+
+  test("removes a prepended block and its separator", () => {
+    const withBlock = prependSiblingBlock("Real body", "task:slack:C1:1", [sibling()], NOW);
+    expect(stripSiblingBlock(withBlock)).toBe("Real body");
+  });
+
+  test("removes a block that appears mid-description", () => {
+    const block = renderSiblingBlock("task:slack:C1:1", [sibling()], NOW);
+    const mixed = `Prelude\n\n${block}\n\nAfter`;
+    expect(stripSiblingBlock(mixed)).toBe("Prelude\n\nAfter");
+  });
+
+  test("returns input unchanged when tags are unmatched", () => {
+    const broken = "<sibling_tasks_in_progress> no closing tag here";
+    expect(stripSiblingBlock(broken)).toBe(broken);
+  });
+
+  test("handles non-string input", () => {
+    // @ts-expect-error — runtime safety
+    expect(stripSiblingBlock(undefined)).toBe("");
+  });
+});
+
+describe("pickResumeParent", () => {
+  test("returns null when currentAgentId is missing", () => {
+    expect(pickResumeParent([sibling()], null)).toBeNull();
+    expect(pickResumeParent([sibling()], undefined)).toBeNull();
+  });
+
+  test("returns null when no siblings are on the same agent", () => {
+    const out = pickResumeParent([sibling({ agentId: "agent-B" })], "agent-A");
+    expect(out).toBeNull();
+  });
+
+  test("returns null for empty input", () => {
+    expect(pickResumeParent([], "agent-A")).toBeNull();
+  });
+
+  test("in_progress beats pending even if pending is more recent", () => {
+    const recent_pending = sibling({
+      id: "rp",
+      status: "pending",
+      updatedAt: new Date(NOW).toISOString(),
+    });
+    const older_in_progress = sibling({
+      id: "oip",
+      status: "in_progress",
+      updatedAt: new Date(NOW - 3600_000).toISOString(),
+    });
+    const picked = pickResumeParent([recent_pending, older_in_progress], "agent-A");
+    expect(picked?.id).toBe("oip");
+  });
+
+  test("among same-status siblings, most recent wins", () => {
+    const older = sibling({ id: "o", updatedAt: new Date(NOW - 3600_000).toISOString() });
+    const newer = sibling({ id: "n", updatedAt: new Date(NOW - 60_000).toISOString() });
+    const picked = pickResumeParent([older, newer], "agent-A");
+    expect(picked?.id).toBe("n");
+  });
+
+  test("ordering: in_progress > pending > offered > paused", () => {
+    const all = [
+      sibling({ id: "p", status: "paused" }),
+      sibling({ id: "o", status: "offered" }),
+      sibling({ id: "pe", status: "pending" }),
+      sibling({ id: "ip", status: "in_progress" }),
+    ];
+    expect(pickResumeParent(all, "agent-A")?.id).toBe("ip");
+    expect(pickResumeParent(all.slice(0, 3), "agent-A")?.id).toBe("pe");
+    expect(pickResumeParent(all.slice(0, 2), "agent-A")?.id).toBe("o");
+    expect(pickResumeParent(all.slice(0, 1), "agent-A")?.id).toBe("p");
+  });
+
+  test("ignores siblings with null agentId", () => {
+    const out = pickResumeParent(
+      [sibling({ agentId: null }), sibling({ id: "ok", agentId: "agent-A" })],
+      "agent-A",
+    );
+    expect(out?.id).toBe("ok");
+  });
+});

package/src/tests/tool-annotations.test.ts

@@ -159,6 +159,7 @@ describe("Tool Annotations & Classification", () => {
       "slack-reply",
       "slack-read",
       "slack-post",
+      "slack-start-thread",
       "slack-upload-file",
       "slack-download-file",
       "slack-list-channels",

package/src/tools/slack-post.ts

@@ -9,14 +9,20 @@ export const registerSlackPostTool = (server: McpServer) => {
   createToolRegistrar(server)(
     "slack-post",
     {
-      title: "Post new message to Slack channel",
+      title: "Post message to Slack channel",
       description:
-        "Post a new message to a Slack channel. This creates a new message (not a thread reply). Requires lead privileges.",
+        "Post a message to a Slack channel. By default creates a new top-level message; pass `threadTs` to post as a threaded reply under an existing message (obtain the ts from `slack-start-thread`). Requires lead privileges.",
       annotations: { openWorldHint: true },
 
       inputSchema: z.object({
         channelId: z.string().min(1).describe("The Slack channel ID to post to."),
         message: z.string().min(1).max(4000).describe("The message content to post."),
+        threadTs: z
+          .string()
+          .optional()
+          .describe(
+            "Optional parent message ts to thread under. Obtain via `slack-start-thread`. When omitted, posts as a new top-level message.",
+          ),
       }),
       outputSchema: z.object({
         success: z.boolean(),
@@ -24,7 +30,7 @@ export const registerSlackPostTool = (server: McpServer) => {
         messageTs: z.string().optional(),
       }),
     },
-    async ({ channelId, message }, requestInfo, _meta) => {
+    async ({ channelId, message, threadTs }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
         return {
           content: [{ type: "text", text: "Agent ID not found." }],
@@ -67,6 +73,7 @@ export const registerSlackPostTool = (server: McpServer) => {
           text: slackMessage, // Fallback for notifications
           username: agent.name,
           icon_emoji: ":crown:",
+          ...(threadTs ? { thread_ts: threadTs } : {}),
           blocks: [
             {
               type: "section",

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

@@ -0,0 +1,123 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { getSlackApp } from "@/slack/app";
+import { markdownToSlack } from "@/slack/responses";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSlackStartThreadTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-start-thread",
+    {
+      title: "Start a new Slack thread",
+      description:
+        "Post a new top-level message to a Slack channel and return its ts so the caller can thread replies under it. Pass the returned `ts` as `threadTs` on subsequent `slack-post` calls to keep replies in the same thread. Requires lead privileges.",
+      annotations: { openWorldHint: true },
+
+      inputSchema: z.object({
+        channelId: z.string().min(1).describe("The Slack channel ID to post to."),
+        message: z.string().min(1).max(4000).describe("The message content to post."),
+      }),
+      outputSchema: z.object({
+        success: z.boolean(),
+        message: z.string(),
+        channelId: z.string().optional(),
+        ts: z.string().optional(),
+      }),
+    },
+    async ({ channelId, message }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return {
+          content: [{ type: "text", text: "Agent not found." }],
+          structuredContent: { success: false, message: "Agent not found." },
+        };
+      }
+
+      if (!agent.isLead) {
+        return {
+          content: [{ type: "text", text: "Posting to Slack channels requires lead privileges." }],
+          structuredContent: {
+            success: false,
+            message: "Posting to Slack channels requires lead privileges.",
+          },
+        };
+      }
+
+      const app = getSlackApp();
+      if (!app) {
+        return {
+          content: [{ type: "text", text: "Slack not configured." }],
+          structuredContent: { success: false, message: "Slack not configured." },
+        };
+      }
+
+      try {
+        const slackMessage = markdownToSlack(message);
+
+        const result = await app.client.chat.postMessage({
+          channel: channelId,
+          text: slackMessage, // Fallback for notifications
+          username: agent.name,
+          icon_emoji: ":crown:",
+          blocks: [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: slackMessage,
+              },
+            },
+          ],
+        });
+
+        const ts = result.ts;
+        const resolvedChannelId = result.channel ?? channelId;
+
+        if (!ts) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "Message posted but Slack did not return a ts — cannot thread replies.",
+              },
+            ],
+            structuredContent: {
+              success: false,
+              message: "Message posted but Slack did not return a ts — cannot thread replies.",
+              channelId: resolvedChannelId,
+            },
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Thread started. channelId=${resolvedChannelId}, ts=${ts}. Pass ts as threadTs on slack-post to reply in-thread.`,
+            },
+          ],
+          structuredContent: {
+            success: true,
+            message: "Thread started successfully.",
+            channelId: resolvedChannelId,
+            ts,
+          },
+        };
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text", text: `Failed to start thread: ${errorMsg}` }],
+          structuredContent: { success: false, message: `Failed to start thread: ${errorMsg}` },
+        };
+      }
+    },
+  );
+};

package/src/tools/tool-config.ts

@@ -80,13 +80,14 @@ export const DEFERRED_TOOLS = new Set([
   "context-history",
   "context-diff",
 
-  // Slack (6)
+  // Slack (7)
   "slack-reply",
   "slack-read",
   "slack-upload-file",
   "slack-download-file",
   "slack-list-channels",
   "slack-post",
+  "slack-start-thread",
 
   // Channel management (2)
   "create-channel",

package/src/tools/update-profile.ts

@@ -226,9 +226,12 @@ export const registerUpdateProfileTool = (server: McpServer) => {
           },
         );
 
-        // Write updated files to workspace only when updating self
+        // Write updated files to workspace only when updating self AND the caller
+        // matches the real running agent (process.env.AGENT_ID). This guards against
+        // unit tests (with fake WORKER_IDs) accidentally overwriting the container's
+        // SOUL.md/IDENTITY.md when the test suite runs inside a real agent container.
         // (remote agent files live on their own container)
-        if (isUpdatingSelf) {
+        if (isUpdatingSelf && requestInfo.agentId === process.env.AGENT_ID) {
           if (soulMd !== undefined) {
             try {
               await Bun.write("/workspace/SOUL.md", soulMd);

package/src/types.ts

@@ -141,6 +141,11 @@ export const AgentTaskSchema = z.object({
   workflowRunId: z.string().uuid().nullable().optional(),
   workflowRunStepId: z.string().uuid().nullable().optional(),
 
+  // Cross-ingress context key — uniform identifier for the "context entity"
+  // (Slack thread, GitHub issue, Linear issue, schedule, workflow run, ...).
+  // See src/tasks/context-key.ts. Nullable: legacy rows stay NULL.
+  contextKey: z.string().optional(),
+
   // Structured output schema (optional — JSON Schema that task output must conform to)
   outputSchema: z.record(z.string(), z.unknown()).optional(),
 

package/src/workflows/executors/agent-task.ts

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { workflowContextKey } from "../../tasks/context-key";
+import { withSiblingAwareness } from "../../tasks/sibling-awareness";
 import type { ExecutorMeta } from "../../types";
 import type { ExecutorResult } from "./base";
 import { BaseExecutor } from "./base";
@@ -77,20 +79,25 @@ export class AgentTaskExecutor extends BaseExecutor<
     }
 
     // 3. Create the task (config is already deep-interpolated by the engine)
-    const task = db.createTaskExtended(config.template, {
-      agentId: config.agentId ?? null,
-      source: "workflow",
-      tags: config.tags,
-      priority: config.priority,
-      offeredTo: config.offerMode ? config.agentId : undefined,
-      workflowRunId: meta.runId,
-      workflowRunStepId: meta.stepId,
-      dir: effectiveDir,
-      vcsRepo: effectiveVcsRepo,
-      model: config.model,
-      parentTaskId: config.parentTaskId,
-      outputSchema: config.outputSchema,
-    });
+    const { description: taskDescription, options: taskOptions } = withSiblingAwareness(
+      config.template,
+      {
+        agentId: config.agentId ?? null,
+        source: "workflow",
+        tags: config.tags,
+        priority: config.priority,
+        offeredTo: config.offerMode ? config.agentId : undefined,
+        workflowRunId: meta.runId,
+        workflowRunStepId: meta.stepId,
+        dir: effectiveDir,
+        vcsRepo: effectiveVcsRepo,
+        model: config.model,
+        parentTaskId: config.parentTaskId,
+        outputSchema: config.outputSchema,
+        contextKey: workflowContextKey({ workflowRunId: meta.runId }),
+      },
+    );
+    const task = db.createTaskExtended(taskDescription, taskOptions);
 
     // 4. Return async result — engine will pause the workflow
     return {