@desplega.ai/agent-swarm 2.5.4 → 2.7.0

package/src/tests/docs-index.test.ts

@@ -0,0 +1,135 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  collectDocsPages,
+  coverageErrors,
+  INDEX_END,
+  INDEX_START,
+  renderDocsIndex,
+  replaceIndexBlock,
+  SKILL_CONTENT_PATH,
+} from "../../scripts/build-docs-index";
+import { loadSeedSkills } from "../be/seed-skills";
+
+const page = (frontmatter: string, body = "Body.\n") => `---\n${frontmatter}\n---\n\n${body}`;
+
+describe("docs index (real docs tree)", () => {
+  test("every playbook is in the index and the coverage rules pass", async () => {
+    const pages = await collectDocsPages();
+    expect(coverageErrors(pages)).toEqual([]);
+
+    const index = renderDocsIndex(pages);
+    const playbooks = pages.filter((p) => p.path.startsWith("playbooks/"));
+    expect(playbooks.length).toBeGreaterThan(10);
+    for (const playbook of playbooks) {
+      expect(index).toContain(`(https://docs.agent-swarm.dev/docs/${playbook.slug})`);
+    }
+    // Positive control: a known playbook carries its trigger.
+    expect(index).toContain(
+      "[Open Oncall](https://docs.agent-swarm.dev/docs/playbooks/open-oncall). When: ",
+    );
+    // Negative control: opted-out pages are reference only, release notes are skipped.
+    expect(index).toContain("(https://docs.agent-swarm.dev/docs/playbooks). Reference.");
+    expect(index).not.toContain("/docs/releases/");
+  });
+
+  test("the committed skill body matches the generator", async () => {
+    const content = await Bun.file(SKILL_CONTENT_PATH).text();
+    const regenerated = replaceIndexBlock(content, renderDocsIndex(await collectDocsPages()));
+    expect(content).toBe(regenerated);
+  });
+
+  test("the generator is deterministic", async () => {
+    const first = renderDocsIndex(await collectDocsPages());
+    const second = renderDocsIndex(await collectDocsPages());
+    expect(second).toBe(first);
+  });
+
+  test("the seeded skill is a system default and carries the index", async () => {
+    const skill = (await loadSeedSkills()).find((s) => s.name === "swarm-docs");
+    expect(skill?.systemDefault).toBe(true);
+    expect(skill?.content).toContain("https://docs.agent-swarm.dev/docs/playbooks/open-oncall");
+  });
+});
+
+describe("docs index (fixture tree)", () => {
+  let root: string;
+
+  beforeAll(async () => {
+    root = await mkdtemp(join(tmpdir(), "docs-index-"));
+    await mkdir(join(root, "playbooks"), { recursive: true });
+    await mkdir(join(root, "guides"), { recursive: true });
+    await mkdir(join(root, "releases"), { recursive: true });
+    await Bun.write(join(root, "meta.json"), JSON.stringify({ pages: ["index", "playbooks"] }));
+    await Bun.write(join(root, "index.mdx"), page("title: Home"));
+    await Bun.write(
+      join(root, "playbooks", "meta.json"),
+      JSON.stringify({ pages: ["index", "b", "---Separator---", "a"] }),
+    );
+    await Bun.write(
+      join(root, "playbooks", "index.mdx"),
+      page("title: Playbooks\nagent:\n  offer: false"),
+    );
+    await Bun.write(
+      join(root, "playbooks", "a.mdx"),
+      page('title: A\nagent:\n  when: "Someone wants A"\n  template: "community/a"'),
+    );
+    await Bun.write(join(root, "playbooks", "b.mdx"), page("title: B"));
+    await Bun.write(
+      join(root, "guides", "g.mdx"),
+      page("title: G\nagent:\n  offer: true\n  notWhen: never"),
+    );
+    await Bun.write(join(root, "releases", "r.mdx"), page("title: R"));
+  });
+
+  afterAll(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  test("orders by meta.json, appends unlisted folders, and skips releases", async () => {
+    const pages = await collectDocsPages(root);
+    expect(pages.map((p) => p.path)).toEqual([
+      "index",
+      "playbooks/index",
+      "playbooks/b",
+      "playbooks/a",
+      "guides/g",
+    ]);
+    expect(pages.map((p) => p.slug)).toEqual([
+      "",
+      "playbooks",
+      "playbooks/b",
+      "playbooks/a",
+      "guides/g",
+    ]);
+  });
+
+  test("a playbook without when, and an offered guide without when, fail coverage", async () => {
+    const errors = coverageErrors(await collectDocsPages(root));
+    expect(errors).toEqual([
+      "playbooks/b: playbook needs agent.when (or agent.offer: false)",
+      "guides/g: agent.offer is true but agent.when is missing",
+    ]);
+  });
+
+  test("renders triggers and templates for offered pages only", async () => {
+    const index = renderDocsIndex(await collectDocsPages(root));
+    expect(index).toContain(
+      "- [A](https://docs.agent-swarm.dev/docs/playbooks/a). When: Someone wants A. Template: `community/a`.",
+    );
+    expect(index).toContain(
+      "- [Playbooks](https://docs.agent-swarm.dev/docs/playbooks). Reference.",
+    );
+    expect(index).toContain("- [Home](https://docs.agent-swarm.dev/docs)");
+  });
+
+  test("replaceIndexBlock swaps only the marked block and rejects missing markers", () => {
+    const content = `before\n${INDEX_START}\nold\n${INDEX_END}\nafter\n`;
+    expect(replaceIndexBlock(content, `${INDEX_START}\nnew\n${INDEX_END}`)).toBe(
+      `before\n${INDEX_START}\nnew\n${INDEX_END}\nafter\n`,
+    );
+    expect(() => replaceIndexBlock("no markers", "x")).toThrow();
+  });
+});

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

@@ -376,7 +376,7 @@ describe("dsh harness", () => {
     await rename(join(config.cwd, "dsh"), join(config.cwd, "npx"));
     config.env = { ...config.env, DSH_BINARY: "", PATH: config.cwd };
     await expect(new DshAdapter().createSession(config)).rejects.toThrow(
-      "dsh CLI not found. Install @deepseek-ai/dsh@0.2.1-rc.3",
+      "dsh CLI not found. Install @deepseek-ai/dsh@0.2.1-rc.4",
     );
     expect(await Bun.file(join(config.cwd, "invocation.json")).exists()).toBe(false);
   });

package/src/tests/extensions-pre-task.test.ts

@@ -14,6 +14,7 @@ import {
   createWorkflowRunStep,
   getDbClient,
   getKv,
+  getMostRecentTaskInThread,
   getTaskByWorkflowRunStepId,
   initDb,
   startTask,
@@ -22,7 +23,7 @@ import * as dbClient from "../be/db-client";
 import type { InstallExtensionArgs as ExtensionInstallBody } from "../be/extensions/db";
 import { installExtension, listExtensionRuns } from "../be/extensions/db";
 import { getCatalogEntry } from "../extensions/catalog";
-import type { TaskBlockedEvent } from "../extensions/contract";
+import type { TaskBlockedEvent, TaskCreateEvent } from "../extensions/contract";
 import { disableExtension, enableExtension, stopExtensionRuntime } from "../extensions/lifecycle";
 import { initExtensionPostBridge, teardownExtensionPostBridge } from "../extensions/post-bridge";
 import { handleTasks } from "../http/tasks";
@@ -551,6 +552,57 @@ export default extension;
     );
   });
 
+  test("Slack event metadata retains mixed-sender batches and rejects metadata rewrites", async () => {
+    await createAgent({ name: "slack-metadata-lead", isLead: true, status: "idle" });
+    await installSource(
+      "a-rewrite-slack-metadata",
+      `import type { SwarmExtension } from "swarm-extension";
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", () => ({ action: "modify", data: {
+    priority: 7, slack: { trigger: "mention", messages: [] }
+  } as never }));
+};
+export default extension;
+`,
+    );
+    const recorder = await installAndEnable("record-task-create");
+    const channelId = "C_EVENT_METADATA";
+    const threadTs = "3000.0001";
+    bufferThreadMessage(channelId, threadTs, "first request", "U_FIRST", "3000.0002");
+    bufferThreadMessage(channelId, threadTs, "second request", "U_SECOND", "3000.0003");
+
+    await instantFlush(`${channelId}:${threadTs}`);
+
+    const event = (await getKv(`task:agent:${recorder.agentId}`, "ext:record-task-create:last"))
+      ?.value as TaskCreateEvent & { slack?: unknown };
+    expect(event.slack).toEqual({
+      trigger: "thread-buffer",
+      messages: [
+        { ts: "3000.0002", userId: "U_FIRST", text: "first request" },
+        { ts: "3000.0003", userId: "U_SECOND", text: "second request" },
+      ],
+    });
+    expect(event.origin).toBe("slack");
+    expect(event.options).toMatchObject({
+      slackTriggerMessageTs: "3000.0003",
+      slackUserId: "U_FIRST",
+      priority: 7,
+    });
+    expect(event.options).not.toHaveProperty("slack");
+    const task = await getMostRecentTaskInThread(channelId, threadTs);
+    expect(task).toMatchObject({
+      priority: 7,
+      slackTriggerMessageTs: "3000.0003",
+      slackUserId: "U_FIRST",
+    });
+    expect(task).not.toHaveProperty("slack");
+
+    await createTaskWithSiblingAwareness("ordinary API task", { source: "api" });
+    const apiEvent = (await getKv(`task:agent:${recorder.agentId}`, "ext:record-task-create:last"))
+      ?.value as TaskCreateEvent & { slack?: unknown };
+    expect(apiEvent).not.toHaveProperty("slack");
+  });
+
   test("scheduler and workflow executor provide their task creation origins", async () => {
     const extension = await installSource(
       "record-task-origin",

package/src/tests/fetch-resolved-env.test.ts

@@ -41,8 +41,12 @@ const defaultMockResponse: MockResponse = {
 const mockResponsesByAgentId = new Map<string, MockResponse>();
 const requestedRepoIds = new Map<string, string | null>();
 const requestedTaskIds = new Map<string, string | null>();
-/** Every `GET /api/keys/available` query string observed by the mock server, most recent last. */
+/**
+ * Every `GET /api/keys/available` query string observed by the mock server,
+ * most recent last, without `keySuffixes` (recorded in `keysAvailableSuffixes`).
+ */
 const keysAvailableRequests: string[] = [];
+const keysAvailableSuffixes: Array<string | null> = [];
 
 beforeAll(() => {
   server = Bun.serve({
@@ -63,7 +67,10 @@ beforeAll(() => {
       }
 
       if (url.pathname === "/api/keys/available") {
-        keysAvailableRequests.push(url.search);
+        const params = new URLSearchParams(url.search);
+        keysAvailableSuffixes.push(params.get("keySuffixes"));
+        params.delete("keySuffixes");
+        keysAvailableRequests.push(`?${params}`);
         const totalKeys = Number(url.searchParams.get("totalKeys") ?? "1");
         const availableIndices = Array.from({ length: totalKeys }, (_, i) => i);
         return Response.json({ success: true, availableIndices, totalKeys });
@@ -455,6 +462,13 @@ describe("fetchResolvedEnv", () => {
       expect(keysAvailableRequests).toEqual([
         "?keyType=CLAUDE_CODE_OAUTH_TOKEN&totalKeys=32&model=fable",
       ]);
+      // The pool's own suffixes, in order, so status is matched by key (issue #2425).
+      expect(keysAvailableSuffixes.at(-1)).toBe(
+        Object.values(envWithOauthPool(32))[0]!
+          .split(",")
+          .map((key) => key.slice(-5))
+          .join(","),
+      );
     });
 
     test("model: 'claude-fable-5-1' issues the same model=fable", async () => {

package/src/tests/fixtures/extensions/record-task-create/hooks.ts

@@ -0,0 +1,9 @@
+import type { SwarmExtension } from "swarm-extension";
+
+const extension: SwarmExtension = (api) => {
+  api.on("pre.task.create", async (event, ctx) => {
+    await ctx.state.set("last", event);
+  });
+};
+
+export default extension;

package/src/tests/fixtures/extensions/record-task-create/manifest.json

@@ -0,0 +1,7 @@
+{
+  "name": "record-task-create",
+  "description": "Records task creation events",
+  "version": "1.0.0",
+  "runtime": "api",
+  "assets": { "hooks": "hooks.ts" }
+}

package/src/tests/fleet-benchmark.test.ts

@@ -326,6 +326,14 @@ describe("GET /api/fleet-benchmark", () => {
     expect(fetched).toHaveLength(1);
   });
 
+  test("a use case the catalog does not list yet compares against the whole fleet", async () => {
+    await addTasks(10, "completed", 1);
+    await setProfile("2-10", "content");
+    const response = await buildFleetBenchmarkResponse(NOW);
+    expect(response).toMatchObject({ state: "ready", level: "full", peerGroup: null });
+    expect(fetched).toEqual(["http://proxy.test/v1/fleet/benchmarks?window=30d"]);
+  });
+
   test("full profile tolerates absent or null peer_group from the proxy", async () => {
     await addTasks(10, "completed", 1);
     await setProfile();

package/src/tests/get-workflow-run-tool.test.ts

@@ -0,0 +1,98 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  closeDb,
+  createWorkflow,
+  createWorkflowRun,
+  createWorkflowRunStep,
+  initDb,
+  updateWorkflowRun,
+  updateWorkflowRunStep,
+} from "../be/db";
+import { registerGetWorkflowRunTool } from "../tools/workflows/get-workflow-run";
+
+const dbPath = `./test-get-workflow-run-tool-${process.pid}.sqlite`;
+
+type ToolResult = {
+  isError?: boolean;
+  structuredContent: {
+    message: string;
+    run?: Record<string, unknown>;
+    steps?: Array<Record<string, unknown>>;
+  };
+};
+let handler: (args: unknown, extra: unknown) => Promise<ToolResult>;
+let runId: string;
+
+async function removeDb() {
+  for (const suffix of ["", "-wal", "-shm"]) await unlink(dbPath + suffix).catch(() => undefined);
+}
+
+beforeAll(async () => {
+  await removeDb();
+  initDb(dbPath);
+  const workflow = await createWorkflow({
+    name: "get-workflow-run-tool",
+    definition: { nodes: [{ id: "poll", type: "notify", config: { template: "x" } }] },
+  });
+  runId = crypto.randomUUID();
+  await createWorkflowRun({ id: runId, workflowId: workflow.id });
+  const context = { poll: { attempts: 2 }, blob: "x".repeat(2_000) };
+  for (let i = 0; i < 2; i++) {
+    const step = await createWorkflowRunStep({
+      id: crypto.randomUUID(),
+      runId,
+      nodeId: "poll",
+      nodeType: "notify",
+      input: { ...context, iteration: i },
+    });
+    await updateWorkflowRunStep(step.id, {
+      status: "completed",
+      output: { iteration: i },
+      retryCount: i,
+      finishedAt: new Date().toISOString(),
+    });
+  }
+  await updateWorkflowRun(runId, { status: "completed", context });
+
+  const server = new McpServer({ name: "get-workflow-run-tool", version: "1.0.0" });
+  registerGetWorkflowRunTool(server);
+  handler = (server as unknown as { _registeredTools: Record<string, { handler: typeof handler }> })
+    ._registeredTools["get-workflow-run"]!.handler;
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDb();
+});
+
+const extra = { sessionId: "get-workflow-run-tool", requestInfo: { headers: {} } };
+
+test("defaults to the full run with context and step inputs", async () => {
+  const result = await handler({ id: runId }, extra);
+  expect(result.isError).not.toBe(true);
+  const { run, steps } = result.structuredContent;
+  expect(run?.context).toBeDefined();
+  expect(steps).toHaveLength(2);
+  for (const step of steps!) expect(step.input).toBeDefined();
+});
+
+test("fields=slim drops context and step inputs, keeps outputs and retry fields", async () => {
+  const result = await handler({ id: runId, fields: "slim" }, extra);
+  expect(result.isError).not.toBe(true);
+  const { run, steps } = result.structuredContent;
+  expect(run?.status).toBe("completed");
+  expect(run?.context).toBeUndefined();
+  expect(steps).toHaveLength(2);
+  for (const step of steps!) {
+    expect(step.input).toBeUndefined();
+    expect(step.output).toBeDefined();
+    expect(typeof step.retryCount).toBe("number");
+  }
+});
+
+test("fields=slim reports a missing run as an error", async () => {
+  const result = await handler({ id: crypto.randomUUID(), fields: "slim" }, extra);
+  expect(result.isError).toBe(true);
+});

package/src/tests/heartbeat-checklist.test.ts

@@ -24,6 +24,7 @@ import {
   upsertSwarmConfig,
 } from "../be/db";
 import { getScript, upsertScriptByName } from "../be/scripts/db";
+import * as savedScriptRunner from "../be/scripts/run-saved";
 import { runSavedScriptAsAgent } from "../be/scripts/run-saved";
 import {
   checkHeartbeatChecklist,
@@ -624,6 +625,66 @@ describe("Heartbeat Checklist", () => {
       });
     });
 
+    for (const quiet of [true, false]) {
+      test(`healthy probe preserves the saved gate quiet=${quiet} verdict`, async () => {
+        process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
+        await saveGlobalGateScript("quiet-gate", "export default () => ({ quiet: true });");
+        const saved = spyOn(savedScriptRunner, "runSavedScriptAsAgent").mockResolvedValue({
+          exitCode: 0,
+          result: { quiet, reason: "existing verdict" },
+          stdout: "",
+          stderr: "",
+          durationMs: 1,
+          truncated: { stdout: false, stderr: false },
+        });
+        try {
+          setChecklistGateRunnerForTests((name, agentId, signal) =>
+            defaultChecklistGateRunner(name, agentId, signal, { probe: async () => null }),
+          );
+          await seedLead();
+          await checkHeartbeatChecklist();
+          expect(saved).toHaveBeenCalledTimes(1);
+          const tasks = await checklistTasks();
+          expect(tasks).toHaveLength(quiet ? 0 : 1);
+          if (!quiet) expect(tasks[0]!.tags).toContain("heartbeat-gate:wake");
+        } finally {
+          saved.mockRestore();
+        }
+      });
+    }
+
+    for (const mode of ["shadow", "enforce"] as const) {
+      test(`${mode}: an unhealthy probe produces a wake checklist`, async () => {
+        process.env.HEARTBEAT_CHECKLIST_GATE_MODE = mode;
+        setChecklistGateRunnerForTests((name, agentId, signal) =>
+          defaultChecklistGateRunner(name, agentId, signal, {
+            probe: async () => ({ quiet: false, reason: "script-runner-unhealthy: timeout" }),
+          }),
+        );
+        await seedLead();
+        await checkHeartbeatChecklist();
+        const tasks = await checklistTasks();
+        expect(tasks).toHaveLength(1);
+        expect(tasks[0]!.tags).toContain("heartbeat-gate:wake");
+      });
+    }
+
+    test("a bug in the probe produces wake rather than error", async () => {
+      process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
+      setChecklistGateRunnerForTests((name, agentId, signal) =>
+        defaultChecklistGateRunner(name, agentId, signal, {
+          probe: async () => {
+            throw new Error("probe bug");
+          },
+        }),
+      );
+      await seedLead();
+      await checkHeartbeatChecklist();
+      const tasks = await checklistTasks();
+      expect(tasks).toHaveLength(1);
+      expect(tasks[0]!.tags).toContain("heartbeat-gate:wake");
+    });
+
     test("shadow mode (default): a quiet verdict still creates the task, tagged quiet", async () => {
       useGate({ quiet: true, reason: "no change", summary: "nothing moved" });
       const lead = await seedLead();
@@ -703,6 +764,9 @@ describe("Heartbeat Checklist", () => {
     test("enforce mode: a missing global script fails open through the real runner", async () => {
       process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
       process.env.HEARTBEAT_CHECKLIST_GATE_SCRIPT = "no-such-gate-script";
+      setChecklistGateRunnerForTests((name, agentId, signal) =>
+        defaultChecklistGateRunner(name, agentId, signal, { probe: async () => null }),
+      );
       await seedLead();
 
       await checkHeartbeatChecklist();
@@ -739,6 +803,7 @@ describe("Heartbeat Checklist", () => {
         let run: Promise<unknown> | undefined;
         setChecklistGateRunnerForTests((scriptName, leadAgentId, signal) => {
           run = defaultChecklistGateRunner(scriptName, leadAgentId, signal, {
+            probe: async () => null,
             buildCredentials: () => {
               setupStarted.resolve();
               return new Promise((resolve) => {
@@ -798,6 +863,9 @@ describe("Heartbeat Checklist", () => {
         "export default async function run() { await new Promise((r) => setTimeout(r, 30_000)); return { quiet: true }; }",
       );
       setChecklistGateTimeoutMsForTests(1_500);
+      setChecklistGateRunnerForTests((name, agentId, signal) =>
+        defaultChecklistGateRunner(name, agentId, signal, { probe: async () => null }),
+      );
       await seedLead();
 
       const started = Date.now();
@@ -808,6 +876,27 @@ describe("Heartbeat Checklist", () => {
       expect(tasks).toHaveLength(1);
       expect(tasks[0]!.tags).toContain("heartbeat-gate:error");
     });
+
+    test("enforce mode: the real probe passes with no swarm API key, using the Lead's run token", async () => {
+      process.env.HEARTBEAT_CHECKLIST_GATE_MODE = "enforce";
+      await saveGlobalGateScript("quiet-gate", "export default () => ({ quiet: true });");
+      const savedKeys = { swarm: process.env.AGENT_SWARM_API_KEY, legacy: process.env.API_KEY };
+      process.env.AGENT_SWARM_API_KEY = "";
+      process.env.API_KEY = "";
+      try {
+        await seedLead();
+        await checkHeartbeatChecklist();
+        expect(await checklistTasks()).toHaveLength(0);
+      } finally {
+        for (const [name, value] of [
+          ["AGENT_SWARM_API_KEY", savedKeys.swarm],
+          ["API_KEY", savedKeys.legacy],
+        ] as const) {
+          if (value === undefined) delete process.env[name];
+          else process.env[name] = value;
+        }
+      }
+    });
   });
 
   // ==========================================================================

package/src/tests/heartbeat-script-runner-probe.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { probeScriptRunner } from "../heartbeat/script-runner-probe";
+import type { RunScriptOutput } from "../scripts-runtime/loader";
+
+const ok: RunScriptOutput = {
+  result: true,
+  stdout: "",
+  stderr: "",
+  truncated: { stdout: false, stderr: false },
+  durationMs: 1,
+  exitCode: 0,
+};
+
+afterEach(() => mock.restore());
+
+describe("heartbeat script runner probe", () => {
+  test("success leaves the gate verdict unchanged and clears its deadline", async () => {
+    const clear = spyOn(globalThis, "clearTimeout");
+    const runner = mock(async () => ok);
+    expect(await probeScriptRunner("lead", runner)).toBeNull();
+    expect(runner).toHaveBeenCalledWith({
+      source: "export default async function () { return true; }",
+      agentId: "lead",
+      fsMode: "none",
+      timeoutMs: 10_000,
+      signal: expect.any(AbortSignal),
+    });
+    expect(clear).toHaveBeenCalledTimes(1);
+  });
+
+  test("timeout wakes without waiting for a stalled runner and aborts it", async () => {
+    let expire: (() => void) | undefined;
+    spyOn(globalThis, "setTimeout").mockImplementation(((callback: () => void, ms: number) => {
+      expect(ms).toBe(10_000);
+      expire = callback;
+      return 1;
+    }) as typeof setTimeout);
+    const clear = spyOn(globalThis, "clearTimeout").mockImplementation(() => {});
+    let signal: AbortSignal | undefined;
+    let rejectRun: ((error: Error) => void) | undefined;
+    const result = probeScriptRunner("lead", async (input) => {
+      signal = input.signal;
+      return new Promise<RunScriptOutput>((_, reject) => {
+        rejectRun = reject;
+      });
+    });
+    expire!();
+    expect(await result).toEqual({
+      quiet: false,
+      reason: "script-runner-unhealthy: timeout after 10000ms",
+    });
+    expect(signal?.aborted).toBe(true);
+    expect(clear).toHaveBeenCalledTimes(1);
+    // A runner that rejects after the deadline remains handled by Promise.race.
+    rejectRun!(new Error("late rejection"));
+    await Promise.resolve();
+  });
+
+  test("a thrown runner error wakes", async () => {
+    expect(
+      await probeScriptRunner("lead", async () => {
+        throw new Error("ECONNRESET");
+      }),
+    ).toEqual({
+      quiet: false,
+      reason: "script-runner-unhealthy: ECONNRESET",
+    });
+  });
+
+  for (const [label, failure, reason] of [
+    ["nonzero exit", { exitCode: 1 }, "script exited with code 1"],
+    ["runner error", { error: "killed" }, "killed"],
+    ["runtime error", { runtimeError: { message: "runtime failed" } }, "runtime failed"],
+  ] as const) {
+    test(`${label} wakes`, async () => {
+      const result = await probeScriptRunner(
+        "lead",
+        async () => ({ ...ok, ...failure }) as RunScriptOutput,
+      );
+      expect(result).toEqual({ quiet: false, reason: `script-runner-unhealthy: ${reason}` });
+    });
+  }
+});

package/src/tests/integrations-http.test.ts

@@ -21,6 +21,7 @@ const TEST_DB_PATH = "./test-integrations-http.sqlite";
 
 interface FakeClientLog {
   retrieveCalls: string[];
+  apiKeys: string[];
   retrieveResult?: { name?: string | null; model?: string | null };
   retrieveError?: Error;
 }
@@ -60,7 +61,7 @@ async function clearManagedConfigRows() {
 describe("POST /api/integrations/claude-managed/test", () => {
   let server: Server;
   let baseUrl = "";
-  const log: FakeClientLog = { retrieveCalls: [] };
+  const log: FakeClientLog = { retrieveCalls: [], apiKeys: [] };
   const savedEnv = {
     ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
     MANAGED_AGENT_ID: process.env.MANAGED_AGENT_ID,
@@ -71,7 +72,10 @@ describe("POST /api/integrations/claude-managed/test", () => {
     initDb(TEST_DB_PATH);
 
     const handler = createIntegrationsHandler({
-      buildClient: () => buildFakeClient(log),
+      buildClient: (apiKey) => {
+        log.apiKeys.push(apiKey);
+        return buildFakeClient(log);
+      },
     });
 
     server = createHttpServer(async (req, res) => {
@@ -101,6 +105,7 @@ describe("POST /api/integrations/claude-managed/test", () => {
 
   beforeEach(async () => {
     log.retrieveCalls = [];
+    log.apiKeys = [];
     log.retrieveResult = undefined;
     log.retrieveError = undefined;
     await clearManagedConfigRows();
@@ -138,6 +143,31 @@ describe("POST /api/integrations/claude-managed/test", () => {
     expect(log.retrieveCalls).toEqual(["agent_abc123"]);
   });
 
+  test("a comma pool sends one key to Anthropic", async () => {
+    await upsertSwarmConfig({
+      scope: "global",
+      key: "ANTHROPIC_API_KEY",
+      value: "sk-ant-first,sk-ant-second",
+      isSecret: true,
+    });
+    await upsertSwarmConfig({
+      scope: "global",
+      key: "MANAGED_AGENT_ID",
+      value: "agent_abc123",
+      isSecret: false,
+    });
+
+    const res = await fetch(`${baseUrl}/api/integrations/claude-managed/test`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: "{}",
+    });
+
+    expect((await res.json()) as { ok: boolean }).toMatchObject({ ok: true });
+    expect(log.apiKeys).toHaveLength(1);
+    expect(["sk-ant-first", "sk-ant-second"]).toContain(log.apiKeys[0]);
+  });
+
   test("missing-config path — returns ok:false with helpful error", async () => {
     // No swarm_config rows, no env. resolveConfigValue should return null
     // for both keys and short-circuit before calling Anthropic.