@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/tests/deferred-task-wake.test.ts

@@ -18,6 +18,7 @@ import {
   getTaskById,
   initDb,
   startTask,
+  supersedeTask,
   updateScheduledTask,
 } from "../be/db";
 import {
@@ -28,7 +29,9 @@ import {
   type TaskWakeEvent,
 } from "../scheduler/deferred-task-waits";
 import { dispatchScheduleTarget, executeSchedule } from "../scheduler/scheduler";
+import { createResumeFollowUp } from "../tasks/worker-follow-up";
 import { registerDeferTaskTool } from "../tools/defer-task";
+import type { AgentTask } from "../types";
 
 type Result = { structuredContent: { success: boolean; message: string; scheduleId?: string } };
 type Tool = {
@@ -133,10 +136,218 @@ async function waitState(scheduleId: string) {
     childTaskId: string | null;
     resolvedAt: string | null;
     updated_at: string;
-  }>("SELECT * FROM deferred_task_waits WHERE scheduleId = ?", [scheduleId]);
+  }>(
+    `SELECT w.*, m.taskId FROM deferred_task_waits w
+     JOIN deferred_task_wait_members m ON m.scheduleId = w.scheduleId
+     WHERE w.scheduleId = ?`,
+    [scheduleId],
+  );
+}
+
+async function resumeTask(parentId: string) {
+  const result = await createResumeFollowUp({ parentId, reason: "manual_supersede" });
+  if (result.kind !== "created") throw new Error(`Resume creation failed: ${result.kind}`);
+  return result.task;
+}
+
+async function awaitWatchedTask(scheduleId: string, taskId: string) {
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    if ((await waitState(scheduleId))?.taskId === taskId) return;
+    await Bun.sleep(5);
+  }
+  throw new Error("Event bus did not transfer the watched task");
+}
+
+async function multiFixture(mode?: "all" | "any", event: TaskWakeEvent = "settled") {
+  const parent = await activeTask();
+  const producers = [await activeTask(), await activeTask()];
+  const result = await defer(parent.id, producers[0]!.id, event, {
+    wakeOn: { taskIds: producers.map((producer) => producer.id), event, mode },
+  });
+  expect(result.structuredContent.success).toBe(true);
+  const schedule = (await getScheduledTaskById(result.structuredContent.scheduleId!))!;
+  return { parent, producers, schedule };
 }
 
 describe("defer-task wakeOn", () => {
+  test.each([
+    "completed",
+    "failed",
+    "cancelled",
+  ])("all is the default and waits for the final member to be %s", async (status) => {
+    const { producers, schedule } = await multiFixture();
+    await completeTask(producers[0]!.id, "first result");
+    await reconcileDeferredTaskWaits(producers[0]!.id);
+    expect(await children(schedule.id)).toHaveLength(0);
+    // The dispatch entry point must also enforce the whole set.
+    expect(await dispatchDeferredTaskWait(schedule.id, "task.completed")).toEqual({});
+    if (status === "completed") await completeTask(producers[1]!.id, "second result");
+    else if (status === "failed") await failTask(producers[1]!.id, "second result failed");
+    else await cancelTask(producers[1]!.id, "second result cancelled");
+    await reconcileDeferredTaskWaits(producers[1]!.id);
+    const found = await children(schedule.id);
+    expect(found).toHaveLength(1);
+    expect(found[0]!.task).toContain("all tasks matched settled");
+    expect(found[0]!.task).toContain(`${producers[1]!.id} (${status})`);
+    expect((await getScheduledTaskById(schedule.id))?.enabled).toBe(false);
+  });
+
+  test.each([
+    "completed",
+    "failed",
+    "cancelled",
+  ])("explicit any wakes on the first %s member", async (status) => {
+    const { producers, schedule } = await multiFixture("any");
+    if (status === "completed") await completeTask(producers[1]!.id, "ready");
+    else if (status === "failed") await failTask(producers[1]!.id, "failed");
+    else await cancelTask(producers[1]!.id, "cancelled");
+    await reconcileDeferredTaskWaits(producers[1]!.id);
+    expect(await children(schedule.id)).toHaveLength(1);
+    expect((await children(schedule.id))[0]!.task).toContain("any tasks matched settled");
+    expect((await getTaskById(producers[0]!.id))?.status).toBe("in_progress");
+    await completeTask(producers[0]!.id, "later");
+    await reconcileDeferredTaskWaits();
+    await executeSchedule(schedule);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("all follows one member through repeated deferrals and restart without extending the ceiling", async () => {
+    const { producers, schedule } = await multiFixture("all");
+    await completeTask(producers[0]!.id, "ready");
+    let current = producers[1]!;
+    for (let step = 0; step < 2; step++) {
+      const deferred = await defer(current.id, current.id, "settled", { wakeOn: undefined });
+      expect(deferred.structuredContent.success).toBe(true);
+      await reconcileDeferredTaskWaits(current.id);
+      expect(await children(schedule.id)).toHaveLength(0);
+      expect(await dispatchDeferredTaskWait(schedule.id, "task.completed")).toEqual({});
+      const successor = (await getScheduledTaskById(deferred.structuredContent.scheduleId!))!;
+      await executeSchedule(successor);
+      current = (await children(successor.id))[0]!;
+      closeDb();
+      initDb(path);
+      await initDeferredTaskWaits();
+      expect(await children(schedule.id)).toHaveLength(0);
+      expect((await getScheduledTaskById(schedule.id))?.nextRunAt).toBe(schedule.nextRunAt);
+    }
+    await completeTask(current.id, "final result");
+    const child = await awaitChild(schedule.id);
+    expect(child.task).toContain(`${current.id} (completed)`);
+    expect(child.task).toContain(`${producers[0]!.id} (completed)`);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("any ignores a deferred completion until another member really settles", async () => {
+    const { producers, schedule } = await multiFixture("any");
+    await defer(producers[0]!.id, producers[0]!.id, "settled", { wakeOn: undefined });
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(0);
+    await failTask(producers[1]!.id, "real failure");
+    await reconcileDeferredTaskWaits(producers[1]!.id);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("the set's ceiling fires before all settle and later events cannot duplicate it", async () => {
+    const { producers, schedule } = await multiFixture();
+    await completeTask(producers[0]!.id, "ready");
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(0);
+    await executeSchedule(schedule);
+    expect((await children(schedule.id))[0]!.task).toContain("ceiling expired");
+    await completeTask(producers[1]!.id, "late");
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(1);
+    expect((await waitState(schedule.id))?.firedBy).toBe("ceiling");
+  });
+
+  test.each([
+    "all",
+    "any",
+  ] as const)("%s concurrent terminal events and the ceiling create exactly one child", async (mode) => {
+    const { producers, schedule } = await multiFixture(mode);
+    await initDeferredTaskWaits();
+    await Promise.all([
+      completeTask(producers[0]!.id, "ready"),
+      failTask(producers[1]!.id, "failed"),
+      executeSchedule(schedule),
+    ]);
+    await reconcileDeferredTaskWaits();
+    const found = await children(schedule.id);
+    expect(found).toHaveLength(1);
+    expect((await waitState(schedule.id))?.childTaskId).toBe(found[0]!.id);
+  });
+
+  test.each([
+    "all",
+    "any",
+  ] as const)("%s respects event filters when a member fails", async (mode) => {
+    const { producers, schedule } = await multiFixture(mode, "task.completed");
+    await failTask(producers[0]!.id, "wrong event");
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(0);
+    await completeTask(producers[1]!.id, "right event");
+    await reconcileDeferredTaskWaits();
+    expect(await children(schedule.id)).toHaveLength(mode === "all" ? 0 : 1);
+    await executeSchedule(schedule);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("one invalid member rejects the entire set before any schedule or completion is committed", async () => {
+    const parent = await activeTask();
+    const valid = await activeTask();
+    const terminal = await activeTask();
+    await completeTask(terminal.id, "done");
+    for (const mode of ["all", "any"]) {
+      for (const [id, message] of [
+        [terminal.id, "already completed"],
+        [crypto.randomUUID(), "not found"],
+        [parent.id, "Cannot wake on"],
+      ]) {
+        const result = await defer(parent.id, valid.id, "settled", {
+          wakeOn: { taskIds: [valid.id, id], event: "settled", mode },
+        });
+        expect(result.structuredContent.success).toBe(false);
+        expect(result.structuredContent.message).toContain(message!);
+      }
+    }
+    expect((await getTaskById(parent.id))?.status).toBe("in_progress");
+    expect(
+      await getDbClient().query("SELECT id FROM scheduled_tasks WHERE parentTaskId = ?", [
+        parent.id,
+      ]),
+    ).toHaveLength(0);
+  });
+
+  test("multi-ID schema rejects empty, duplicate, ambiguous, or missing IDs and invalid modes", async () => {
+    const parent = await activeTask();
+    const producer = await activeTask();
+    const base = { taskId: parent.id, summary: "done", note: "wait", delayMs: 60000 };
+    for (const fields of [
+      {},
+      { taskIds: [] },
+      { taskIds: [""] },
+      { taskIds: [producer.id, producer.id] },
+      { taskId: producer.id, taskIds: [producer.id] },
+      { taskIds: [producer.id], mode: "some" },
+    ]) {
+      expect(
+        tool.inputSchema.safeParse({ ...base, wakeOn: { event: "settled", ...fields } }).success,
+      ).toBe(false);
+    }
+    const wakeOn = { taskIds: [producer.id], event: "settled" };
+    expect(tool.inputSchema.safeParse({ ...base, wakeOn }).success).toBe(true);
+    for (const extra of [
+      { delayMs: undefined },
+      { runAt: new Date(Date.now() + 60000).toISOString() },
+    ]) {
+      expect(
+        (await defer(parent.id, producer.id, "settled", { wakeOn, ...extra })).structuredContent
+          .success,
+      ).toBe(false);
+    }
+  });
+
   test("ordinary schedules neither suppress a completion nor retarget its waiters", async () => {
     const { producer, schedule } = await fixture();
     const ordinary = await createScheduledTask({
@@ -392,7 +603,143 @@ describe("defer-task wakeOn", () => {
     expect(await children(schedule.id)).toHaveLength(1);
   });
 
-  test("unmatched task or event does not wake; cancelled producer still has a ceiling", async () => {
+  test("settled wakes on the cancellation bus and consumes the ceiling once", async () => {
+    await initDeferredTaskWaits();
+    const { producer, schedule } = await fixture();
+    await cancelTask(producer.id, "cancelled");
+    expect((await awaitChild(schedule.id)).task).toContain(
+      `Wake-up cause: task.cancelled for task ${producer.id}`,
+    );
+    expect(await waitState(schedule.id)).toMatchObject({ firedBy: "task.cancelled" });
+    await executeSchedule(schedule);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("restart reconciles cancellation missed while the listener was stopped", async () => {
+    const { producer, schedule } = await fixture();
+    await cancelTask(producer.id, "cancelled while stopped");
+    closeDb();
+    initDb(path);
+    await initDeferredTaskWaits();
+    expect(await waitState(schedule.id)).toMatchObject({
+      status: "fired",
+      firedBy: "task.cancelled",
+    });
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test.each([
+    "task.completed",
+    "task.failed",
+  ] as const)("%s does not wake on cancellation and retains the ceiling", async (event) => {
+    await initDeferredTaskWaits();
+    const { producer, schedule } = await fixture(event);
+    await cancelTask(producer.id, "cancelled");
+    await reconcileDeferredTaskWaits(producer.id);
+    expect(await dispatchDeferredTaskWait(schedule.id, "task.cancelled")).toEqual({});
+    expect(await children(schedule.id)).toHaveLength(0);
+    expect(await waitState(schedule.id)).toMatchObject({ status: "pending" });
+    await executeSchedule(schedule);
+    expect(await waitState(schedule.id)).toMatchObject({ firedBy: "ceiling" });
+  });
+
+  test.each([
+    "resume first",
+    "supersede first",
+  ])("superseded follows the resume without waking or extending the ceiling: %s", async (order) => {
+    await initDeferredTaskWaits();
+    for (const event of ["settled", "task.completed", "task.failed"] as const) {
+      const { producer, schedule } = await fixture(event);
+      let resume: AgentTask | undefined;
+      if (order === "resume first") {
+        resume = await resumeTask(producer.id);
+        await reconcileDeferredTaskWaits();
+        expect(await waitState(schedule.id)).toMatchObject({ taskId: producer.id });
+      }
+      await supersedeTask(producer.id, {
+        reason: "manual_supersede",
+        resumeTaskId: resume?.id ?? null,
+      });
+      if (!resume) {
+        await reconcileDeferredTaskWaits(producer.id);
+        expect(await waitState(schedule.id)).toMatchObject({
+          taskId: producer.id,
+          status: "pending",
+        });
+        resume = await resumeTask(producer.id);
+      }
+      await awaitWatchedTask(schedule.id, resume.id);
+      expect(await waitState(schedule.id)).toMatchObject({ status: "pending", firedBy: null });
+      expect(await children(schedule.id)).toHaveLength(0);
+      expect((await getScheduledTaskById(schedule.id))?.nextRunAt).toBe(schedule.nextRunAt);
+      if (event === "task.failed") await failTask(resume.id, "resume failed");
+      else await completeTask(resume.id, "resume completed");
+      expect((await awaitChild(schedule.id)).task).toContain(`for task ${resume.id}`);
+      await executeSchedule(schedule);
+      expect(await children(schedule.id)).toHaveLength(1);
+    }
+  });
+
+  test("superseded without a resume holds to its ceiling and a late resume cannot retarget a fired wait", async () => {
+    await initDeferredTaskWaits();
+    const { producer, schedule } = await fixture();
+    await supersedeTask(producer.id, { reason: "manual_supersede", resumeTaskId: null });
+    // An ordinary follow-up is not the replacement for superseded work.
+    await createTaskExtended("unrelated follow-up", {
+      parentTaskId: producer.id,
+      taskType: "follow-up",
+    });
+    await reconcileDeferredTaskWaits(producer.id);
+    expect(await waitState(schedule.id)).toMatchObject({ taskId: producer.id, status: "pending" });
+    expect(await children(schedule.id)).toHaveLength(0);
+    await executeSchedule(schedule);
+    const fired = await waitState(schedule.id);
+    expect(fired).toMatchObject({ firedBy: "ceiling" });
+    const resume = await resumeTask(producer.id);
+    await completeTask(resume.id, "too late");
+    await reconcileDeferredTaskWaits();
+    expect(await waitState(schedule.id)).toEqual(fired);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("restart follows a missed supersede chain to an already-terminal resume", async () => {
+    const { producer, schedule } = await fixture();
+    let current = producer;
+    for (let step = 0; step < 2; step++) {
+      await supersedeTask(current.id, { reason: "manual_supersede", resumeTaskId: null });
+      current = await resumeTask(current.id);
+    }
+    await completeTask(current.id, "final result");
+    closeDb();
+    initDb(path);
+    await initDeferredTaskWaits();
+    expect(await waitState(schedule.id)).toMatchObject({ taskId: current.id, status: "fired" });
+    expect((await awaitChild(schedule.id)).task).toContain(`for task ${current.id}`);
+    expect(await children(schedule.id)).toHaveLength(1);
+  });
+
+  test("a wait watching both the superseded parent and its resume collapses to one member", async () => {
+    const parent = await activeTask();
+    const producer = await activeTask();
+    const resume = await resumeTask(producer.id);
+    const deferred = await defer(parent.id, producer.id, "settled", {
+      wakeOn: { taskIds: [producer.id, resume.id], event: "settled" },
+    });
+    const scheduleId = deferred.structuredContent.scheduleId!;
+    await supersedeTask(producer.id, { reason: "manual_supersede", resumeTaskId: resume.id });
+    await reconcileDeferredTaskWaits();
+    expect(await waitState(scheduleId)).toMatchObject({ taskId: resume.id, status: "pending" });
+    expect(
+      await getDbClient().query("SELECT * FROM deferred_task_wait_members WHERE scheduleId = ?", [
+        scheduleId,
+      ]),
+    ).toHaveLength(1);
+    await completeTask(resume.id, "done");
+    await reconcileDeferredTaskWaits(resume.id);
+    expect(await children(scheduleId)).toHaveLength(1);
+  });
+
+  test("unmatched task or event does not wake", async () => {
     await initDeferredTaskWaits();
     const { producer, schedule } = await fixture("task.completed");
     const other = await activeTask();
@@ -400,12 +747,6 @@ describe("defer-task wakeOn", () => {
     await failTask(producer.id, "wrong event");
     await reconcileDeferredTaskWaits();
     expect(await children(schedule.id)).toHaveLength(0);
-    const cancelled = await fixture();
-    await cancelTask(cancelled.producer.id, "cancelled");
-    await reconcileDeferredTaskWaits();
-    expect(await children(cancelled.schedule.id)).toHaveLength(0);
-    await executeSchedule(cancelled.schedule);
-    expect(await children(cancelled.schedule.id)).toHaveLength(1);
     await executeSchedule(schedule);
   });
 

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

@@ -18,7 +18,7 @@ import { listenOnFreePort } from "./test-net";
 
 let TEST_BASE_URL = "";
 const ORG_ID = "org-adapter-test";
-const API_KEY = "cog_adapter_key";
+const API_KEY = "example-cog_adapter_key";
 
 // ---------------------------------------------------------------------------
 // Controllable mock state

package/src/tests/devin-api.test.ts

@@ -13,7 +13,7 @@ import { listenOnFreePort } from "./test-net";
 
 let TEST_BASE_URL = "";
 const ORG_ID = "org-test-123";
-const API_KEY = "cog_test_key";
+const API_KEY = "example-cog_test_key";
 
 // Canned responses -----------------------------------------------------------
 const SESSION_RESPONSE = {

package/src/tests/docs-index-footprint.test.js

@@ -78,7 +78,7 @@ describe("docs API index footprint", () => {
     expect(tasks).toContain('"path":"/api/task-templates","method":"get"');
   });
 
-  test("OpenAPI and generated pages keep all 359 operations", async () => {
+  test("OpenAPI and generated pages keep all 370 operations", async () => {
     const spec = await Bun.file(resolve(repoRoot, "openapi.json")).json();
     const operationKeys = [];
     const tags = new Set();
@@ -103,8 +103,8 @@ describe("docs API index footprint", () => {
     expect(spec.paths["/api/agents/{id}/runtime"]?.get).toBeDefined();
 
     const generatedKeys = await generatedOperationKeys();
-    expect(operationKeys).toHaveLength(361);
-    expect(generatedKeys).toHaveLength(361);
+    expect(operationKeys).toHaveLength(372);
+    expect(generatedKeys).toHaveLength(372);
     expect(new Set(generatedKeys)).toEqual(new Set(operationKeys));
   });
 

package/src/tests/e2b-dispatch.test.ts

@@ -70,9 +70,9 @@ describe("E2B env helpers", () => {
     delete process.env.API_KEY;
     delete process.env.AGENT_SWARM_API_KEY;
     try {
-      expect(resolveSwarmApiKey({ API_KEY: "legacy", AGENT_SWARM_API_KEY: "preferred" })).toBe(
-        "preferred",
-      );
+      expect(
+        resolveSwarmApiKey({ API_KEY: "legacy", AGENT_SWARM_API_KEY: "example-preferred" }),
+      ).toBe("example-preferred");
       expect(resolveSwarmApiKey({ API_KEY: "legacy" }, "explicit")).toBe("explicit");
       expect(() => resolveSwarmApiKey({})).toThrow("Missing swarm API key");
     } finally {
@@ -92,14 +92,16 @@ describe("E2B env helpers", () => {
   test("selectEnv and redactWithEnv keep secrets out of logs", () => {
     const selected = selectEnv(
       {
-        API_KEY: "super-secret-value",
-        E2B_API_KEY: "controller-secret",
+        API_KEY: "example-super-secret-value",
+        E2B_API_KEY: "example-controller-secret",
         PATH: "/bin",
       },
       ["API_KEY", "PATH"],
     );
-    expect(selected).toEqual({ API_KEY: "super-secret-value", PATH: "/bin" });
-    expect(redactWithEnv("token=super-secret-value", selected)).toContain("[REDACTED:API_KEY]");
+    expect(selected).toEqual({ API_KEY: "example-super-secret-value", PATH: "/bin" });
+    expect(redactWithEnv("token=example-super-secret-value", selected)).toContain(
+      "[REDACTED:API_KEY]",
+    );
   });
 
   test("redactObjectWithEnv redacts token-like response fields", () => {
@@ -107,8 +109,8 @@ describe("E2B env helpers", () => {
       redactObjectWithEnv(
         {
           sandboxID: "sbx123",
-          envdAccessToken: "controller-token-that-should-not-print",
-          nested: { trafficAccessToken: "traffic-token-that-should-not-print" },
+          envdAccessToken: "example-controller-token-that-should-not-print",
+          nested: { trafficAccessToken: "example-traffic-token-that-should-not-print" },
         },
         {},
       ),
@@ -232,7 +234,7 @@ describe("E2B dispatch helpers", () => {
   test("E2B SDK connection options preserve loaded controller endpoints", () => {
     expect(
       e2bSdkConnectionOptions(
-        "controller-key",
+        "example-controller-key",
         {
           E2B_DOMAIN: "sandbox.example.com",
           E2B_SANDBOX_URL: "https://sandbox.sandbox.example.com",
@@ -240,7 +242,7 @@ describe("E2B dispatch helpers", () => {
         "https://api.sandbox.example.com",
       ),
     ).toEqual({
-      apiKey: "controller-key",
+      apiKey: "example-controller-key",
       domain: "sandbox.example.com",
       sandboxUrl: "https://sandbox.sandbox.example.com",
       apiUrl: "https://api.sandbox.example.com",
@@ -360,7 +362,7 @@ describe("E2B dispatch helpers", () => {
         name: "agent swarm/worker",
         public: true,
         e2bEnv: {
-          E2B_API_KEY: "controller-secret",
+          E2B_API_KEY: "example-controller-secret",
           E2B_API_URL: "https://api.e2b.example",
         },
       });
@@ -370,7 +372,7 @@ describe("E2B dispatch helpers", () => {
       expect(calls[0]?.init?.method).toBe("PATCH");
       expect(calls[0]?.init?.headers).toMatchObject({
         "Content-Type": "application/json",
-        "X-API-Key": "controller-secret",
+        "X-API-Key": "example-controller-secret",
       });
       expect(calls[0]?.init?.body).toBe(JSON.stringify({ public: true }));
       expect(result.stdout).toBe(
@@ -826,7 +828,7 @@ describe("E2B swarm grouping + deep-link (Phase 4)", () => {
 
   test("e2b dashboard deep-link uses camelCase params and hides the key by default", () => {
     const masked = buildDashboardDeepLink(
-      { apiUrl: "https://api.example.com", apiKey: "super-secret-key", name: "demo" },
+      { apiUrl: "https://api.example.com", apiKey: "example-super-secret-key", name: "demo" },
       false,
     );
     // camelCase params the SPA reads.
@@ -834,7 +836,7 @@ describe("E2B swarm grouping + deep-link (Phase 4)", () => {
     expect(masked).toContain("name=demo");
     // Key hidden — the real value MUST NOT appear.
     expect(masked).toContain("apiKey=<hidden — pass --reveal-key>");
-    expect(masked).not.toContain("super-secret-key");
+    expect(masked).not.toContain("example-super-secret-key");
     // Never snake_case.
     expect(masked).not.toContain("api_url");
     expect(masked).not.toContain("api_key");
@@ -842,10 +844,10 @@ describe("E2B swarm grouping + deep-link (Phase 4)", () => {
 
   test("e2b dashboard deep-link embeds the real key only when revealed", () => {
     const revealed = buildDashboardDeepLink(
-      { apiUrl: "https://api.example.com", apiKey: "super-secret-key", name: "demo" },
+      { apiUrl: "https://api.example.com", apiKey: "example-super-secret-key", name: "demo" },
       true,
     );
-    expect(revealed).toContain("apiKey=super-secret-key");
+    expect(revealed).toContain("apiKey=example-super-secret-key");
     expect(revealed).not.toContain("<hidden");
     expect(revealed).toContain("apiUrl=https%3A%2F%2Fapi.example.com");
   });
@@ -876,10 +878,10 @@ describe("E2B swarm grouping + deep-link (Phase 4)", () => {
   test("onboarding dashboard builder emits camelCase apiUrl/apiKey (not snake_case)", () => {
     const url = buildOnboardDashboardUrl({
       apiUrl: "http://localhost:3013",
-      apiKey: "onboard-key",
+      apiKey: "example-onboard-key",
     });
     expect(url).toContain("apiUrl=http%3A%2F%2Flocalhost%3A3013");
-    expect(url).toContain("apiKey=onboard-key");
+    expect(url).toContain("apiKey=example-onboard-key");
     // The bug we fixed: snake_case is silently ignored by the SPA.
     expect(url).not.toContain("api_url");
     expect(url).not.toContain("api_key");

package/src/tests/e2e-claude-transport.test.ts

@@ -93,7 +93,7 @@ describe("Claude E2E transport harness", () => {
   });
 
   test("writes the agent override and validates transport metadata and Claude costs", async () => {
-    process.env.ANTHROPIC_API_KEY = "test-anthropic-key";
+    process.env.ANTHROPIC_API_KEY = "example-test-anthropic-key";
     process.env.E2E_CLAUDE_BINARY = "/opt/claude-pinned";
     process.env.E2E_WORKER_BINARY = "/opt/agent-swarm";
     const spawnCalls: Parameters<typeof Bun.spawn>[] = [];
@@ -141,7 +141,7 @@ describe("Claude E2E transport harness", () => {
   });
 
   test("fails when Claude metadata or costs do not prove the selected transport", async () => {
-    process.env.ANTHROPIC_API_KEY = "test-anthropic-key";
+    process.env.ANTHROPIC_API_KEY = "example-test-anthropic-key";
     process.env.E2E_CLAUDE_TRANSPORT = "sdk";
     process.env.E2E_COST_TIMEOUT_MS = "1";
     const spawnSpy = spyOn(Bun, "spawn").mockImplementation((() =>
@@ -184,7 +184,7 @@ describe("Claude E2E transport harness", () => {
 
   test("does not validate the Claude flag for non-Claude legs", async () => {
     process.env.E2E_CLAUDE_TRANSPORT = "invalid";
-    process.env.OPENROUTER_API_KEY = "test-openrouter-key";
+    process.env.OPENROUTER_API_KEY = "example-test-openrouter-key";
     const spawnSpy = spyOn(Bun, "spawn").mockImplementation((() =>
       fakeWorker()) as typeof Bun.spawn);
 

package/src/tests/e2e-redact.test.ts

@@ -5,10 +5,10 @@ describe("e2e redaction", () => {
   test("masks exact known values and common token shapes", () => {
     const text = [
       "Authorization: Bearer 0123456789abcdef0123456789abcdef",
-      "OPENAI_API_KEY=sk-proj-abcdefghijklmnopqrstuvwxyz0123",
-      "anthropic sk-ant-api03-abcdefghijklmnop",
-      "github ghp_abcdefghijklmnopqrstuvwxyz0123456789",
-      "slack xoxb-1234567890-abcdefghijk",
+      "OPENAI_API_KEY=example-sk-proj-abcdefghijklmnopqrstuvwxyz0123",
+      "anthropic example-sk-ant-api03-abcdefghijklmnop",
+      "github example-ghp_abcdefghijklmnopqrstuvwxyz0123456789",
+      "slack example-xoxb-1234567890-abcdefghijk",
       'auth.json {"refresh_token":"rt-abcdefghijklmnop","id_token":"x.y.z"}',
       "jwt eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c",
       "my-secret-run-key-value appears here",
@@ -42,7 +42,7 @@ describe("e2e redaction", () => {
   test("knownSecrets reads provider env values and the codex blob fields", () => {
     const saved = { ...process.env };
     try {
-      process.env.OPENROUTER_API_KEY = "sk-or-v1-known-value-1234";
+      process.env.OPENROUTER_API_KEY = "example-sk-or-v1-known-value-1234";
       process.env.CODEX_OAUTH = JSON.stringify({
         access: "access-token-value-1234",
         refresh: "refresh-token-value-1234",
@@ -50,7 +50,7 @@ describe("e2e redaction", () => {
         accountId: "acct",
       });
       const known = knownSecrets(["extra-secret-value"]);
-      expect(known).toContain("sk-or-v1-known-value-1234");
+      expect(known).toContain("example-sk-or-v1-known-value-1234");
       expect(known).toContain("access-token-value-1234");
       expect(known).toContain("refresh-token-value-1234");
       expect(known).toContain("extra-secret-value");