@desplega.ai/agent-swarm 1.131.1 → 1.134.0

package/src/tools/poll-task.ts

@@ -2,18 +2,23 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { addMinutes } from "date-fns";
 import * as z from "zod";
 import {
+  getActiveTaskCount,
   getAgentById,
   getDb,
   getOfferedTasksForAgent,
   getPendingTaskForAgent,
   getUnassignedTasksCount,
+  hasCapacity,
   incrementEmptyPollCount,
   MAX_EMPTY_POLLS,
   resetEmptyPollCount,
   startTask,
   updateAgentStatus,
 } from "@/be/db";
+import { touchRuntimeInstance } from "@/be/multi-runtime";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+import type { AgentTask } from "@/types";
+import { isMultiRuntimeEnabled } from "@/utils/multi-runtime";
 import { looseAgentTaskOutputSchema } from "./get-task-details";
 
 const DEFAULT_POLL_INTERVAL_MS = 2000;
@@ -70,6 +75,28 @@ export const registerPollTaskTool = (server: McpServer) => {
       // touching the bookkeeping path below.
       const wasBudgetRefused: boolean = false;
 
+      // Second dispatch entrypoint alongside HTTP /api/poll, so it needs the
+      // same gate: a process whose runtime is gone must not pick up work
+      // beside its replacement. Touch validates ownership+liveness and
+      // refreshes it; it cannot revive a retired runtime.
+      if (
+        isMultiRuntimeEnabled() &&
+        !(
+          requestInfo.runtimeInstanceId &&
+          touchRuntimeInstance(requestInfo.runtimeInstanceId, agentId)
+        )
+      ) {
+        return toolOk("No task available.", {
+          details: "No task available for this runtime.",
+          data: {
+            yourAgentId: requestInfo.agentId,
+            offeredTasks: [],
+            availableCount: 0,
+            waitedForSeconds: 0,
+          },
+        });
+      }
+
       const agent = getAgentById(agentId);
       if (!agent) {
         return toolErr(`Agent with ID "${agentId}" not found in the swarm.`, {
@@ -104,26 +131,78 @@ export const registerPollTaskTool = (server: McpServer) => {
       // Poll for pending tasks
       while (new Date() < maxTime) {
         // Fetch and update in a single transaction to avoid race conditions
-        const startedTask = getDb().transaction(() => {
-          const agentNow = getAgentById(agentId)!;
+        const outcome = getDb().transaction(
+          (): AgentTask | "at-capacity" | "runtime-unavailable" | null => {
+            // The entry gate only proves liveness when the long poll began;
+            // the runtime must be live at the exact moment work is acquired,
+            // so revalidate in the same transaction that can start the task.
+            // Touch refreshes an already-live row and cannot revive one.
+            if (
+              isMultiRuntimeEnabled() &&
+              !(
+                requestInfo.runtimeInstanceId &&
+                touchRuntimeInstance(requestInfo.runtimeInstanceId, agentId)
+              )
+            ) {
+              return "runtime-unavailable";
+            }
+
+            const agentNow = getAgentById(agentId)!;
+
+            if (agentNow.status !== "busy") {
+              updateAgentStatus(agentId, "idle");
+            }
 
-          if (agentNow.status !== "busy") {
-            updateAgentStatus(agentId, "idle");
-          }
+            const pendingTask = getPendingTaskForAgent(agentId);
+            if (!pendingTask) return null;
 
-          const pendingTask = getPendingTaskForAgent(agentId);
-          if (!pendingTask) return null;
+            // Logical capacity is decided inside the same transaction as the
+            // start transition: several runtimes of one agent race this
+            // dispatch, and a check outside it would let each of them start a
+            // task past the agent's limit. Same gate as HTTP /api/poll.
+            if (!hasCapacity(agentId)) return "at-capacity";
 
-          const maybeTask = startTask(pendingTask.id);
+            const maybeTask = startTask(pendingTask.id);
 
-          if (maybeTask) {
-            // Update automatically in case the agent forgets xd
-            updateAgentStatus(agentId, "busy");
-          }
+            if (maybeTask) {
+              // Update automatically in case the agent forgets xd
+              updateAgentStatus(agentId, "busy");
+            }
 
-          return maybeTask;
-        })();
+            return maybeTask;
+          },
+        )();
+
+        if (outcome === "runtime-unavailable") {
+          // The runtime was retired while this call waited: stop immediately
+          // rather than keep polling as it, and skip the exit counter — this
+          // is a refusal, not an empty poll.
+          return toolOk("No task available.", {
+            details: "No task available for this runtime.",
+            data: {
+              yourAgentId: requestInfo.agentId,
+              offeredTasks: [],
+              availableCount: 0,
+              waitedForSeconds: Math.round((Date.now() - now.getTime()) / 1000),
+            },
+          });
+        }
+
+        if (outcome === "at-capacity") {
+          // A capacity refusal is not an empty poll (refused ≠ empty, D-R3):
+          // return without advancing the exit counter.
+          return toolOk("No task available.", {
+            details: `You are at capacity (${getActiveTaskCount(agentId)} active task(s)). Complete a task before polling for more.`,
+            data: {
+              yourAgentId: requestInfo.agentId,
+              offeredTasks: [],
+              availableCount: getUnassignedTasksCount(),
+              waitedForSeconds: Math.round((Date.now() - now.getTime()) / 1000),
+            },
+          });
+        }
 
+        const startedTask = outcome;
         if (startedTask) {
           // Reset empty poll count when task is assigned
           resetEmptyPollCount(agentId);

package/src/tools/script-common.ts

@@ -172,6 +172,11 @@ export async function proxyScriptsApi(args: {
   if (args.requestInfo.sourceTaskId) {
     headers["X-Source-Task-Id"] = args.requestInfo.sourceTaskId;
   }
+  // Runtime identity is process context from the worker's MCP session — it
+  // rides the proxy like the agent identity, never as tool or script input.
+  if (args.requestInfo.runtimeInstanceId) {
+    headers["X-Runtime-Instance-ID"] = args.requestInfo.runtimeInstanceId;
+  }
   const res = await fetch(`${apiBaseUrl()}${args.path}`, {
     method: args.method,
     headers,

package/src/tools/send-task.ts

@@ -223,11 +223,8 @@ export async function sendTaskHandler(
 
   const creatorAgentId = ctx.kind === "owner" ? ctx.agentId : undefined;
   const sourceTaskId = ctx.kind === "owner" ? ctx.sourceTaskId : undefined;
-  const callerTask = sourceTaskId ? getTaskById(sourceTaskId) : null;
   const requestedByUserId =
-    ctx.kind === "user"
-      ? ctx.userId
-      : (inputRequestedByUserId ?? callerTask?.requestedByUserId ?? undefined);
+    ctx.kind === "user" ? ctx.userId : (inputRequestedByUserId ?? undefined);
 
   if (ctx.kind === "owner" && agentId === ctx.agentId) {
     return toolErr("Cannot send a task to yourself, are you drunk?", {

package/src/tools/slack-archive-channel.ts

@@ -0,0 +1,70 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { can } from "@/rbac";
+import { getSlackApp } from "@/slack/app";
+import { slackMissingScopeMessage } from "@/slack/channel-join";
+import { archiveChannel } from "@/slack/channel-lifecycle";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+
+export const registerSlackArchiveChannelTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-archive-channel",
+    {
+      title: "Archive a Slack channel",
+      description:
+        "Archives a Slack channel. Channels that are already archived are treated as a successful no-op, while Slack's general channel cannot be archived. Requires lead privileges.",
+      annotations: { openWorldHint: true, destructiveHint: true },
+
+      inputSchema: z.object({
+        channelId: z.string().min(1).describe("The Slack channel ID to archive."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        channelId: z.string().optional(),
+        alreadyArchived: z.boolean().optional(),
+      }),
+    },
+    async ({ channelId }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return toolErr("Agent ID not found.");
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return toolErr("Agent not found.");
+      }
+
+      const decision = can({
+        principal: { kind: "agent", agentId: agent.id, isLead: agent.isLead },
+        verb: "integration.slack.channel.archive",
+        resource: { kind: "none" },
+        source: "mcp",
+      });
+      if (!decision.allow) {
+        return toolErr("Managing Slack channels requires lead privileges.");
+      }
+
+      const app = getSlackApp();
+      if (!app) {
+        return toolErr("Slack not configured.");
+      }
+
+      try {
+        const result = await archiveChannel(app.client, channelId);
+        return toolOk(
+          result.alreadyArchived
+            ? "Slack channel is already archived."
+            : "Slack channel archived successfully.",
+          { data: { channelId, ...result } },
+        );
+      } catch (error) {
+        const missingScopeMessage = slackMissingScopeMessage(error);
+        if (missingScopeMessage) {
+          return toolErr(`Failed to archive Slack channel: ${missingScopeMessage}`);
+        }
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return toolErr(`Failed to archive Slack channel: ${errorMsg}`);
+      }
+    },
+  );
+};

package/src/tools/slack-create-channel.ts

@@ -0,0 +1,74 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { can } from "@/rbac";
+import { getSlackApp } from "@/slack/app";
+import { slackMissingScopeMessage } from "@/slack/channel-join";
+import { createChannel } from "@/slack/channel-lifecycle";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+
+export const registerSlackCreateChannelTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-create-channel",
+    {
+      title: "Create a Slack channel",
+      description:
+        "Creates a public or private Slack channel. The supplied name is normalized to Slack's channel-name rules, and the normalized name is returned. Requires lead privileges.",
+      annotations: { openWorldHint: true },
+
+      inputSchema: z.object({
+        name: z.string().min(1).describe("The desired Slack channel name."),
+        isPrivate: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe("Whether to create a private channel. Defaults to false."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        channelId: z.string().optional(),
+        name: z.string().optional(),
+        isPrivate: z.boolean().optional(),
+      }),
+    },
+    async ({ name, isPrivate }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return toolErr("Agent ID not found.");
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return toolErr("Agent not found.");
+      }
+
+      const decision = can({
+        principal: { kind: "agent", agentId: agent.id, isLead: agent.isLead },
+        verb: "integration.slack.channel.create",
+        resource: { kind: "none" },
+        source: "mcp",
+      });
+      if (!decision.allow) {
+        return toolErr("Managing Slack channels requires lead privileges.");
+      }
+
+      const app = getSlackApp();
+      if (!app) {
+        return toolErr("Slack not configured.");
+      }
+
+      try {
+        const result = await createChannel(app.client, { name, isPrivate });
+        return toolOk("Slack channel created successfully.", {
+          details: `Created Slack channel ${result.name} (${result.channelId}).`,
+          data: { ...result, isPrivate },
+        });
+      } catch (error) {
+        const missingScopeMessage = slackMissingScopeMessage(error);
+        if (missingScopeMessage) {
+          return toolErr(`Failed to create Slack channel: ${missingScopeMessage}`);
+        }
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return toolErr(`Failed to create Slack channel: ${errorMsg}`);
+      }
+    },
+  );
+};

package/src/tools/slack-invite-to-channel.ts

@@ -0,0 +1,78 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getAgentById } from "@/be/db";
+import { can } from "@/rbac";
+import { getSlackApp } from "@/slack/app";
+import { slackMissingScopeMessage } from "@/slack/channel-join";
+import { inviteToChannel } from "@/slack/channel-lifecycle";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
+
+export const registerSlackInviteToChannelTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "slack-invite-to-channel",
+    {
+      title: "Invite users to a Slack channel",
+      description:
+        "Invites one or more workspace users to a Slack channel. Users who are already in the channel are treated as a successful no-op. Requires lead privileges.",
+      annotations: { openWorldHint: true },
+
+      inputSchema: z.object({
+        channelId: z.string().min(1).describe("The Slack channel ID."),
+        userIds: z
+          .array(z.string().min(1))
+          .min(1)
+          .max(100)
+          .describe("Slack user IDs to invite (up to 100)."),
+      }),
+      outputSchema: swarmToolOutputSchema({
+        channelId: z.string().optional(),
+        userIds: z.array(z.string()).optional(),
+        alreadyInChannel: z.boolean().optional(),
+      }),
+    },
+    async ({ channelId, userIds }, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return toolErr("Agent ID not found.");
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent) {
+        return toolErr("Agent not found.");
+      }
+
+      const decision = can({
+        principal: { kind: "agent", agentId: agent.id, isLead: agent.isLead },
+        verb: "integration.slack.channel.invite",
+        resource: { kind: "none" },
+        source: "mcp",
+      });
+      if (!decision.allow) {
+        return toolErr("Managing Slack channels requires lead privileges.");
+      }
+
+      const app = getSlackApp();
+      if (!app) {
+        return toolErr("Slack not configured.");
+      }
+
+      try {
+        const result = await inviteToChannel(app.client, channelId, userIds);
+        return toolOk(
+          result.alreadyInChannel
+            ? "Users are already in the Slack channel."
+            : "Users invited to the Slack channel successfully.",
+          {
+            data: { channelId, userIds, ...result },
+          },
+        );
+      } catch (error) {
+        const missingScopeMessage = slackMissingScopeMessage(error);
+        if (missingScopeMessage) {
+          return toolErr(`Failed to invite users to Slack channel: ${missingScopeMessage}`);
+        }
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return toolErr(`Failed to invite users to Slack channel: ${errorMsg}`);
+      }
+    },
+  );
+};

package/src/tools/store-progress.ts

@@ -24,6 +24,7 @@ import {
 import { createWorkerTaskFollowUp } from "@/tasks/worker-follow-up";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 import { AgentTaskStatusSchema, AttachmentInputSchema, isTerminalTaskStatus } from "@/types";
+import { scrubSecrets } from "../utils/secret-scrubber";
 
 // Phase 11: the `cost` / `costData` field was removed from this tool's input
 // schema. Adapters (claude/codex/pi/opencode/devin/claude-managed) are the
@@ -400,7 +401,12 @@ export const registerStoreProgressTool = (server: McpServer) => {
           } catch {
             // Non-blocking — task completion memory failure should not affect task status
           }
-        })();
+        })().catch((err) =>
+          console.error(
+            "[store-progress] task completion memory write failed:",
+            scrubSecrets(err instanceof Error ? err.message : String(err)),
+          ),
+        );
       }
 
       if (shouldRunTerminalSideEffects) {
@@ -436,7 +442,12 @@ export const registerStoreProgressTool = (server: McpServer) => {
               err instanceof Error ? err.message : String(err),
             );
           }
-        })();
+        })().catch((err) =>
+          console.error(
+            "[store-progress] server rater run failed:",
+            scrubSecrets(err instanceof Error ? err.message : String(err)),
+          ),
+        );
       }
 
       // Create follow-up task for the lead when a worker task finishes.

package/src/tools/swarm-config/delete-config.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { deleteSwarmConfig, getAgentById, getSwarmConfigLookupById } from "@/be/db";
+import { AGENT_MAX_TASKS_CONFIG_KEY, resetAgentMaxTasksMirror } from "@/be/multi-runtime";
 import { scheduleIntegrationsReload } from "@/http/core";
 import { can } from "@/rbac";
 import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
@@ -56,6 +57,14 @@ export const registerDeleteConfigTool = (server: McpServer) => {
         }
 
         const deleted = deleteSwarmConfig(id);
+        if (
+          deleted &&
+          existing.scope === "agent" &&
+          existing.scopeId &&
+          existing.key === AGENT_MAX_TASKS_CONFIG_KEY
+        ) {
+          resetAgentMaxTasksMirror(existing.scopeId);
+        }
         if (!deleted) {
           return toolErr(`Failed to delete config entry "${id}".`, {
             data: { yourAgentId: requestInfo.agentId },

package/src/tools/swarm-config/set-config.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { getAgentById, maskSecrets, upsertSwarmConfig } from "@/be/db";
+import { getAgentById, maskSecrets } from "@/be/db";
+import { upsertSwarmConfigWithPolicyMirror } from "@/be/multi-runtime";
 import {
   isReservedConfigKey,
   reservedKeyError,
@@ -110,7 +111,7 @@ export const registerSetConfigTool = (server: McpServer) => {
           return toolErr(validationError, { data: { yourAgentId: requestInfo.agentId } });
         }
 
-        const config = upsertSwarmConfig({
+        const config = upsertSwarmConfigWithPolicyMirror({
           scope,
           scopeId: scope === "global" ? null : scopeId,
           key,

package/src/tools/task-action.ts

@@ -27,6 +27,7 @@ import {
   releaseTask,
   updateTaskClaudeSessionId,
 } from "@/be/db";
+import { touchRuntimeInstance } from "@/be/multi-runtime";
 import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import {
   createToolRegistrar,
@@ -42,6 +43,7 @@ import {
   ReasoningEffortSchema,
   splitLegacyModelAlias,
 } from "@/types";
+import { isMultiRuntimeEnabled } from "@/utils/multi-runtime";
 import { looseAgentTaskOutputSchema } from "./get-task-details";
 
 export const TaskActionSchema = z.enum([
@@ -140,6 +142,28 @@ function agentOnlyActionResult(): SwarmToolResult {
   return toolErr("This action is only available to worker agents.");
 }
 
+/**
+ * Work-acquisition gate shared by claim and accept — the same dispatch gate
+ * as HTTP poll and poll-task: a process whose runtime is gone must not take
+ * work beside its replacement. Identity travels as request context, never as
+ * a tool argument; touch refreshes liveness and cannot revive a retired
+ * runtime. Returns null when acquisition may proceed.
+ */
+function staleRuntimeResult(ctx: ToolCtx, agentId: string): TaskActionResult | null {
+  if (!isMultiRuntimeEnabled()) return null;
+  if (
+    ctx.kind === "owner" &&
+    ctx.runtimeInstanceId &&
+    touchRuntimeInstance(ctx.runtimeInstanceId, agentId)
+  ) {
+    return null;
+  }
+  return {
+    success: false,
+    message: "This runtime is no longer registered. Re-register before taking work.",
+  };
+}
+
 function taskActionResult(result: TaskActionResult, agentId?: string): SwarmToolResult {
   const { refusalSideEffects: _omit, success, message, ...rest } = result;
   const data = {
@@ -285,6 +309,8 @@ export async function taskActionHandler(
         if (!taskId) {
           return { success: false, message: "Task ID is required for 'claim' action." };
         }
+        const staleClaimRuntime = staleRuntimeResult(ctx, agentId);
+        if (staleClaimRuntime) return staleClaimRuntime;
         // Check capacity before claiming
         if (!hasCapacity(agentId)) {
           const activeCount = getActiveTaskCount(agentId);
@@ -388,6 +414,10 @@ export async function taskActionHandler(
         if (!taskId) {
           return { success: false, message: "Task ID is required for 'accept' action." };
         }
+        // Accept is a work-acquisition transition too — gate it before the
+        // budget admission below so a retired process cannot take the offer.
+        const staleAcceptRuntime = staleRuntimeResult(ctx, agentId);
+        if (staleAcceptRuntime) return staleAcceptRuntime;
         const existingTask = getTaskById(taskId);
         if (!existingTask) {
           return { success: false, message: `Task "${taskId}" not found.` };

package/src/tools/task-tool-ctx.ts

@@ -3,13 +3,20 @@ import type { AgentTask, User } from "@/types";
 import { type RequestInfo, type SwarmToolResult, toolErr } from "./utils";
 
 export type ToolCtx =
-  | { kind: "owner"; agentId?: string; sourceTaskId?: string; sessionId?: string }
+  | {
+      kind: "owner";
+      agentId?: string;
+      runtimeInstanceId?: string;
+      sourceTaskId?: string;
+      sessionId?: string;
+    }
   | { kind: "user"; userId: string; user: User; sessionId?: string };
 
 export function ownerCtx(info: RequestInfo): ToolCtx {
   return {
     kind: "owner",
     agentId: info.agentId,
+    runtimeInstanceId: info.runtimeInstanceId,
     sourceTaskId: info.sourceTaskId,
     sessionId: info.sessionId,
   };

package/src/tools/tool-config.ts

@@ -87,7 +87,7 @@ export const DEFERRED_TOOLS = new Set([
   "context-history",
   "context-diff",
 
-  // Slack (9)
+  // Slack (12)
   "slack-reply",
   "slack-read",
   "slack-upload-file",
@@ -95,6 +95,9 @@ export const DEFERRED_TOOLS = new Set([
   "slack-list-channels",
   "slack-post",
   "slack-start-thread",
+  "slack-create-channel",
+  "slack-invite-to-channel",
+  "slack-archive-channel",
   "slack-delete",
   "slack-update",