@desplega.ai/agent-swarm 1.131.1 → 1.134.0

package/src/queue-stall-alarm.ts

@@ -0,0 +1,216 @@
+import { getDb } from "./be/db";
+import { getSlackApp } from "./slack/app";
+import { scrubSecrets } from "./utils/secret-scrubber";
+
+export const QUEUE_STALL_THRESHOLD_MS = 30 * 60 * 1000;
+export const QUEUE_STALL_CHECK_INTERVAL_MS = 5 * 60 * 1000;
+const QUEUE_STALL_STARTUP_DELAY_MS = 10_000;
+
+export interface QueueStallSnapshot {
+  claimableCount: number;
+  oldestTaskId: string | null;
+  oldestClaimableAt: string | null;
+  oldestAgeMs: number;
+  recentPickupCount: number;
+}
+
+type QueueStallNotifier = (message: string) => Promise<void>;
+
+let alarmInterval: ReturnType<typeof setInterval> | null = null;
+let startupTimeout: ReturnType<typeof setTimeout> | null = null;
+let checkInFlight = false;
+let alarmActive = false;
+
+/**
+ * Read the queue denominator and oldest age in one snapshot. Tasks with unmet
+ * dependencies are excluded because a worker cannot start them yet.
+ */
+export function getQueueStallSnapshot(now = new Date()): QueueStallSnapshot {
+  const oldest = getDb()
+    .prepare<
+      { claimableCount: number; oldestTaskId: string | null; oldestClaimableAt: string | null },
+      []
+    >(
+      `WITH queued AS (
+         SELECT
+           t.id,
+           t.dependsOn,
+           COALESCE(
+             (
+               SELECT MAX(entry.createdAt)
+               FROM agent_log entry
+               WHERE entry.taskId = t.id
+                 AND entry.newValue = t.status
+                 AND entry.eventType IN (
+                   'task_created',
+                   'task_status_change',
+                   'task_released',
+                   'task_accepted',
+                   'task_rejected'
+                 )
+             ),
+             t.createdAt
+           ) AS queueEnteredAt
+         FROM agent_tasks t
+         WHERE t.status IN ('pending', 'unassigned')
+       ),
+       claimable AS (
+         SELECT
+           queued.id,
+           MAX(
+             queued.queueEnteredAt,
+             COALESCE(
+               (
+                 SELECT MAX(COALESCE(prerequisite.finishedAt, prerequisite.createdAt))
+                 FROM json_each(COALESCE(queued.dependsOn, '[]')) dep
+                 JOIN agent_tasks prerequisite ON prerequisite.id = dep.value
+               ),
+               queued.queueEnteredAt
+             )
+           ) AS claimableAt
+         FROM queued
+         WHERE NOT EXISTS (
+             SELECT 1
+             FROM json_each(COALESCE(queued.dependsOn, '[]')) dep
+             LEFT JOIN agent_tasks prerequisite ON prerequisite.id = dep.value
+             WHERE prerequisite.id IS NULL OR prerequisite.status != 'completed'
+           )
+       ),
+       oldest AS (
+         SELECT id, claimableAt FROM claimable ORDER BY claimableAt ASC LIMIT 1
+       )
+       SELECT
+         (SELECT COUNT(*) FROM claimable) AS claimableCount,
+         (SELECT id FROM oldest) AS oldestTaskId,
+         (SELECT claimableAt FROM oldest) AS oldestClaimableAt`,
+    )
+    .get();
+
+  const pickupCutoff = new Date(now.getTime() - QUEUE_STALL_THRESHOLD_MS).toISOString();
+  const recentPickupCount =
+    getDb()
+      .prepare<{ count: number }, [string]>(
+        `SELECT COUNT(*) AS count
+         FROM agent_log
+         WHERE eventType IN ('task_status_change', 'task_claimed')
+           AND oldValue IN ('pending', 'unassigned')
+           AND newValue = 'in_progress'
+           AND createdAt >= ?`,
+      )
+      .get(pickupCutoff)?.count ?? 0;
+
+  const oldestClaimableAt = oldest?.oldestClaimableAt ?? null;
+  return {
+    claimableCount: oldest?.claimableCount ?? 0,
+    oldestTaskId: oldest?.oldestTaskId ?? null,
+    oldestClaimableAt,
+    oldestAgeMs: oldestClaimableAt
+      ? Math.max(0, now.getTime() - new Date(oldestClaimableAt).getTime())
+      : 0,
+    recentPickupCount,
+  };
+}
+
+export function isQueueStalled(snapshot: QueueStallSnapshot): boolean {
+  return snapshot.claimableCount > 0 && snapshot.oldestAgeMs >= QUEUE_STALL_THRESHOLD_MS;
+}
+
+function formatAge(ageMs: number): string {
+  return `${Math.floor(ageMs / 60_000)}m`;
+}
+
+function formatCheckFailure(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return `[Queue Stall Alarm] Check or notification failed: ${scrubSecrets(message)}`;
+}
+
+async function notifySlack(message: string): Promise<void> {
+  const channel = process.env.SLACK_ALERTS_CHANNEL?.trim();
+  if (!channel) throw new Error("SLACK_ALERTS_CHANNEL is not configured");
+
+  const app = getSlackApp();
+  if (!app) throw new Error("Slack is not connected");
+
+  await app.client.chat.postMessage({
+    channel,
+    text: message,
+    unfurl_links: false,
+    unfurl_media: false,
+  });
+}
+
+/** Run one detector tick. Exported so tests and operators can exercise it directly. */
+export async function checkQueueStall(
+  now = new Date(),
+  notify: QueueStallNotifier = notifySlack,
+): Promise<QueueStallSnapshot> {
+  const snapshot = getQueueStallSnapshot(now);
+  const stalled = isQueueStalled(snapshot);
+
+  if (stalled && !alarmActive) {
+    await notify(
+      `🚨 *Agent Swarm queue pickup stalled*\n` +
+        `Claimable tasks: *${snapshot.claimableCount}*\n` +
+        `Oldest wait: *${formatAge(snapshot.oldestAgeMs)}* (task \`${snapshot.oldestTaskId}\`)\n` +
+        `Pickups in the last 30m: *${snapshot.recentPickupCount}*\n\n` +
+        "This alarm runs in the API process and does not require an agent to claim a task.",
+    );
+    alarmActive = true;
+    console.error(
+      `[Queue Stall Alarm] Fired: claimable=${snapshot.claimableCount}, oldest=${snapshot.oldestTaskId}, age=${formatAge(snapshot.oldestAgeMs)}, recent_pickups=${snapshot.recentPickupCount}`,
+    );
+  } else if (!stalled && alarmActive) {
+    await notify(
+      `✅ *Agent Swarm queue pickup recovered*\nClaimable tasks: *${snapshot.claimableCount}*\nPickups in the last 30m: *${snapshot.recentPickupCount}*`,
+    );
+    alarmActive = false;
+    console.log("[Queue Stall Alarm] Recovery notification sent");
+  }
+
+  return snapshot;
+}
+
+function scheduleCheck(): void {
+  if (checkInFlight) return;
+  checkInFlight = true;
+  checkQueueStall()
+    .catch((error) => {
+      console.error(formatCheckFailure(error));
+    })
+    .finally(() => {
+      checkInFlight = false;
+    });
+}
+
+export function startQueueStallAlarm(): void {
+  if (alarmInterval || startupTimeout) return;
+
+  console.log(
+    `[Queue Stall Alarm] Starting (threshold ${formatAge(QUEUE_STALL_THRESHOLD_MS)}, interval ${formatAge(QUEUE_STALL_CHECK_INTERVAL_MS)})`,
+  );
+  startupTimeout = setTimeout(() => {
+    startupTimeout = null;
+    scheduleCheck();
+  }, QUEUE_STALL_STARTUP_DELAY_MS);
+  alarmInterval = setInterval(scheduleCheck, QUEUE_STALL_CHECK_INTERVAL_MS);
+}
+
+export function stopQueueStallAlarm(): void {
+  if (startupTimeout) {
+    clearTimeout(startupTimeout);
+    startupTimeout = null;
+  }
+  if (alarmInterval) {
+    clearInterval(alarmInterval);
+    alarmInterval = null;
+  }
+  checkInFlight = false;
+}
+
+export const _test = {
+  formatCheckFailure,
+  resetState(): void {
+    stopQueueStallAlarm();
+    alarmActive = false;
+  },
+};

package/src/rbac/legacy-policy.ts

@@ -162,6 +162,9 @@ export const LEGACY_POLICY = {
   "integration.slack.post": leadOnly,
   "integration.slack.read": leadOnly,
   "integration.slack.thread.start": leadOnly,
+  "integration.slack.channel.create": leadOnly,
+  "integration.slack.channel.invite": leadOnly,
+  "integration.slack.channel.archive": leadOnly,
   "integration.slack.upload": leadOnly,
   "integration.slack.delete": leadOnly,
   "integration.slack.update": leadOnly,

package/src/rbac/permissions.ts

@@ -93,6 +93,18 @@ export const PERMISSIONS = {
     description: "Start a thread in a direct Slack channel.",
     namespace: "integration",
   },
+  "integration.slack.channel.create": {
+    description: "Create a Slack channel.",
+    namespace: "integration",
+  },
+  "integration.slack.channel.invite": {
+    description: "Invite users to a Slack channel.",
+    namespace: "integration",
+  },
+  "integration.slack.channel.archive": {
+    description: "Archive a Slack channel.",
+    namespace: "integration",
+  },
   "integration.slack.upload": {
     description: "Upload a file to a direct Slack channel.",
     namespace: "integration",

package/src/scheduler/scheduler.ts

@@ -4,6 +4,7 @@ import {
   getDb,
   getDueScheduledTasks,
   getScheduledTaskById,
+  getUserById,
   getWorkflow,
   updateScheduledTask,
 } from "@/be/db";
@@ -117,10 +118,16 @@ export interface DispatchScheduleResult {
   task?: AgentTask;
 }
 
+function withoutDeletedRequester(schedule: ScheduledTask): ScheduledTask {
+  if (!schedule.createdBy || getUserById(schedule.createdBy)) return schedule;
+  return { ...schedule, createdBy: undefined };
+}
+
 export async function dispatchScheduleTarget(
   schedule: ScheduledTask,
   extraTags: string[] = [],
 ): Promise<DispatchScheduleResult> {
+  schedule = withoutDeletedRequester(schedule);
   switch (schedule.targetType) {
     case "workflow": {
       if (!schedule.workflowId) {

package/src/script-workflows/executor.ts

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { mkdir, rm } from "node:fs/promises";
 import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ScriptRun } from "../types";
 import {
   buildSandboxedCommand,
@@ -40,7 +41,7 @@ export interface ScriptExecutor {
 
 export function getScriptWorkflowHarnessPath(): string {
   const runtimeDir = process.env.SCRIPT_WORKFLOW_RUNTIME_DIR;
-  if (!runtimeDir) return new URL("./harness.ts", import.meta.url).pathname;
+  if (!runtimeDir) return fileURLToPath(new URL("./harness.ts", import.meta.url));
 
   const bundledHarness = `${resolve(runtimeDir)}/harness.bundle.js`;
   if (!existsSync(bundledHarness)) {

package/src/scripts-runtime/executors/native.ts

@@ -1,3 +1,4 @@
+import { fileURLToPath } from "node:url";
 import {
   buildSandboxedCommand,
   readStreamCapped,
@@ -120,7 +121,7 @@ export class NativeScriptExecutor implements ScriptExecutor {
     // subprocesses cannot access. Use the pre-built bundle from real filesystem instead.
     const harnessPath = process.env.SCRIPT_RUNTIME_DIR
       ? `${process.env.SCRIPT_RUNTIME_DIR}/eval-harness.bundle.js`
-      : new URL("../eval-harness.ts", import.meta.url).pathname;
+      : fileURLToPath(new URL("../eval-harness.ts", import.meta.url));
     const controller = new AbortController();
     let timedOut = false;
     let killed = input.signal?.aborted ?? false;

package/src/scripts-runtime/executors/types.ts

@@ -10,6 +10,11 @@ export type SwarmConfigPayload = {
     apiKey: { value: string; isSecret: true };
     agentId: { value: string; isSecret: false };
     mcpBaseUrl: { value: string; isSecret: false };
+    /**
+     * Per-boot runtime identity of the invoking worker process. System
+     * context like the agent identity — scripts never supply or override it.
+     */
+    runtimeInstanceId?: { value: string; isSecret: false };
   };
   user: Record<string, { value: string; isSecret: boolean }>;
   egressSecrets?: EgressSecretEntry[];

package/src/scripts-runtime/loader.ts

@@ -19,6 +19,8 @@ export type RunScriptInput = {
   args?: unknown;
   fsMode?: ScriptFsMode;
   agentId: string;
+  /** Per-boot runtime identity of the invoking worker; system context, never script input. */
+  runtimeInstanceId?: string;
   signal?: AbortSignal;
   timeoutMs?: number;
   mcpBaseUrl?: string;
@@ -50,6 +52,9 @@ async function buildConfigPayload(input: RunScriptInput): Promise<SwarmConfigPay
         value: input.mcpBaseUrl ?? process.env.MCP_BASE_URL ?? "http://localhost:3013",
         isSecret: false,
       },
+      ...(input.runtimeInstanceId
+        ? { runtimeInstanceId: { value: input.runtimeInstanceId, isSecret: false as const } }
+        : {}),
     },
     user: input.userConfig ?? {},
     egressSecrets: input.egressSecrets ?? (await buildEgressSecrets()),

package/src/scripts-runtime/sdk-allowlist.ts

@@ -69,6 +69,9 @@ export const SDK_TOOL_NAME_MAP = {
   slack_post: "slack-post", // external: sends to Slack
   slack_reply: "slack-reply", // external: sends to Slack
   slack_startThread: "slack-start-thread", // external: sends to Slack
+  slack_createChannel: "slack-create-channel", // external: mutates Slack
+  slack_inviteToChannel: "slack-invite-to-channel", // external: mutates Slack
+  slack_archiveChannel: "slack-archive-channel", // external: mutates Slack
   slack_uploadFile: "slack-upload-file", // external: sends to Slack
   slack_downloadFile: "slack-download-file",
   slack_delete: "slack-delete", // external: mutates Slack, destructive

package/src/scripts-runtime/swarm-config.ts

@@ -5,6 +5,8 @@ export class SwarmConfig {
   readonly apiKey: RedactedValue<string>;
   readonly agentId: RedactedValue<string>;
   readonly mcpBaseUrl: RedactedValue<string>;
+  /** Per-boot runtime identity of the invoking worker; system context, never script input. */
+  readonly runtimeInstanceId: RedactedValue<string> | undefined;
 
   private readonly userValues: Map<string, RedactedValue<string>>;
 
@@ -21,6 +23,12 @@ export class SwarmConfig {
       type: "system",
       isSecret: payload.system.mcpBaseUrl.isSecret,
     });
+    this.runtimeInstanceId = payload.system.runtimeInstanceId
+      ? Redacted.make(payload.system.runtimeInstanceId.value, {
+          type: "system",
+          isSecret: payload.system.runtimeInstanceId.isSecret,
+        })
+      : undefined;
     this.userValues = new Map(
       Object.entries(payload.user ?? {}).map(([key, value]) => [
         key,

package/src/scripts-runtime/swarm-sdk.ts

@@ -14,6 +14,12 @@ function headers(config: SwarmConfig): Record<string, string> {
   return {
     Authorization: `Bearer ${Redacted.value(config.apiKey)}`,
     "X-Agent-ID": Redacted.value(config.agentId),
+    // Per-boot identity of the invoking worker process (system context, not
+    // script input) — work-acquisition endpoints gate on it in multi-runtime
+    // mode.
+    ...(config.runtimeInstanceId
+      ? { "X-Runtime-Instance-ID": Redacted.value(config.runtimeInstanceId) }
+      : {}),
     "Content-Type": "application/json",
   };
 }
@@ -168,6 +174,7 @@ function bridgeRequestFor(name: string, args: unknown): BridgeRequest | null {
           hideCompleted: body.hideCompleted,
           consecutiveErrorsMin: body.consecutiveErrorsMin,
           lastRunStatus: body.lastRunStatus,
+          fields: body.includeFull ? "full" : undefined,
         }),
       };
     case "schedule_create":

package/src/scripts-runtime/types/stdlib.d.ts

@@ -158,6 +158,7 @@ declare module "swarm-sdk" {
       hideCompleted?: boolean;
       consecutiveErrorsMin?: number;
       lastRunStatus?: "failed" | "succeeded";
+      includeFull?: boolean;
     }): Promise<unknown>;
     // --- scripts ---
     script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;
@@ -325,6 +326,9 @@ declare module "swarm-sdk" {
       message: string;
       blocks?: unknown;
     }): Promise<unknown>;
+    slack_createChannel(args: { name: string; isPrivate?: boolean }): Promise<unknown>;
+    slack_inviteToChannel(args: { channelId: string; userIds: string[] }): Promise<unknown>;
+    slack_archiveChannel(args: { channelId: string }): Promise<unknown>;
     slack_uploadFile(args: Record<string, unknown>): Promise<unknown>;
     slack_downloadFile(args: { url: string }): Promise<unknown>;
     slack_delete(args: { channelId: string; messageTs: string }): Promise<unknown>;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -140,6 +140,7 @@ declare module "swarm-sdk" {
       hideCompleted?: boolean;
       consecutiveErrorsMin?: number;
       lastRunStatus?: "failed" | "succeeded";
+      includeFull?: boolean;
     }): Promise<unknown>;
     // --- scripts ---
     script_search(args: { query?: string; scope?: ScriptScope; limit?: number }): Promise<unknown>;
@@ -307,6 +308,9 @@ declare module "swarm-sdk" {
       message: string;
       blocks?: unknown;
     }): Promise<unknown>;
+    slack_createChannel(args: { name: string; isPrivate?: boolean }): Promise<unknown>;
+    slack_inviteToChannel(args: { channelId: string; userIds: string[] }): Promise<unknown>;
+    slack_archiveChannel(args: { channelId: string }): Promise<unknown>;
     slack_uploadFile(args: Record<string, unknown>): Promise<unknown>;
     slack_downloadFile(args: { url: string }): Promise<unknown>;
     slack_delete(args: { channelId: string; messageTs: string }): Promise<unknown>;

package/src/server.ts

@@ -119,8 +119,11 @@ import {
   registerSkillUninstallTool,
   registerSkillUpdateTool,
 } from "./tools/skills";
+import { registerSlackArchiveChannelTool } from "./tools/slack-archive-channel";
+import { registerSlackCreateChannelTool } from "./tools/slack-create-channel";
 import { registerSlackDeleteTool } from "./tools/slack-delete";
 import { registerSlackDownloadFileTool } from "./tools/slack-download-file";
+import { registerSlackInviteToChannelTool } from "./tools/slack-invite-to-channel";
 import { registerSlackListChannelsTool } from "./tools/slack-list-channels";
 import { registerSlackPostTool } from "./tools/slack-post";
 import { registerSlackReadTool } from "./tools/slack-read";
@@ -504,6 +507,9 @@ export function createServer(opts: { scriptsOnly?: boolean; fullSurface?: boolea
     registerSlackReadTool(server);
     registerSlackPostTool(server);
     registerSlackStartThreadTool(server);
+    registerSlackCreateChannelTool(server);
+    registerSlackInviteToChannelTool(server);
+    registerSlackArchiveChannelTool(server);
     registerSlackListChannelsTool(server);
     registerSlackUploadFileTool(server);
     registerSlackDownloadFileTool(server);

package/src/slack/channel-join.ts

@@ -2,14 +2,33 @@ import type { WebClient } from "@slack/web-api";
 
 const logger = console;
 
+type SlackErrorData = {
+  error?: unknown;
+  needed?: unknown;
+};
+
 // @slack/web-api platform errors set message to "An API error occurred: <code>"
-// and store the raw Slack API code at error.data.error.
-function slackCode(error: unknown): string | undefined {
+// and store Slack's full response body on error.data.
+function slackErrorData(error: unknown): SlackErrorData | undefined {
   if (!(error instanceof Error)) return undefined;
-  const d = (error as { data?: { error?: unknown } }).data;
+  return (error as { data?: SlackErrorData }).data;
+}
+
+export function slackCode(error: unknown): string | undefined {
+  const d = slackErrorData(error);
   return typeof d?.error === "string" ? d.error : undefined;
 }
 
+export function slackMissingScopeMessage(error: unknown): string | undefined {
+  const data = slackErrorData(error);
+  if (data?.error !== "missing_scope" || typeof data.needed !== "string") return undefined;
+
+  const needed = data.needed.trim();
+  if (!needed) return undefined;
+
+  return `Slack requires the \`${needed}\` scope. Add it to slack-manifest.json, apply the updated manifest to the Slack app, then reinstall the app to the workspace for the change to take effect.`;
+}
+
 /**
  * Returns true if the channel has any external (non-host-org) members.
  * Uses Slack's documented flags: is_ext_shared (accepted Connect) and

package/src/slack/channel-lifecycle.ts

@@ -0,0 +1,114 @@
+import type { WebClient } from "@slack/web-api";
+import { slackCode } from "@/slack/channel-join";
+
+export type CreateChannelResult = {
+  channelId: string;
+  name: string;
+};
+
+export type InviteToChannelResult = {
+  alreadyInChannel: boolean;
+};
+
+export type ArchiveChannelResult = {
+  alreadyArchived: boolean;
+};
+
+export function normalizeChannelName(name: string): string {
+  const normalized = name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, "-")
+    .replace(/^[-_]+|[-_]+$/g, "")
+    .slice(0, 80)
+    .replace(/[-_]+$/g, "");
+
+  if (!normalized) {
+    throw new Error("Slack channel name must contain at least one letter or number.");
+  }
+
+  return normalized;
+}
+
+export async function createChannel(
+  client: WebClient,
+  { name, isPrivate = false }: { name: string; isPrivate?: boolean },
+): Promise<CreateChannelResult> {
+  const normalizedName = normalizeChannelName(name);
+
+  try {
+    const result = await client.conversations.create({
+      name: normalizedName,
+      is_private: isPrivate,
+    });
+    const channelId = result.channel?.id;
+    if (!channelId) {
+      throw new Error("Slack created the channel but did not return its ID.");
+    }
+
+    return { channelId, name: normalizedName };
+  } catch (error) {
+    if (slackCode(error) === "name_taken") {
+      throw new Error(`Slack channel name "${normalizedName}" is already taken.`);
+    }
+    throw error;
+  }
+}
+
+export async function inviteToChannel(
+  client: WebClient,
+  channelId: string,
+  userIds: string[],
+): Promise<InviteToChannelResult> {
+  if (userIds.length === 0) {
+    throw new Error("At least one Slack user ID is required.");
+  }
+
+  try {
+    await client.conversations.invite({
+      channel: channelId,
+      users: userIds.join(","),
+    });
+    return { alreadyInChannel: false };
+  } catch (error) {
+    if (slackCode(error) !== "already_in_channel") {
+      throw error;
+    }
+
+    let allAlreadyInChannel = true;
+    for (const userId of userIds) {
+      try {
+        await client.conversations.invite({ channel: channelId, users: userId });
+        allAlreadyInChannel = false;
+      } catch (userError) {
+        if (slackCode(userError) !== "already_in_channel") {
+          throw userError;
+        }
+      }
+    }
+
+    return { alreadyInChannel: allAlreadyInChannel };
+  }
+}
+
+export async function archiveChannel(
+  client: WebClient,
+  channelId: string,
+): Promise<ArchiveChannelResult> {
+  try {
+    await client.conversations.archive({ channel: channelId });
+    return { alreadyArchived: false };
+  } catch (error) {
+    const code = slackCode(error);
+    if (code === "already_archived") {
+      return { alreadyArchived: true };
+    }
+    if (code === "cant_archive_general") {
+      throw new Error("Slack's general channel cannot be archived.");
+    }
+    if (code === "cant_archive_required") {
+      throw new Error("This required Slack channel cannot be archived.");
+    }
+    throw error;
+  }
+}

package/src/tests/budget-claim-gate.test.ts

@@ -128,6 +128,7 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     if ("error" in body) throw new Error("unexpected error response");
     expect(body.trigger?.type).toBe("task_assigned");
     expect((body.trigger as { taskId: string }).taskId).toBe(task.id);
+    expect(getAgentById(worker.id)?.status).toBe("busy");
   });
 
   test("pending task trigger includes requester role and notes", async () => {
@@ -272,6 +273,25 @@ describe("Phase 3 — /api/poll budget admission gate", () => {
     expect(claimedTriggers).toHaveLength(1);
     expect(nullTriggers).toHaveLength(1);
   });
+
+  test("pool claim marks the agent busy before the poll transaction returns", async () => {
+    const worker = createAgent({
+      name: "claim-status",
+      isLead: false,
+      status: "idle",
+      maxTasks: 1,
+    });
+    const pooled = createTaskExtended("claim status task", {});
+
+    expect(getAgentById(worker.id)?.status).toBe("idle");
+
+    const { body } = await callPoll(worker.id);
+
+    if ("error" in body) throw new Error("unexpected error response");
+    expect(body.trigger?.type).toBe("task_assigned");
+    expect((body.trigger as { taskId: string }).taskId).toBe(pooled.id);
+    expect(getAgentById(worker.id)?.status).toBe("busy");
+  });
 });
 
 // ─── MCP task-action accept tests ───────────────────────────────────────────

package/src/tests/claude-adapter.test.ts

@@ -687,6 +687,38 @@ describe("mergeMcpConfig (issue #369)", () => {
     expect((entry.headers as Record<string, string>)["X-Source-Task-Id"]).toBe(TASK_ID);
   });
 
+  test("agent-swarm server gets X-Runtime-Instance-ID when a runtime identity is given", () => {
+    const base = {
+      mcpServers: {
+        "agent-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID, undefined, "runtime-boot-1");
+    const agentSwarm = merged.mcpServers["agent-swarm"] as Record<string, unknown>;
+    expect((agentSwarm.headers as Record<string, string>)["X-Runtime-Instance-ID"]).toBe(
+      "runtime-boot-1",
+    );
+  });
+
+  test("no runtime identity → no X-Runtime-Instance-ID header", () => {
+    const base = {
+      mcpServers: {
+        "agent-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID);
+    const agentSwarm = merged.mcpServers["agent-swarm"] as Record<string, unknown>;
+    expect((agentSwarm.headers as Record<string, string>)["X-Runtime-Instance-ID"]).toBeUndefined();
+  });
+
   test("does not mutate the input baseConfig", () => {
     const base = {
       mcpServers: {