@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/src/tests/opencode-shell-env.test.ts

@@ -0,0 +1,145 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OpenCode } from "@opencode/sdk";
+import { fetchResolvedEnv } from "../commands/runner";
+import { createOpencodeSwarmPlugin } from "../providers/opencode-swarm-plugin";
+
+/**
+ * OpenCode runs in-process, so its shell tool would spawn with the worker's
+ * process.env. The swarm plugin swaps in the env the runner resolved for the
+ * task: a row admitted after boot (exportToEnv flipped on) must reach the
+ * shell, and a row revoked after boot (flipped off) must leave it, even though
+ * process.env still holds the boot value.
+ */
+
+type ConfigRow = { key: string; value: string; isSecret: boolean; exportToEnv: boolean };
+
+const SHELL_TIMEOUT_MS = 15_000;
+
+let server: ReturnType<typeof Bun.serve>;
+let apiUrl = "";
+let rows: ConfigRow[] = [];
+let directory = "";
+
+beforeAll(() => {
+  server = Bun.serve({
+    port: 0,
+    fetch: () => Response.json({ configs: rows }),
+  });
+  apiUrl = `http://localhost:${server.port}`;
+  directory = mkdtempSync(join(tmpdir(), "opencode-shell-env-"));
+});
+
+afterAll(() => {
+  server.stop(true);
+  rmSync(directory, { recursive: true, force: true });
+});
+
+type Host = Awaited<ReturnType<typeof OpenCode.create>>;
+
+async function hostWithEnv(env: Record<string, string | undefined>): Promise<Host> {
+  const plugin = createOpencodeSwarmPlugin({
+    apiUrl: "http://127.0.0.1:9",
+    apiKey: "",
+    agentId: "agent-1",
+    taskId: "",
+    isLead: false,
+    env,
+  });
+  return OpenCode.create({ plugins: [plugin], log: { level: "error", emit: () => {} } });
+}
+
+/**
+ * Runs one command as a session shell call, the path the agent's shell tool
+ * takes (`host.shell.create` skips plugin hooks), and returns its output.
+ */
+async function shell(host: Host, command: string): Promise<string> {
+  const session = await host.sessions.create({ location: { directory } });
+  const outFile = join(directory, `out-${crypto.randomUUID()}.txt`);
+  await host.sessions.shell({
+    sessionID: session.id,
+    command: `{ ${command}; } > ${outFile}.tmp 2>&1; mv ${outFile}.tmp ${outFile}`,
+  });
+  const deadline = Date.now() + SHELL_TIMEOUT_MS;
+  while (!(await Bun.file(outFile).exists())) {
+    if (Date.now() > deadline) throw new Error("shell did not exit");
+    await Bun.sleep(25);
+  }
+  return (await Bun.file(outFile).text()).trim();
+}
+
+describe("OpenCode shell env (real OpenCode host)", () => {
+  const envKeys = ["SHELL_REVOKED_CANARY", "SHELL_ADMITTED_CANARY"] as const;
+  const saved: Record<string, string | undefined> = {};
+  let log: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    for (const key of envKeys) saved[key] = process.env[key];
+    log = spyOn(console, "log").mockImplementation(() => {});
+  });
+  afterEach(() => {
+    log.mockRestore();
+    for (const key of envKeys) {
+      if (saved[key] === undefined) delete process.env[key];
+      else process.env[key] = saved[key];
+    }
+  });
+
+  test(
+    "admission and revocation after boot reach the shell",
+    async () => {
+      process.env.SHELL_REVOKED_CANARY = "boot-revoked";
+      delete process.env.SHELL_ADMITTED_CANARY;
+      rows = [
+        { key: "SHELL_REVOKED_CANARY", value: "row-revoked", isSecret: true, exportToEnv: false },
+        { key: "SHELL_ADMITTED_CANARY", value: "row-admitted", isSecret: true, exportToEnv: true },
+      ];
+      const { env } = await fetchResolvedEnv(apiUrl, "key", "agent-1", process.env);
+      const host = await hostWithEnv(env);
+      try {
+        const out = await shell(
+          host,
+          'echo "admitted=$SHELL_ADMITTED_CANARY revoked=$SHELL_REVOKED_CANARY term=$OPENCODE_TERMINAL."; tr "\\0" "\\n" < /proc/$$/environ | grep -c "^SHELL_REVOKED_CANARY=" || true',
+        );
+        expect(out).toContain("admitted=row-admitted revoked= term=1.");
+        expect(out.split("\n").at(-1)).toBe("0");
+      } finally {
+        await host.close();
+      }
+    },
+    SHELL_TIMEOUT_MS * 2,
+  );
+
+  test(
+    "concurrent hosts keep their own env",
+    async () => {
+      const [first, second] = await Promise.all([
+        hostWithEnv({ ...process.env, SHELL_ADMITTED_CANARY: "first" }),
+        hostWithEnv({ ...process.env, SHELL_ADMITTED_CANARY: undefined }),
+      ]);
+      try {
+        const [a, b] = await Promise.all([
+          shell(first, 'echo "v=$SHELL_ADMITTED_CANARY"'),
+          shell(second, 'echo "v=$SHELL_ADMITTED_CANARY"'),
+        ]);
+        expect(a).toBe("v=first");
+        expect(b).toBe("v=");
+        expect(process.env.SHELL_ADMITTED_CANARY).toBeUndefined();
+      } finally {
+        await Promise.all([first.close(), second.close()]);
+      }
+    },
+    SHELL_TIMEOUT_MS * 2,
+  );
+});

package/src/tests/openrouter-base-url.test.ts

@@ -2,16 +2,17 @@
  * OPENROUTER_BASE_URL gateway routing — unit tests.
  *
  * Covers the shared resolver (`src/utils/openrouter-base-url.ts`), the pi
- * models.json override writer (`ensureOpenRouterModelsOverride`) including
- * its composition through pi-coding-agent's ModelRuntime, and attribution host gating.
+ * per-session models.json composer (`writeSessionModelsJson`) for every shared
+ * starting state, its composition through pi-coding-agent's ModelRuntime, and
+ * attribution host gating.
  */
 
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
-import { ensureOpenRouterModelsOverride } from "../providers/pi-mono-adapter";
+import { writeSessionModelsJson } from "../providers/pi-mono-adapter";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterAttributionHeaders,
@@ -47,162 +48,111 @@ describe("getOpenRouterBaseUrl", () => {
   });
 });
 
-describe("ensureOpenRouterModelsOverride (pi)", () => {
-  let agentDir: string;
-
-  beforeAll(() => {
-    agentDir = mkdtempSync(join(tmpdir(), "pi-or-override-"));
-  });
-
-  afterAll(() => {
-    rmSync(agentDir, { recursive: true, force: true });
-  });
-
-  test("no-op when OPENROUTER_BASE_URL is unset", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-noop-"));
-    try {
-      await ensureOpenRouterModelsOverride(dir, {});
-      expect(await Bun.file(join(dir, "models.json")).exists()).toBe(false);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("writes providers.openrouter.baseUrl when the env is set", async () => {
-    await ensureOpenRouterModelsOverride(agentDir, { OPENROUTER_BASE_URL: GATEWAY });
-    const written = JSON.parse(await Bun.file(join(agentDir, "models.json")).text());
-    expect(written).toEqual({ providers: { openrouter: { baseUrl: GATEWAY } } });
-  });
-
-  test("reverts a written override when the env returns to default (file we created is removed)", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-revert-"));
-    try {
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      expect(await Bun.file(join(dir, "models.json")).exists()).toBe(true);
-      await ensureOpenRouterModelsOverride(dir, {});
-      // The override was ALL the file contained — both it and the marker go.
-      expect(await Bun.file(join(dir, "models.json")).exists()).toBe(false);
-      expect(await Bun.file(join(dir, ".agent-swarm-openrouter-override.json")).exists()).toBe(
-        false,
-      );
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("revert restores a displaced user baseUrl and keeps sibling keys", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-restore-"));
-    try {
-      await Bun.write(
-        join(dir, "models.json"),
-        JSON.stringify({
-          providers: {
-            openrouter: { baseUrl: "https://user.example/v1", compat: { supportsTools: true } },
-            custom: { baseUrl: "https://custom.example/v1", api: "openai-completions" },
-          },
-        }),
-      );
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      // Re-run with the gateway still set — displaced value must survive.
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      await ensureOpenRouterModelsOverride(dir, {});
-      const restored = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(restored.providers.openrouter).toEqual({
-        baseUrl: "https://user.example/v1",
-        compat: { supportsTools: true },
-      });
-      expect(restored.providers.custom).toEqual({
-        baseUrl: "https://custom.example/v1",
-        api: "openai-completions",
+describe("writeSessionModelsJson — OpenRouter gateway (pi)", () => {
+  const MARKER = ".agent-swarm-openrouter-override.json";
+  const LEGACY = "https://legacy-gateway.example/v1";
+  const USER = "https://user.example/v1";
+  const userOpenRouter = { baseUrl: USER, compat: { supportsTools: true } };
+  const custom = { baseUrl: "https://custom.example/v1", api: "openai-completions" };
+
+  /** Starting states of the shared agent dir; the marker ones are left by earlier versions. */
+  const states: Record<string, Record<string, string>> = {
+    "no models.json": {},
+    "hand-authored baseUrl": {
+      "models.json": JSON.stringify({ providers: { openrouter: userOpenRouter, custom } }),
+    },
+    "legacy override over a user baseUrl": {
+      "models.json": JSON.stringify({
+        providers: { openrouter: { ...userOpenRouter, baseUrl: LEGACY }, custom },
+      }),
+      [MARKER]: JSON.stringify({ baseUrl: LEGACY, previous: USER }),
+    },
+    "legacy override alone": {
+      "models.json": JSON.stringify({ providers: { openrouter: { baseUrl: LEGACY } } }),
+      [MARKER]: JSON.stringify({ baseUrl: LEGACY }),
+    },
+    "legacy marker, baseUrl edited by hand since": {
+      "models.json": JSON.stringify({ providers: { openrouter: { baseUrl: USER } } }),
+      [MARKER]: JSON.stringify({ baseUrl: LEGACY }),
+    },
+    "corrupt models.json": { "models.json": "{not json" },
+  };
+
+  // The openrouter block the session's runtime loads, per state, for the
+  // default gateway and for OPENROUTER_BASE_URL=GATEWAY. `null`: no copy, and
+  // the session loads the shared file as it is.
+  const expected: Record<string, [defaultGateway: unknown, gateway: unknown]> = {
+    "no models.json": [null, { baseUrl: GATEWAY }],
+    "hand-authored baseUrl": [null, { ...userOpenRouter, baseUrl: GATEWAY }],
+    "legacy override over a user baseUrl": [
+      userOpenRouter,
+      { ...userOpenRouter, baseUrl: GATEWAY },
+    ],
+    "legacy override alone": [undefined, { baseUrl: GATEWAY }],
+    "legacy marker, baseUrl edited by hand since": [{ baseUrl: USER }, { baseUrl: GATEWAY }],
+    "corrupt models.json": [null, { baseUrl: GATEWAY }],
+  };
+
+  function snapshot(dir: string): Record<string, string> {
+    return Object.fromEntries(
+      readdirSync(dir)
+        .sort()
+        .map((name) => [name, readFileSync(join(dir, name), "utf-8")]),
+    );
+  }
+
+  for (const [state, files] of Object.entries(states)) {
+    for (const [i, env] of [{}, { OPENROUTER_BASE_URL: GATEWAY }].entries()) {
+      const label = i === 0 ? "default gateway" : "session gateway";
+      test(`${state}, ${label}: composed privately, shared dir untouched`, async () => {
+        const dir = mkdtempSync(join(tmpdir(), "pi-or-session-"));
+        try {
+          for (const [name, text] of Object.entries(files)) await Bun.write(join(dir, name), text);
+          const before = snapshot(dir);
+          const session = await writeSessionModelsJson(dir, env);
+          try {
+            const want = expected[state]?.[i];
+            if (want === null) {
+              expect(session.modelsPath).toBeUndefined();
+            } else {
+              expect(session.modelsPath).toBeDefined();
+              expect(session.modelsPath?.startsWith(dir)).toBe(false);
+              const copy = JSON.parse(readFileSync(session.modelsPath as string, "utf-8"));
+              expect(copy.providers?.openrouter).toEqual(want);
+              if (files["models.json"]?.includes("custom.example")) {
+                expect(copy.providers.custom).toEqual(custom);
+              }
+            }
+          } finally {
+            await session.dispose();
+          }
+          expect(snapshot(dir)).toEqual(before);
+        } finally {
+          rmSync(dir, { recursive: true, force: true });
+        }
       });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("revert leaves a user-edited baseUrl alone (marker mismatch) and drops the marker", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-user-edit-"));
-    try {
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      // User hand-edits the file after we wrote it.
-      await Bun.write(
-        join(dir, "models.json"),
-        JSON.stringify({ providers: { openrouter: { baseUrl: "https://mine.example/v1" } } }),
-      );
-      await ensureOpenRouterModelsOverride(dir, {});
-      const kept = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(kept.providers.openrouter.baseUrl).toBe("https://mine.example/v1");
-      expect(await Bun.file(join(dir, ".agent-swarm-openrouter-override.json")).exists()).toBe(
-        false,
-      );
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("default env never touches a hand-authored models.json (no marker)", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-hands-off-"));
-    try {
-      const userConfig = {
-        providers: { openrouter: { baseUrl: "https://mine.example/v1" } },
-      };
-      await Bun.write(join(dir, "models.json"), JSON.stringify(userConfig));
-      await ensureOpenRouterModelsOverride(dir, {});
-      expect(JSON.parse(await Bun.file(join(dir, "models.json")).text())).toEqual(userConfig);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
     }
-  });
+  }
 
-  test("merge-preserves existing providers and openrouter keys", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-merge-"));
+  test("ModelRuntime composes the override onto built-in OpenRouter models", async () => {
+    // The whole point of the lever: built-in model IDs resolved through the
+    // runtime's composed store carry the gateway baseUrl.
+    const dir = mkdtempSync(join(tmpdir(), "pi-or-runtime-"));
+    const session = await writeSessionModelsJson(dir, { OPENROUTER_BASE_URL: GATEWAY });
     try {
-      await Bun.write(
-        join(dir, "models.json"),
-        JSON.stringify({
-          providers: {
-            openrouter: { baseUrl: "https://old.example/v1", compat: { supportsTools: true } },
-            custom: { baseUrl: "https://custom.example/v1", api: "openai-completions" },
-          },
-        }),
-      );
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      const written = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(written.providers.openrouter.baseUrl).toBe(GATEWAY);
-      expect(written.providers.openrouter.compat).toEqual({ supportsTools: true });
-      expect(written.providers.custom).toEqual({
-        baseUrl: "https://custom.example/v1",
-        api: "openai-completions",
+      const runtime = await ModelRuntime.create({
+        authPath: join(dir, "auth.json"),
+        modelsPath: session.modelsPath,
       });
+      expect(runtime.getError()).toBeUndefined();
+      const model = runtime.getModel("openrouter", "anthropic/claude-sonnet-5");
+      expect(model?.baseUrl).toBe(GATEWAY);
     } finally {
+      await session.dispose();
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("overwrites a corrupt models.json with just the override", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-corrupt-"));
-    try {
-      await Bun.write(join(dir, "models.json"), "{not json");
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      const written = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(written).toEqual({ providers: { openrouter: { baseUrl: GATEWAY } } });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("ModelRuntime composes the override onto built-in OpenRouter models", async () => {
-    // The whole point of the lever: built-in model IDs resolved through the
-    // runtime's composed store carry the gateway baseUrl.
-    const runtime = await ModelRuntime.create({
-      authPath: join(agentDir, "auth.json"),
-      modelsPath: join(agentDir, "models.json"),
-    });
-    expect(runtime.getError()).toBeUndefined();
-    const model = runtime.getModel("openrouter", "anthropic/claude-sonnet-5");
-    expect(model?.baseUrl).toBe(GATEWAY);
-  });
-
   test("ModelRuntime keeps the default baseUrl when no models.json exists", async () => {
     const dir = mkdtempSync(join(tmpdir(), "pi-or-default-"));
     try {

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

@@ -15,7 +15,7 @@ import { unlink } from "node:fs/promises";
 import net from "node:net";
 import { runInNewContext } from "node:vm";
 import type { Subprocess } from "bun";
-import { BROWSER_SDK_JS } from "../artifact-sdk/browser-sdk";
+import { BROWSER_SDK_JS } from "../pages/browser-sdk";
 import { signPageSession, verifyPageSession } from "../utils/page-session";
 import { getFreePort, SERVER_BOOT_HOOK_TIMEOUT_MS, waitForServer } from "./test-net";
 

package/src/tests/pages-browser-sdk.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, mock, test } from "bun:test";
+import { BROWSER_SDK_JS } from "../pages/browser-sdk";
+
+// ─── Browser SDK tests ─────────────────────────────────────────────────
+
+describe("BROWSER_SDK_JS", () => {
+  test("is a non-empty string", () => {
+    expect(typeof BROWSER_SDK_JS).toBe("string");
+    expect(BROWSER_SDK_JS.length).toBeGreaterThan(100);
+  });
+
+  test("contains SwarmSDK class", () => {
+    expect(BROWSER_SDK_JS).toContain("class SwarmSDK");
+  });
+
+  test("is syntactically valid JavaScript", () => {
+    expect(() => new Function(BROWSER_SDK_JS)).not.toThrow();
+  });
+
+  test("exposes the eight canonical domains", () => {
+    const expectedDomains = [
+      "this.tasks",
+      "this.agents",
+      "this.events",
+      "this.memory",
+      "this.repos",
+      "this.schedules",
+      "this.approvalRequests",
+      "this.assets",
+    ];
+    for (const domain of expectedDomains) {
+      expect(BROWSER_SDK_JS).toContain(domain);
+    }
+  });
+
+  test("removed domains are NOT exposed (messages, services, slack)", () => {
+    const removed = ["this.messages", "this.services", "this.slack", "postMessage", "readMessages"];
+    for (const r of removed) {
+      expect(BROWSER_SDK_JS).not.toContain(r);
+    }
+  });
+
+  test("assigns SwarmSDK class + swarmSdk singleton to window", () => {
+    expect(BROWSER_SDK_JS).toContain("window.SwarmSDK = SwarmSDK");
+    expect(BROWSER_SDK_JS).toContain("window.swarmSdk = new SwarmSDK()");
+  });
+
+  test("routes calls through the /@swarm/api/* proxy", () => {
+    expect(BROWSER_SDK_JS).toContain("const base = '/@swarm/api'");
+    // Sentinel endpoints — one per domain.
+    expect(BROWSER_SDK_JS).toContain("'/tasks'");
+    expect(BROWSER_SDK_JS).toContain("'/agents'");
+    expect(BROWSER_SDK_JS).toContain("'/events'");
+    expect(BROWSER_SDK_JS).toContain("'/memory/search'");
+    expect(BROWSER_SDK_JS).toContain("'/repos'");
+    expect(BROWSER_SDK_JS).toContain("'/schedules'");
+    expect(BROWSER_SDK_JS).toContain("'/approval-requests'");
+    expect(BROWSER_SDK_JS).toContain("'/assets'");
+    expect(BROWSER_SDK_JS).toContain("'/assets/key-audit'");
+    expect(BROWSER_SDK_JS).toContain("'/assets/mappings'");
+  });
+
+  test("does not fetch on SDK load or construction", () => {
+    const fetchMock = mock(() => Promise.resolve(Response.json({})));
+    const window = {};
+    const loadSdk = new Function("window", "fetch", `${BROWSER_SDK_JS}\nreturn window.SwarmSDK;`);
+
+    const SwarmSDK = loadSdk(window, fetchMock);
+    expect(window).toHaveProperty("swarmSdk");
+    expect(fetchMock).not.toHaveBeenCalled();
+
+    new SwarmSDK();
+    new SwarmSDK();
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/src/tests/pages-feedback.test.ts

@@ -12,11 +12,11 @@ import {
   type Server,
   type ServerResponse,
 } from "node:http";
-import { feedbackOverlayScripts, isPageFeedbackRequested } from "../artifact-sdk/feedback-overlay";
 import { closeDb, createAgent, getTaskById, initDb } from "../be/db";
 import { handlePages } from "../http/pages";
 import { handlePagesPublic } from "../http/pages-public";
 import { getPathSegments, parseQueryParams } from "../http/utils";
+import { feedbackOverlayScripts, isPageFeedbackRequested } from "../pages/feedback-overlay";
 import { listenOnFreePort } from "./test-net";
 
 const TEST_DB_PATH = "./test-pages-feedback.sqlite";

package/src/tests/paused-tasks-requested-by.test.ts

@@ -0,0 +1,102 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createUser,
+  initDb,
+  pauseTask,
+  startTask,
+} from "../be/db";
+import { handleTasks } from "../http/tasks";
+
+const TEST_DB_PATH = "./test-paused-tasks-requested-by.sqlite";
+const AGENT_ID = "50000000-0000-4000-8000-000000000001";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+async function getPausedTasks(): Promise<{
+  status: number;
+  body: { tasks: Array<{ id: string; requestedBy?: Record<string, unknown> }> };
+}> {
+  let status = 200;
+  let bodyStr = "";
+  const req = {
+    method: "GET",
+    url: "/api/paused-tasks",
+    headers: { "x-agent-id": AGENT_ID },
+  } as unknown as Parameters<typeof handleTasks>[0];
+  const res = {
+    setHeader() {},
+    writeHead(code: number) {
+      status = code;
+    },
+    end(body?: string) {
+      bodyStr = body ?? "";
+    },
+  } as unknown as Parameters<typeof handleTasks>[1];
+  const handled = await handleTasks(
+    req,
+    res,
+    ["api", "paused-tasks"],
+    new URLSearchParams(),
+    AGENT_ID,
+  );
+  if (!handled) throw new Error("handleTasks did not handle the request");
+  return { status, body: JSON.parse(bodyStr) };
+}
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  await createAgent({ id: AGENT_ID, name: "Paused Worker", isLead: false, status: "idle" });
+});
+
+afterAll(async () => {
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+describe("GET /api/paused-tasks requester projection", () => {
+  test("carries the same requestedBy a task_assigned trigger carries", async () => {
+    const user = await createUser({
+      name: "Paused Requester",
+      email: "paused@example.com",
+      role: "CTO",
+      notes: "Paused requester notes",
+    });
+    const withUser = await createTaskExtended("Paused task with requester", {
+      agentId: AGENT_ID,
+      requestedByUserId: user.id,
+    });
+    const withoutUser = await createTaskExtended("Paused task without requester", {
+      agentId: AGENT_ID,
+    });
+    for (const task of [withUser, withoutUser]) {
+      await startTask(task.id);
+      expect(await pauseTask(task.id)).not.toBeNull();
+    }
+
+    const { status, body } = await getPausedTasks();
+    expect(status).toBe(200);
+    const byId = new Map(body.tasks.map((task) => [task.id, task]));
+    expect(byId.get(withUser.id)?.requestedBy).toMatchObject({
+      id: user.id,
+      name: "Paused Requester",
+      email: "paused@example.com",
+      role: "CTO",
+      notes: "Paused requester notes",
+    });
+    expect(byId.get(withoutUser.id)).toBeDefined();
+    expect(byId.get(withoutUser.id)?.requestedBy).toBeUndefined();
+  });
+});