@desplega.ai/agent-swarm 2.4.4 → 2.5.0

package/src/tests/page-guest-session.test.ts

@@ -134,17 +134,21 @@ afterAll(async () => {
 describe("proxy allowlist for a guest session", () => {
   test("allows the page's own record and its KV", async () => {
     const own = await fetch(`${BASE}/@swarm/api/pages/${pageId}`, {
-      headers: { Cookie: `page_session=${guestCookie}` },
+      headers: { Cookie: `page_session_${pageId}=${guestCookie}`, "X-Swarm-Page-Id": pageId },
     });
     expect(own.status).toBe(200);
     const put = await fetch(`${BASE}/@swarm/api/kv/probe`, {
       method: "PUT",
-      headers: { Cookie: `page_session=${guestCookie}`, "Content-Type": "application/json" },
+      headers: {
+        Cookie: `page_session_${pageId}=${guestCookie}`,
+        "X-Swarm-Page-Id": pageId,
+        "Content-Type": "application/json",
+      },
       body: JSON.stringify({ value: "v" }),
     });
     expect(put.status).toBe(200);
     const get = await fetch(`${BASE}/@swarm/api/kv/probe`, {
-      headers: { Cookie: `page_session=${guestCookie}` },
+      headers: { Cookie: `page_session_${pageId}=${guestCookie}`, "X-Swarm-Page-Id": pageId },
     });
     expect(get.status).toBe(200);
   });
@@ -162,7 +166,11 @@ describe("proxy allowlist for a guest session", () => {
     test(`refuses ${method} ${path} with 403`, async () => {
       const res = await fetch(`${BASE}/@swarm/api/${path}`, {
         method,
-        headers: { Cookie: `page_session=${guestCookie}`, "Content-Type": "application/json" },
+        headers: {
+          Cookie: `page_session_${pageId}=${guestCookie}`,
+          "X-Swarm-Page-Id": pageId,
+          "Content-Type": "application/json",
+        },
         body: method === "POST" ? "{}" : undefined,
       });
       expect(res.status).toBe(403);
@@ -206,13 +214,16 @@ describe("a password-page guest is isolated from another page", () => {
 
     const unlock = await fetch(`${BASE}/p/${pageA}?key=open-sesame`);
     expect(unlock.status).toBe(200);
-    const cookieA = /page_session=([^;]+)/.exec(unlock.headers.get("set-cookie") ?? "")?.[1];
+    const cookieA = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(
+      unlock.headers.get("set-cookie") ?? "",
+    )?.[1];
     expect(cookieA).toBeTruthy();
     const asGuest = (path: string, init: RequestInit = {}) =>
       fetch(`${BASE}/@swarm/api/${path}`, {
         ...init,
         headers: {
-          Cookie: `page_session=${cookieA}`,
+          Cookie: `page_session_${pageA}=${cookieA}`,
+          "X-Swarm-Page-Id": pageA,
           "Content-Type": "application/json",
           "X-Page-Id": pageB,
           "X-Agent-ID": agentId,
@@ -377,12 +388,12 @@ describe("server-side gates deny a guest and keep the operator and user", () =>
   test("a user session through the proxy and an operator-launched session still work", async () => {
     for (const cookie of [userCookie, operatorCookie]) {
       const res = await fetch(`${BASE}/@swarm/api/tasks`, {
-        headers: { Cookie: `page_session=${cookie}` },
+        headers: { Cookie: `page_session_${pageId}=${cookie}`, "X-Swarm-Page-Id": pageId },
       });
       expect(res.status).toBe(200);
     }
     const whoami = await fetch(`${BASE}/@swarm/api/whoami`, {
-      headers: { Cookie: `page_session=${userCookie}` },
+      headers: { Cookie: `page_session_${pageId}=${userCookie}`, "X-Swarm-Page-Id": pageId },
     });
     expect(((await whoami.json()) as { kind: string }).kind).toBe("user");
   });

package/src/tests/page-proxy-authed.test.ts

@@ -122,7 +122,7 @@ describe("/@swarm/api/* proxy — authed-mode page", () => {
     expect(launch.status).toBe(204);
     const setCookie = launch.headers.get("set-cookie");
     expect(setCookie).toBeTruthy();
-    const cookieValue = /page_session=([^;]+)/.exec(setCookie!)?.[1];
+    const cookieValue = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(setCookie!)?.[1];
     expect(cookieValue).toBeTruthy();
 
     // Drive the proxy with the cookie — should resolve to the page owner's

package/src/tests/page-proxy.test.ts

@@ -182,11 +182,13 @@ type BrowserSdk = {
   };
 };
 
-function browserSdk(cookie: string, spoofedAgentId?: string): BrowserSdk {
+function browserSdk(pageId: string, cookie: string, spoofedAgentId?: string): BrowserSdk {
   const window: { swarmSdk?: BrowserSdk } = {};
   const pageFetch = (input: string, init?: RequestInit) => {
     const headers = new Headers(init?.headers);
-    headers.set("Cookie", `page_session=${cookie}`);
+    // The SDK must name its own page; the test only supplies the cookie jar.
+    if (headers.get("X-Swarm-Page-Id") !== pageId) throw new Error("SDK did not name its page");
+    headers.set("Cookie", `page_session_${pageId}=${cookie}`);
     if (spoofedAgentId) headers.set("X-Agent-ID", spoofedAgentId);
     return fetch(new URL(input, BASE), { ...init, headers });
   };
@@ -195,6 +197,7 @@ function browserSdk(cookie: string, spoofedAgentId?: string): BrowserSdk {
     encodeURIComponent,
     fetch: pageFetch,
     URLSearchParams,
+    location: { pathname: `/p/${pageId}` },
     window,
   });
   if (!window.swarmSdk) throw new Error("browser SDK did not initialize");
@@ -207,7 +210,9 @@ async function launchPageCookie(id: string, bearer = API_KEY): Promise<string> {
     headers: { Authorization: `Bearer ${bearer}` },
   });
   expect(launch.status).toBe(204);
-  const cookie = /page_session=([^;]+)/.exec(launch.headers.get("set-cookie") ?? "")?.[1];
+  const cookie = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(
+    launch.headers.get("set-cookie") ?? "",
+  )?.[1];
   if (!cookie) throw new Error("failed to mint page session cookie");
   return cookie;
 }
@@ -243,14 +248,14 @@ describe("/api/pages/:id/launch", () => {
     expect(res.status).toBe(204);
     const cookie = res.headers.get("set-cookie");
     expect(cookie).toBeTruthy();
-    expect(cookie!).toContain("page_session=");
+    expect(cookie!).toContain("page_session_");
     expect(cookie!).toContain("HttpOnly");
     expect(cookie!).toContain("Path=/");
     expect(cookie!).toContain("Max-Age=3600");
     // In dev (NODE_ENV != production) the cookie should be SameSite=Lax sans Secure.
     expect(cookie!).toContain("SameSite=Lax");
     expect(cookie!).not.toMatch(/\bSecure\b/);
-    const cookieValue = /page_session=([^;]+)/.exec(cookie!)?.[1];
+    const cookieValue = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(cookie!)?.[1];
     const payload = await verifyPageSession(cookieValue);
     expect(payload?.uid).toBeUndefined();
     expect(payload?.name).toMatch(/^guest-/);
@@ -294,7 +299,9 @@ describe("/@swarm/api/* proxy", () => {
       headers: { Authorization: `Bearer ${viewer.token}` },
     });
     expect(launch.status).toBe(204);
-    const cookieValue = /page_session=([^;]+)/.exec(launch.headers.get("set-cookie") ?? "")?.[1];
+    const cookieValue = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(
+      launch.headers.get("set-cookie") ?? "",
+    )?.[1];
     expect(cookieValue).toBeTruthy();
     const payload = await verifyPageSession(cookieValue);
     expect(payload?.uid).toBe(viewer.id);
@@ -322,7 +329,7 @@ describe("/@swarm/api/* proxy", () => {
     const setCookie = launch.headers.get("set-cookie");
     expect(setCookie).toBeTruthy();
 
-    const cookieValue = /page_session=([^;]+)/.exec(setCookie!)?.[1];
+    const cookieValue = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(setCookie!)?.[1];
     expect(cookieValue).toBeTruthy();
 
     const res = await fetch(`${BASE}/@swarm/api/agents/${agentId}`, {
@@ -410,7 +417,7 @@ describe("/@swarm/api/* page execution context", () => {
 
     // Execute the shipped browser SDK with a forged client identity. The
     // proxy must ignore that header and derive memory scope from the page.
-    const sdk = browserSdk(cookie, otherAgentId);
+    const sdk = browserSdk(pageId, cookie, otherAgentId);
     const search = await sdk.memory.search({ query: searchToken, scope: "agent", limit: 10 });
     expect(search.results.map((memory) => memory.id)).toContain(ownerMemoryId);
     expect(search.results.map((memory) => memory.id)).not.toContain(otherMemoryId);
@@ -432,7 +439,7 @@ describe("/@swarm/api/* page execution context", () => {
     const viewer = await createUserToken(`Page Viewer ${randomUUID().slice(0, 8)}`);
     const pageId = await createPage();
     const cookie = await launchPageCookie(pageId, viewer.token);
-    const sdk = browserSdk(cookie);
+    const sdk = browserSdk(pageId, cookie);
 
     const search = await sdk.memory.search({ query: searchToken, scope: "agent", limit: 5 });
     expect(search.results.map((memory) => memory.id)).toContain(ownerMemoryId);
@@ -506,7 +513,7 @@ describe("/@swarm/api/* proxy — suffix normalization", () => {
       headers: { Authorization: `Bearer ${API_KEY}`, "X-Agent-ID": agentId },
     });
     const setCookie = launch.headers.get("set-cookie");
-    const cookieValue = /page_session=([^;]+)/.exec(setCookie!)?.[1];
+    const cookieValue = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(setCookie!)?.[1];
     if (!cookieValue) throw new Error("failed to mint test cookie");
     return cookieValue;
   }

package/src/tests/page-session.test.ts

@@ -3,7 +3,15 @@ import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import type { PageSessionPayload } from "../utils/page-session";
-import { parseCookieHeader, signPageSession, verifyPageSession } from "../utils/page-session";
+import {
+  extractPageSession,
+  issuePageSessionCookie,
+  MAX_PAGE_SESSION_COOKIES,
+  pageSessionSetCookies,
+  parseCookieHeader,
+  signPageSession,
+  verifyPageSession,
+} from "../utils/page-session";
 
 const ORIGINAL_SECRET = process.env.PAGE_SESSION_SECRET;
 const ORIGINAL_API_KEY = process.env.API_KEY;
@@ -266,3 +274,96 @@ describe("parseCookieHeader", () => {
     expect(parseCookieHeader("xxpage_session=evil; other=ok", "page_session")).toBeUndefined();
   });
 });
+
+describe("per-page session cookies", () => {
+  const exp = () => Math.floor(Date.now() / 1000) + 3600;
+  const req = (cookie: string) => ({ headers: { cookie } });
+
+  test("issuance names the cookie after the page", async () => {
+    const header = await issuePageSessionCookie("pagea", { dev: true });
+    expect(header.startsWith("page_session_pagea=")).toBe(true);
+  });
+
+  test("each page reads its own cookie from a shared jar", async () => {
+    const a = await signPageSession({ pageId: "pagea", exp: exp() });
+    const b = await signPageSession({ pageId: "pageb", exp: exp() });
+    const jar = req(`page_session_pagea=${a}; page_session_pageb=${b}`);
+    expect((await extractPageSession(jar, "pagea"))?.token).toBe(a);
+    expect((await extractPageSession(jar, "pageb"))?.token).toBe(b);
+  });
+
+  test("the legacy page_session cookie is accepted only for the page it names", async () => {
+    const a = await signPageSession({ pageId: "pagea", exp: exp() });
+    expect((await extractPageSession(req(`page_session=${a}`), "pagea"))?.payload.pageId).toBe(
+      "pagea",
+    );
+    expect(await extractPageSession(req(`page_session=${a}`), "pageb")).toBeNull();
+  });
+
+  test("a token for another page under this page's name is ignored", async () => {
+    const a = await signPageSession({ pageId: "pagea", exp: exp() });
+    expect(await extractPageSession(req(`page_session_pageb=${a}`), "pageb")).toBeNull();
+  });
+
+  test("an id that is not cookie-name safe is refused", async () => {
+    const a = await signPageSession({ pageId: "a=b", exp: exp() });
+    expect(await extractPageSession(req(`page_session=${a}`), "a=b")).toBeNull();
+  });
+});
+
+describe("pageSessionSetCookies", () => {
+  const now = () => Math.floor(Date.now() / 1000);
+  const cookieFor = async (pageId: string, exp = now() + 3600) =>
+    `page_session_${pageId}=${await signPageSession({ pageId, exp })}`;
+  const evicted = (lines: string[]) =>
+    lines.slice(1).map((line) => {
+      expect(line).toContain("Max-Age=0");
+      return line.split("=")[0];
+    });
+
+  test("issues only the new session when the jar is under the cap", async () => {
+    const jar = await cookieFor("pagea");
+    const lines = await pageSessionSetCookies({ headers: { cookie: jar } }, "pageb", { dev: true });
+    expect(lines).toHaveLength(1);
+    expect(lines[0]!.startsWith("page_session_pageb=")).toBe(true);
+  });
+
+  test("evicts the oldest sessions beyond the cap", async () => {
+    const ids = Array.from({ length: MAX_PAGE_SESSION_COOKIES + 4 }, (_, i) => `page${i}`);
+    // page0 expires soonest, so it is the oldest launch.
+    const jar = (await Promise.all(ids.map((id, i) => cookieFor(id, now() + 1000 + i)))).join("; ");
+    const lines = await pageSessionSetCookies({ headers: { cookie: jar } }, "fresh", { dev: true });
+    expect(evicted(lines).sort()).toEqual(
+      ["page0", "page1", "page2", "page3", "page4"].map((id) => `page_session_${id}`).sort(),
+    );
+  });
+
+  test("breaks same-second ties toward the cookie listed later", async () => {
+    const exp = now() + 3600;
+    const ids = Array.from({ length: MAX_PAGE_SESSION_COOKIES }, (_, i) => `tie${i}`);
+    const jar = (await Promise.all(ids.map((id) => cookieFor(id, exp)))).join("; ");
+    const lines = await pageSessionSetCookies({ headers: { cookie: jar } }, "fresh", { dev: true });
+    expect(evicted(lines)).toEqual(["page_session_tie0"]);
+  });
+
+  test("evicts expired, forged and misnamed sessions but keeps legacy and own cookies", async () => {
+    const jar = [
+      await cookieFor("expired", now() - 10),
+      `page_session_forged=${await forgeToken({ pageId: "forged", exp: now() + 3600 }, "x")}`,
+      `page_session_misnamed=${await signPageSession({ pageId: "other", exp: now() + 3600 })}`,
+      `page_session=${await signPageSession({ pageId: "legacy", exp: now() + 3600 })}`,
+      await cookieFor("fresh"),
+      await cookieFor("kept"),
+    ].join("; ");
+    const lines = await pageSessionSetCookies({ headers: { cookie: jar } }, "fresh", {
+      dev: false,
+    });
+    expect(evicted(lines).sort()).toEqual([
+      "page_session_expired",
+      "page_session_forged",
+      "page_session_misnamed",
+    ]);
+    // Prod eviction cookies carry the same SameSite=None; Secure attributes.
+    for (const line of lines) expect(line).toContain("SameSite=None; Secure");
+  });
+});

package/src/tests/pages-authed-mode.test.ts

@@ -5,8 +5,9 @@
  *   2. `GET /p/:id` without cookie → 401.
  *   3. `POST /api/pages/:id/launch` (bearer) → 204 + Set-Cookie.
  *   4. `GET /p/:id` with cookie → 200 + SDK injected.
- *   5. `GET /p/:id` with cookie scoped to a DIFFERENT page id → 403.
- *   6. `GET /p/:id.json` with cookie → 200 + JSON metadata.
+ *   5. A session signed for a DIFFERENT page id is ignored → 401.
+ *   6. Two launched pages both load from one cookie jar.
+ *   7. `GET /p/:id.json` with cookie → 200 + JSON metadata.
  *
  * Uses the same in-process handler wiring as `pages-public-html.test.ts` so
  * we don't have to boot the full http server. The proxy in
@@ -26,7 +27,7 @@ import { closeDb, initDb } from "../be/db";
 import { handlePages } from "../http/pages";
 import { handlePagesPublic } from "../http/pages-public";
 import { getPathSegments, parseQueryParams } from "../http/utils";
-import { signPageSession } from "../utils/page-session";
+import { MAX_PAGE_SESSION_COOKIES, signPageSession } from "../utils/page-session";
 import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-pages-authed-mode.sqlite";
@@ -47,7 +48,7 @@ function createTestServer(): Server {
 /** Pull the cookie value out of a Set-Cookie header line. */
 function extractCookieValue(setCookie: string | null): string {
   expect(setCookie).toBeTruthy();
-  const match = /page_session=([^;]+)/.exec(setCookie!);
+  const match = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(setCookie!);
   expect(match).toBeTruthy();
   return match![1]!;
 }
@@ -132,7 +133,7 @@ describe("GET /p/:id — authed mode cookie gate (step-4)", () => {
     expect(text).toContain("class SwarmSDK");
   });
 
-  test("cookie scoped to a different page id → 403", async () => {
+  test("a session signed for another page is ignored → 401", async () => {
     const idA = await createAuthedPage("page-a");
     const idB = await createAuthedPage("page-b");
 
@@ -140,13 +141,82 @@ describe("GET /p/:id — authed mode cookie gate (step-4)", () => {
     const exp = Math.floor(Date.now() / 1000) + 3600;
     const tokenForA = await signPageSession({ pageId: idA, exp });
 
-    // … and try to use it for page B.
-    const res = await fetch(`${BASE}/p/${idB}`, {
-      headers: { Cookie: `page_session=${tokenForA}` },
-    });
-    expect(res.status).toBe(403);
-    const body = (await res.json()) as { error: string };
-    expect(body.error).toContain("different page id");
+    // … and try to use it for page B, under the legacy name and under B's own name.
+    for (const cookie of [`page_session=${tokenForA}`, `page_session_${idB}=${tokenForA}`]) {
+      const res = await fetch(`${BASE}/p/${idB}`, { headers: { Cookie: cookie } });
+      expect(res.status).toBe(401);
+    }
+  });
+
+  test("two launched pages both load from one cookie jar", async () => {
+    const idA = await createAuthedPage("tab-a");
+    const idB = await createAuthedPage("tab-b");
+    const jar: string[] = [];
+    for (const id of [idA, idB]) {
+      const launch = await fetch(`${BASE}/api/pages/${id}/launch`, {
+        method: "POST",
+        headers: { "X-Agent-ID": agentId },
+      });
+      expect(launch.status).toBe(204);
+      const setCookie = launch.headers.get("set-cookie")!;
+      expect(setCookie.startsWith(`page_session_${id}=`)).toBe(true);
+      jar.push(setCookie.split(";")[0]!);
+    }
+    const cookie = jar.join("; ");
+    for (const id of [idA, idB]) {
+      const res = await fetch(`${BASE}/p/${id}`, { headers: { Cookie: cookie } });
+      expect(res.status).toBe(200);
+    }
+  });
+
+  test("90 launches from one browser keep the Cookie header bounded", async () => {
+    // A browser jar: Set-Cookie with Max-Age=0 deletes, anything else upserts.
+    const jar = new Map<string, string>();
+    const cookieHeader = () => [...jar].map(([name, value]) => `${name}=${value}`).join("; ");
+    const ids: string[] = [];
+    for (let i = 0; i < 90; i++) {
+      const id = await createAuthedPage(`overflow-${i}`);
+      ids.push(id);
+      const launch = await fetch(`${BASE}/api/pages/${id}/launch`, {
+        method: "POST",
+        headers: { "X-Agent-ID": agentId, Cookie: cookieHeader() },
+      });
+      expect(launch.status).toBe(204);
+      for (const line of launch.headers.getSetCookie()) {
+        const [pair] = line.split(";");
+        const eq = pair!.indexOf("=");
+        const name = pair!.slice(0, eq);
+        if (/Max-Age=0(;|$)/.test(line)) jar.delete(name);
+        else jar.set(name, pair!.slice(eq + 1));
+      }
+    }
+
+    expect(jar.size).toBe(MAX_PAGE_SESSION_COOKIES);
+    expect(cookieHeader().length).toBeLessThan(8 * 1024);
+    // The newest launches keep their sessions; the oldest were evicted.
+    for (const id of ids.slice(-MAX_PAGE_SESSION_COOKIES)) {
+      const res = await fetch(`${BASE}/p/${id}`, { headers: { Cookie: cookieHeader() } });
+      expect(res.status).toBe(200);
+    }
+    expect(jar.has(`page_session_${ids[0]}`)).toBe(false);
+
+    // Control: the same sessions, operator-shaped as the dashboard mints them,
+    // overflow the 16 KB header limit when nothing evicts them.
+    const unbounded = (
+      await Promise.all(
+        ids.map(async (id) => {
+          const token = await signPageSession({
+            pageId: id,
+            exp: Math.floor(Date.now() / 1000) + 3600,
+            name: "guest-0123abcd",
+            op: true,
+          });
+          return `page_session_${id}=${token}`;
+        }),
+      )
+    ).join("; ");
+    const overflow = await fetch(`${BASE}/p/${ids.at(-1)}`, { headers: { Cookie: unbounded } });
+    expect(overflow.status).toBe(431);
   });
 
   test("/p/:id.json with cookie → 200 + JSON metadata", async () => {

package/src/tests/pages-password-mode.test.ts

@@ -47,7 +47,7 @@ function createTestServer(): Server {
 
 function extractCookieValue(setCookie: string | null): string {
   expect(setCookie).toBeTruthy();
-  const match = /page_session=([^;]+)/.exec(setCookie!);
+  const match = /page_session_[A-Za-z0-9_-]+=([^;]+)/.exec(setCookie!);
   expect(match).toBeTruthy();
   return match![1]!;
 }
@@ -140,7 +140,7 @@ describe("GET /p/:id — password mode (step-5)", () => {
     expect(res.status).toBe(200);
     expect(res.headers.get("content-type")?.toLowerCase()).toContain("text/html");
     const cookieHeader = res.headers.get("set-cookie");
-    expect(cookieHeader).toContain("page_session=");
+    expect(cookieHeader).toContain("page_session_");
     const text = await res.text();
     expect(text).toContain("<h1>open sesame</h1>");
     // BROWSER_SDK_JS sentinel.
@@ -158,7 +158,7 @@ describe("GET /p/:id — password mode (step-5)", () => {
       headers: { Authorization: `Basic ${basic}` },
     });
     expect(res.status).toBe(200);
-    expect(res.headers.get("set-cookie")).toContain("page_session=");
+    expect(res.headers.get("set-cookie")).toContain("page_session_");
     const text = await res.text();
     expect(text).toContain("<h1>via basic</h1>");
   });
@@ -222,7 +222,7 @@ describe("GET /p/:id — password mode (step-5)", () => {
     const id = await createPasswordPage("json-key", "swordfish");
     const res = await fetch(`${BASE}/p/${id}.json?key=swordfish`);
     expect(res.status).toBe(200);
-    expect(res.headers.get("set-cookie")).toContain("page_session=");
+    expect(res.headers.get("set-cookie")).toContain("page_session_");
   });
 
   test("cross-page cookie reuse → 401 + password prompt (cookie is silently ignored for password mode)", async () => {
@@ -252,7 +252,7 @@ describe("GET /p/:id — password mode (step-5)", () => {
       headers: { Cookie: `page_session=${cookieForA}` },
     });
     expect(recover.status).toBe(200);
-    expect(recover.headers.get("set-cookie")).toContain("page_session=");
+    expect(recover.headers.get("set-cookie")).toContain("page_session_");
   });
 
   test("malformed Basic header (no colon) → 401 (no crash)", async () => {

package/src/tests/pi-codemode.test.ts

@@ -340,8 +340,14 @@ describe("bounded codemode", () => {
         undefined,
         fakeCtx().ctx,
       );
-      expect(Date.now() - started).toBeLessThan(5_000);
-      expect(textOf(result)).toContain("Codemode worker limit reached");
+      const elapsed = Date.now() - started;
+      expect(elapsed).toBeGreaterThanOrEqual(250);
+      expect(elapsed).toBeLessThan(5_000);
+      // pi 1.4 queues the script for a worker; our deadline ends the wait.
+      expect(textOf(result)).toContain(
+        "Script aborted: Codemode script exceeded its 300 ms deadline",
+      );
+      expect(textOf(result)).toContain("The script did not start.");
     } finally {
       holders.abort(new Error("test done"));
       await Promise.all(holding);

package/src/tests/preload-env.test.ts

@@ -0,0 +1,57 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CHILD_PROCESS_TEST_BUDGET_MS, expectChildOk, runChild } from "./test-proc";
+
+test(
+  "preload clears inherited worker configuration before test files load",
+  async () => {
+    const directory = await mkdtemp(join(tmpdir(), "swarm-preload-env-"));
+    const fixture = join(directory, "worker-env.test.ts");
+    const keys = [
+      "SLACK_RENDER_V2",
+      "SLACK_STATUS_ICON_COMPLETED",
+      "SLACK_FUTURE_SETTING",
+      "COMB_ENABLED",
+      "APP_URL",
+      "AGENT_FS_API_URL",
+      "AGENT_FS_LIVE_URL",
+      "AGENT_FS_DEFAULT_ORG_ID",
+      "AGENT_FS_DEFAULT_DRIVE_ID",
+      "SWARM_ORG_NAME",
+      "SWARM_ORG_WEBSITE",
+    ];
+    try {
+      await Bun.write(
+        fixture,
+        `import { expect, test } from "bun:test";
+const inherited = ${JSON.stringify(keys)}.filter(key => process.env[key] !== undefined);
+test("worker defaults are cleared before module evaluation", () => {
+  expect(inherited).toEqual([]);
+  expect(process.env.PRELOAD_ENV_CONTROL).toBe("preserved");
+  process.env.SLACK_STATUS_ICON_COMPLETED = "test-icon";
+});
+test("suite configuration survives between tests", () => {
+  expect(process.env.SLACK_STATUS_ICON_COMPLETED).toBe("test-icon");
+});
+`,
+      );
+      const result = expectChildOk(
+        await runChild([process.execPath, "test", fixture], {
+          cwd: join(import.meta.dir, "../.."),
+          env: {
+            ...process.env,
+            ...Object.fromEntries(keys.map((key) => [key, "inherited-worker-setting"])),
+            PRELOAD_ENV_CONTROL: "preserved",
+          },
+        }),
+        "test runner with inherited worker env",
+      );
+      expect(result.stderr).toContain("2 pass");
+    } finally {
+      await rm(directory, { recursive: true, force: true });
+    }
+  },
+  CHILD_PROCESS_TEST_BUDGET_MS,
+);

package/src/tests/preload.ts

@@ -22,6 +22,27 @@ import { startHangWatchdog } from "./hang-watchdog";
 
 startHangWatchdog();
 
+// Worker deployments configure Slack rendering, links, and organization defaults.
+// Start tests from the same unset defaults as CI; suites can still opt in by
+// setting their own values after the preload runs.
+for (const key of Object.keys(process.env)) {
+  if (
+    key.startsWith("SLACK_") ||
+    [
+      "COMB_ENABLED",
+      "APP_URL",
+      "AGENT_FS_API_URL",
+      "AGENT_FS_LIVE_URL",
+      "AGENT_FS_DEFAULT_ORG_ID",
+      "AGENT_FS_DEFAULT_DRIVE_ID",
+      "SWARM_ORG_NAME",
+      "SWARM_ORG_WEBSITE",
+    ].includes(key)
+  ) {
+    delete process.env[key];
+  }
+}
+
 // The API drain (src/be/api-drain.ts) is off unless API_DRAIN_MAX_MS is set,
 // but a shell can inherit it (a swarm worker container gets the deploy's value).
 // Test servers are stopped with SIGTERM and their fixtures leave in_progress rows

package/src/tests/prompt-template-remaining.test.ts

@@ -6,6 +6,7 @@ import { resolveTemplate } from "../prompts/resolver";
 
 // Side-effect imports: register all templates from each source
 import "../gitlab/templates";
+import "../bitbucket/templates";
 import "../agentmail/templates";
 import "../linear/templates";
 import "../heartbeat/templates";
@@ -28,6 +29,7 @@ async function ensureTemplatesRegistered(): Promise<void> {
   // module state across parallel test files, a single-template check is racy.
   const ts = Date.now();
   await import(`../gitlab/templates?t=${ts}`);
+  await import(`../bitbucket/templates?t=${ts}`);
   await import(`../agentmail/templates?t=${ts}`);
   await import(`../linear/templates?t=${ts}`);
   await import(`../heartbeat/templates?t=${ts}`);
@@ -94,6 +96,42 @@ describe("template registration — all sources", () => {
     expect(eventTypes).toContain("gitlab.pipeline.failed");
   });
 
+  test("Bitbucket templates are registered (2 common + 3 event)", () => {
+    const eventTypes = getAllTemplateDefinitions().map((d) => d.eventType);
+    expect(eventTypes).toContain("common.delegation_instruction.bitbucket");
+    expect(eventTypes).toContain("common.command_suggestions.bitbucket_pr");
+    expect(eventTypes).toContain("bitbucket.pull_request.opened");
+    expect(eventTypes).toContain("bitbucket.pull_request.review_requested");
+    expect(eventTypes).toContain("bitbucket.comment.mentioned");
+  });
+
+  test("Bitbucket templates resolve with no unresolved variables", () => {
+    const shared = {
+      pr_id: 42,
+      pr_title: "Fix retry",
+      repo: "acme-ws/widgets",
+      username: "Dana",
+      pr_url: "https://bitbucket.org/acme-ws/widgets/pull-requests/42",
+    };
+    const pr = { ...shared, source_branch: "feat", target_branch: "main", context_section: "" };
+    for (const id of ["bitbucket.pull_request.opened", "bitbucket.pull_request.review_requested"]) {
+      const result = resolveTemplate(id, pr);
+      expect(result.skipped).toBe(false);
+      expect(result.unresolved).toEqual([]);
+      expect(result.text).toContain("[Bitbucket PR #42]");
+      expect(result.text).toContain("api.bitbucket.org/2.0/repositories/acme-ws/widgets");
+    }
+    const comment = resolveTemplate("bitbucket.comment.mentioned", {
+      ...shared,
+      location_section: "File: src/a.ts:3\n",
+      context: "please fix",
+      existing_task_note: "",
+    });
+    expect(comment.unresolved).toEqual([]);
+    expect(comment.text).toContain("File: src/a.ts:3");
+    expect(comment.text).toContain("please fix");
+  });
+
   test("AgentMail templates are registered (5 event)", () => {
     const all = getAllTemplateDefinitions();
     const eventTypes = all.map((d) => d.eventType);