@desplega.ai/agent-swarm 2.4.3 → 2.4.5

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/rbac-engine.test.ts

@@ -105,6 +105,7 @@ const OPERATOR_OR_USER_VERBS: PermissionVerb[] = [
   "approval.respond",
   "runtime_controller.write",
   "runtime_pool.write",
+  "agent.token.manage",
 ];
 
 const LEAD_OR_OPERATOR_VERBS: PermissionVerb[] = ["models.catalog.write"];

package/src/tests/realtime-transport.test.ts

@@ -75,9 +75,11 @@ async function createPage(
 async function launchPage(pageId: string, agentId: string): Promise<string> {
   const response = await api("POST", `/api/pages/${pageId}/launch`, { agentId });
   expect(response.status).toBe(204);
-  const cookie = response.headers.get("set-cookie")?.match(/page_session=([^;]+)/)?.[1];
+  const cookie = response.headers
+    .get("set-cookie")
+    ?.match(/page_session_[A-Za-z0-9_-]+=([^;]+)/)?.[1];
   expect(cookie).toBeTruthy();
-  return `page_session=${cookie}`;
+  return `page_session_${pageId}=${cookie}`;
 }
 
 async function createUserToken(name: string): Promise<{ id: string; token: string }> {
@@ -107,17 +109,21 @@ async function launchPageAsUser(pageId: string, token: string): Promise<string>
     headers: { Authorization: `Bearer ${token}` },
   });
   expect(response.status).toBe(204);
-  const cookie = response.headers.get("set-cookie")?.match(/page_session=([^;]+)/)?.[1];
+  const cookie = response.headers
+    .get("set-cookie")
+    ?.match(/page_session_[A-Za-z0-9_-]+=([^;]+)/)?.[1];
   expect(cookie).toBeTruthy();
-  return `page_session=${cookie}`;
+  return `page_session_${pageId}=${cookie}`;
 }
 
 async function unlockPasswordPage(pageId: string, password: string): Promise<string> {
   const response = await fetch(`${baseUrl}/p/${pageId}?key=${encodeURIComponent(password)}`);
   expect(response.status).toBe(200);
-  const cookie = response.headers.get("set-cookie")?.match(/page_session=([^;]+)/)?.[1];
+  const cookie = response.headers
+    .get("set-cookie")
+    ?.match(/page_session_[A-Za-z0-9_-]+=([^;]+)/)?.[1];
   expect(cookie).toBeTruthy();
-  return `page_session=${cookie}`;
+  return `page_session_${pageId}=${cookie}`;
 }
 
 function openSocket(
@@ -443,7 +449,7 @@ describe("realtime transport", () => {
     const passwordPage = await createPage(agentId, "password", "secret");
     expect(await socketAccepted({ Origin: baseUrl }, pageSocketUrl(passwordPage))).toBe(false);
     const passwordCookie = await unlockPasswordPage(passwordPage, "secret");
-    expect(passwordCookie).toContain("page_session=");
+    expect(passwordCookie).toContain("page_session_");
   });
 
   test("persists room state across an API restart and cascades page deletion", async () => {

package/src/tests/runtime-child-token-cleanup.test.ts

@@ -9,6 +9,7 @@ import { handleSessions } from "../http/sessions";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { ACPAdapter } from "../providers/acp-adapter";
 import { setRequestAuth } from "../utils/request-auth-context";
+import { ACP_SDK_PATH, serveFakeAcpAgent } from "./acp-fake-agent";
 import { listenOnFreePort } from "./test-net";
 import { CHILD_PROCESS_TEST_BUDGET_MS } from "./test-proc";
 
@@ -69,12 +70,11 @@ for (const setupFails of [false, true]) {
       const api = await startApi(resolveRevoke);
       const script = join(tmpdir(), `runtime-child-${crypto.randomUUID()}.ts`);
       const capture = `${script}.auth`;
-      const sdk = join(process.cwd(), "node_modules/@agentclientprotocol/sdk/dist/acp.js");
       await Bun.write(
         script,
         `
 import { Readable, Writable } from "node:stream";
-import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream } from ${JSON.stringify(sdk)};
+import { PROTOCOL_VERSION, agent, methods, ndJsonStream } from ${JSON.stringify(ACP_SDK_PATH)};
 class Agent {
   async initialize() {
     return { protocolVersion: PROTOCOL_VERSION, agentCapabilities: { loadSession: false } };
@@ -89,7 +89,7 @@ class Agent {
   async prompt() { return { stopReason: "end_turn" }; }
   async cancel() {}
 }
-new AgentSideConnection(() => new Agent(), ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin)));
+${serveFakeAcpAgent("Agent")}
 `,
       );
       try {

package/src/tests/script-connections.test.ts

@@ -636,6 +636,8 @@ describe("script connections", () => {
       markMigrationApplied(database, "227_inbox_item_state_last_read_at.sql");
       // 231 indexes agent_tasks columns that this fixture's id-only agent_tasks lacks.
       markMigrationApplied(database, "231_slack_tasks_last_updated_index.sql");
+      // 232 rebuilds session_tokens with the 207 columns, which this fixture skipped.
+      markMigrationApplied(database, "232_agent_session_tokens.sql");
 
       const id = crypto.randomUUID();
       const now = new Date().toISOString();