@desplega.ai/agent-swarm 1.157.0 → 1.158.0

package/src/tests/apps-sync-engine.test.ts

@@ -26,7 +26,12 @@ import {
   withMutationLock,
 } from "../apps/row-store";
 import { createApp, getApp, updateApp } from "../apps/store";
-import { getAppSyncStatus, runAppSync, type SyncPassResult } from "../apps/sync";
+import {
+  getAppSyncStatus,
+  RECONCILE_CHUNK_SIZE,
+  runAppSync,
+  type SyncPassResult,
+} from "../apps/sync";
 import {
   closeDb,
   createAgent,
@@ -1277,17 +1282,20 @@ spawnDescribe("concurrency", () => {
   });
 
   test("a mid-pass write failure reports the committed churn instead of zero counts", async () => {
-    // Row writes are independent KV upserts, not a transaction: fail the
-    // SECOND create after the first already committed and the pass counts
-    // must say so instead of reporting the zero-count base.
-    const script = await fixtureScript("partial", [ghRecord(1), ghRecord(2)]);
+    // Rows are written in chunked transactions: fail the second create of the
+    // SECOND chunk after the first chunk committed. The pass counts must say
+    // so instead of reporting the zero-count base, and the failing chunk must
+    // roll back without leaving partial rows.
+    const total = RECONCILE_CHUNK_SIZE + 2;
+    const records = Array.from({ length: total }, (_, index) => ghRecord(index + 1));
+    const script = await fixtureScript("partial", records);
     const appId = await createSyncApp(issueDefinition(script.id));
 
     const realCreate = rowStore.createAppRowUnlocked;
     let creates = 0;
     const spy = spyOn(rowStore, "createAppRowUnlocked").mockImplementation((...callArgs) => {
       creates += 1;
-      if (creates === 2) throw new Error("kv write failed (injected)");
+      if (creates === RECONCILE_CHUNK_SIZE + 2) throw new Error("kv write failed (injected)");
       return realCreate(...callArgs);
     });
     try {
@@ -1296,9 +1304,12 @@ spawnDescribe("concurrency", () => {
 
       expect(result.ok).toBe(false);
       expect(pass.error).toContain("kv write failed (injected)");
-      expect(pass).toMatchObject({ pulled: 2, created: 1 });
-      expect((await rowsOf(appId)).map((row) => row.issueKey)).toEqual(["1"]);
-      expect(await getAppSyncStatus(appId, "issue", "gh")).toMatchObject({ ok: false, created: 1 });
+      expect(pass).toMatchObject({ pulled: total, created: RECONCILE_CHUNK_SIZE });
+      expect(await rowsOf(appId)).toHaveLength(RECONCILE_CHUNK_SIZE);
+      expect(await getAppSyncStatus(appId, "issue", "gh")).toMatchObject({
+        ok: false,
+        created: RECONCILE_CHUNK_SIZE,
+      });
     } finally {
       spy.mockRestore();
     }

package/src/tests/boot-seeds.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { ensurePricingSeeded, ensureRbacSeeded } from "../be/boot-seeds";
+import { closeDb, getDbClient, initDb } from "../be/db";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import { BUILTIN_ROLES } from "../be/rbac-roles";
+import { createServer } from "../server";
+
+const TEST_DB_PATH = "./test-boot-seeds.sqlite";
+const BUILTIN_ROLE_ID = "rbac-role-requester";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {
+      // File does not exist.
+    }
+  }
+}
+
+async function countPricingSeedRows(): Promise<number> {
+  const row = await getDbClient().get<{ n: number }>(
+    "SELECT COUNT(*) AS n FROM pricing WHERE effective_from = 0",
+  );
+  return row?.n ?? 0;
+}
+
+async function countBuiltinPermissions(): Promise<number> {
+  const row = await getDbClient().get<{ n: number }>(
+    "SELECT COUNT(*) AS n FROM role_permissions WHERE roleId = ?",
+    [BUILTIN_ROLE_ID],
+  );
+  return row?.n ?? 0;
+}
+
+// Fresh DB handle per test: the guards are keyed on the live handle.
+beforeEach(async () => {
+  closeDb();
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+});
+
+afterEach(() => {
+  closeDb();
+});
+
+afterAll(async () => {
+  await removeDbFiles();
+});
+
+describe("ensurePricingSeeded", () => {
+  test("seeds once per database handle, and again for a new handle", async () => {
+    ensurePricingSeeded();
+    const seeded = await countPricingSeedRows();
+    expect(seeded).toBeGreaterThan(0);
+
+    // A second call must not touch the table: wipe it and confirm it stays empty.
+    await getDbClient().run("DELETE FROM pricing WHERE effective_from = 0");
+    ensurePricingSeeded();
+    expect(await countPricingSeedRows()).toBe(0);
+
+    // Reopening the same file gives a new handle, which is seeded again.
+    closeDb();
+    initDb(TEST_DB_PATH);
+    ensurePricingSeeded();
+    expect(await countPricingSeedRows()).toBe(seeded);
+  });
+});
+
+describe("ensureRbacSeeded", () => {
+  test("syncs once per database handle, and again for a new handle", async () => {
+    ensureRbacSeeded();
+    const seeded = await countBuiltinPermissions();
+    expect(seeded).toBeGreaterThan(0);
+
+    await getDbClient().run("DELETE FROM role_permissions WHERE roleId = ?", [BUILTIN_ROLE_ID]);
+    ensureRbacSeeded();
+    expect(await countBuiltinPermissions()).toBe(0);
+
+    closeDb();
+    initDb(TEST_DB_PATH);
+    ensureRbacSeeded();
+    expect(await countBuiltinPermissions()).toBe(seeded);
+  });
+
+  test("a failed sync does not mark the handle done", async () => {
+    // Make the built-in role unrecoverable: its name is taken by another role id.
+    const builtin = BUILTIN_ROLES.find((role) => role.id === BUILTIN_ROLE_ID);
+    if (!builtin) throw new Error("test fixture: built-in role missing");
+    const client = getDbClient();
+    await client.run("PRAGMA foreign_keys = OFF");
+    await client.run("DELETE FROM roles WHERE id = ?", [BUILTIN_ROLE_ID]);
+    await client.run("PRAGMA foreign_keys = ON");
+    await client.run(
+      "INSERT INTO roles (id, name, description, isBuiltin, grantsAll) VALUES ('rbac-role-collision', ?, 'x', 0, 0)",
+      [builtin.name],
+    );
+
+    expect(() => ensureRbacSeeded()).toThrow(/already uses that name/);
+    // Not cached as done: the next caller retries and sees the same error.
+    expect(() => ensureRbacSeeded()).toThrow(/already uses that name/);
+
+    await client.run("DELETE FROM roles WHERE id = 'rbac-role-collision'");
+    ensureRbacSeeded();
+    expect(await countBuiltinPermissions()).toBeGreaterThan(0);
+  });
+});
+
+describe("createServer (one call per MCP session)", () => {
+  let savedDatabasePath: string | undefined;
+
+  beforeEach(() => {
+    savedDatabasePath = process.env.DATABASE_PATH;
+    process.env.DATABASE_PATH = TEST_DB_PATH;
+  });
+
+  afterEach(() => {
+    if (savedDatabasePath === undefined) delete process.env.DATABASE_PATH;
+    else process.env.DATABASE_PATH = savedDatabasePath;
+  });
+
+  test("seeds pricing and RBAC on the first session only", async () => {
+    await createServer();
+    expect(await countPricingSeedRows()).toBeGreaterThan(0);
+    expect(await countBuiltinPermissions()).toBeGreaterThan(0);
+
+    await getDbClient().run("DELETE FROM pricing WHERE effective_from = 0");
+    await getDbClient().run("DELETE FROM role_permissions WHERE roleId = ?", [BUILTIN_ROLE_ID]);
+
+    // A later session re-registers tools but must not re-run the seeds.
+    const second = await createServer();
+    expect(second).toBeDefined();
+    expect(await countPricingSeedRows()).toBe(0);
+    expect(await countBuiltinPermissions()).toBe(0);
+  });
+});
+
+describe("loadModelsDevCache", () => {
+  const saved = process.env.MODELSDEV_CACHE_PATH;
+  let dir: string | undefined;
+
+  afterEach(async () => {
+    if (saved === undefined) delete process.env.MODELSDEV_CACHE_PATH;
+    else process.env.MODELSDEV_CACHE_PATH = saved;
+    if (dir) await rm(dir, { recursive: true, force: true });
+    dir = undefined;
+  });
+
+  test("returns the same parsed object while it is alive", () => {
+    const first = loadModelsDevCache();
+    expect(first).not.toBeNull();
+    expect(loadModelsDevCache()).toBe(first);
+  });
+
+  test("keys the memo on the resolved path", async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "modelsdev-cache-"));
+    const alt = path.join(dir, "cache.json");
+    await writeFile(alt, JSON.stringify({ anthropic: { id: "anthropic-alt", models: {} } }));
+
+    const bundled = loadModelsDevCache();
+    process.env.MODELSDEV_CACHE_PATH = alt;
+    const overridden = loadModelsDevCache();
+
+    expect(overridden?.anthropic?.id).toBe("anthropic-alt");
+    expect(overridden).not.toBe(bundled);
+  });
+});

package/src/tests/cancel-approval-request-tool.test.ts

@@ -0,0 +1,115 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  closeDb,
+  createAgent,
+  createApprovalRequest,
+  createTaskExtended,
+  getApprovalRequestById,
+  getDbClient,
+  initDb,
+} from "../be/db";
+import { registerCancelApprovalRequestTool } from "../tools/cancel-approval-request";
+
+const TEST_DB_PATH = "./test-cancel-approval-request-tool.sqlite";
+
+type ToolResult = {
+  isError?: boolean;
+  structuredContent: { success: boolean; alreadyCancelled?: boolean; runCancelled?: boolean };
+};
+
+let callTool: (args: unknown, agentId: string) => Promise<ToolResult>;
+let leadId = "";
+let ownerId = "";
+let workerId = "";
+
+async function makeRequest() {
+  const sourceTask = await createTaskExtended("source", { agentId: ownerId, source: "mcp" });
+  const id = crypto.randomUUID();
+  await createApprovalRequest({
+    id,
+    title: "Tool cancel",
+    questions: [{ id: "q1", type: "approval", label: "Approve?", required: true }],
+    approvers: { policy: "any" },
+    sourceTaskId: sourceTask.id,
+  });
+  return id;
+}
+
+describe("cancel-approval-request tool", () => {
+  beforeAll(async () => {
+    initDb(TEST_DB_PATH);
+    leadId = (await createAgent({ name: "tool-lead", isLead: true, status: "idle" })).id;
+    ownerId = (await createAgent({ name: "tool-owner", isLead: false, status: "idle" })).id;
+    workerId = (await createAgent({ name: "tool-worker", isLead: false, status: "idle" })).id;
+    const server = new McpServer({ name: "cancel-approval-request-test", version: "1.0.0" });
+    registerCancelApprovalRequestTool(server);
+    const tool = (
+      server as unknown as {
+        _registeredTools: Record<
+          string,
+          { handler: (args: unknown, extra: unknown) => Promise<unknown> }
+        >;
+      }
+    )._registeredTools["cancel-approval-request"];
+    if (!tool) throw new Error("cancel-approval-request tool was not registered");
+    callTool = async (args, agentId) =>
+      (await tool.handler(args, {
+        sessionId: "cancel-approval-request-test",
+        requestInfo: { headers: { "x-agent-id": agentId } },
+      })) as ToolResult;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+    }
+  });
+
+  test("a lead cancels a pending request, then a second call is a no-op", async () => {
+    const requestId = await makeRequest();
+
+    const first = await callTool({ requestId, reason: "not needed" }, leadId);
+    expect(first.isError).toBeFalsy();
+    expect(first.structuredContent.alreadyCancelled).toBe(false);
+    const row = await getApprovalRequestById(requestId);
+    expect(row!.status).toBe("cancelled");
+    expect(row!.resolvedBy).toBe(leadId);
+    expect(row!.resolutionReason).toBe("not needed");
+
+    const second = await callTool({ requestId }, leadId);
+    expect(second.isError).toBeFalsy();
+    expect(second.structuredContent.alreadyCancelled).toBe(true);
+  });
+
+  test("a worker that does not own the source task gets a tool error", async () => {
+    const requestId = await makeRequest();
+
+    const result = await callTool({ requestId }, workerId);
+
+    expect(result.isError).toBe(true);
+    expect((await getApprovalRequestById(requestId))!.status).toBe("pending");
+  });
+
+  test("the owner agent may cancel", async () => {
+    const requestId = await makeRequest();
+    const result = await callTool({ requestId }, ownerId);
+    expect(result.isError).toBeFalsy();
+    expect((await getApprovalRequestById(requestId))!.status).toBe("cancelled");
+  });
+
+  test("an expired pending request gets a tool error and becomes timeout", async () => {
+    const requestId = await makeRequest();
+    await getDbClient().run("UPDATE approval_requests SET expiresAt = ? WHERE id = ?", [
+      new Date(Date.now() - 60_000).toISOString(),
+      requestId,
+    ]);
+
+    const result = await callTool({ requestId }, leadId);
+
+    expect(result.isError).toBe(true);
+    expect((await getApprovalRequestById(requestId))!.status).toBe("timeout");
+  });
+});

package/src/tests/claude-managed-adapter.test.ts

@@ -922,6 +922,12 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
       cacheReadPerMillion: 1.0,
       cacheWritePerMillion: 12.5,
     });
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5-5"]).toEqual({
+      inputPerMillion: 2.0,
+      outputPerMillion: 10.0,
+      cacheReadPerMillion: 0.2,
+      cacheWritePerMillion: 2.5,
+    });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5"]).toEqual({
       inputPerMillion: 2.0,
       outputPerMillion: 10.0,

package/src/tests/config-key-filter.test.ts

@@ -0,0 +1,80 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import { closeDb, initDb, upsertSwarmConfig } from "../be/db";
+import { handleConfig } from "../http/config";
+import { handleCore } from "../http/core";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+// ctx.swarm.config_get / config_list send `key` to these routes. Both used to
+// ignore it and return every row, so a script asking for one secret got all.
+
+const API_KEY = "example-config-key-filter-test-key";
+
+let server: Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  initDb(":memory:");
+  await upsertSwarmConfig({ scope: "global", key: "WANTED_KEY", value: "wanted" });
+  await upsertSwarmConfig({
+    scope: "global",
+    key: "OTHER_SECRET",
+    value: "other-secret-value",
+    isSecret: true,
+  });
+  await upsertSwarmConfig({ scope: "global", key: "PLAIN_KEY", value: "plain" });
+
+  server = createServer(async (req, res) => {
+    if (await handleCore(req, res, req.headers["x-agent-id"] as string | undefined, API_KEY)) {
+      return;
+    }
+    const segments = getPathSegments(req.url || "");
+    const query = parseQueryParams(req.url || "");
+    if (await handleConfig(req, res, segments, query)) return;
+    res.writeHead(404).end();
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+});
+
+async function getKeys(path: string): Promise<string[]> {
+  const response = await fetch(`${baseUrl}${path}`, {
+    headers: { Authorization: `Bearer ${API_KEY}` },
+  });
+  expect(response.status).toBe(200);
+  const body = (await response.json()) as { configs: Array<{ key: string }> };
+  return body.configs.map((config) => config.key);
+}
+
+const ALL_KEYS = ["OTHER_SECRET", "PLAIN_KEY", "WANTED_KEY"];
+
+describe.each([
+  ["/api/config/resolved", "?"],
+  ["/api/config", "?scope=global&"],
+])("GET %s key filter", (path, prefix) => {
+  test("?key=<existing> returns exactly that row", async () => {
+    expect(await getKeys(`${path}${prefix}key=WANTED_KEY&includeSecrets=true`)).toEqual([
+      "WANTED_KEY",
+    ]);
+  });
+
+  test("?key=<unknown> returns an empty list", async () => {
+    expect(await getKeys(`${path}${prefix}key=NO_SUCH_KEY&includeSecrets=true`)).toEqual([]);
+  });
+
+  test("no key returns every row", async () => {
+    expect((await getKeys(`${path}${prefix}includeSecrets=true`)).sort()).toEqual(ALL_KEYS);
+  });
+
+  test("an empty key is rejected instead of returning every row", async () => {
+    const response = await fetch(`${baseUrl}${path}${prefix}key=`, {
+      headers: { Authorization: `Bearer ${API_KEY}` },
+    });
+    expect(response.status).toBe(400);
+  });
+});

package/src/tests/context-window.test.ts

@@ -27,6 +27,7 @@ describe("getContextWindowSize", () => {
   });
 
   test("returns 1M for sonnet models", () => {
+    expect(getContextWindowSize("claude-sonnet-5-5")).toBe(1_000_000);
     expect(getContextWindowSize("claude-sonnet-5")).toBe(1_000_000);
     expect(getContextWindowSize("claude-sonnet-4-6")).toBe(1_000_000);
     expect(getContextWindowSize("sonnet")).toBe(1_000_000);

package/src/tests/db-client-busy-retry.test.ts

@@ -202,6 +202,102 @@ describe("db-client SQLITE_BUSY retry", () => {
     expect(Date.now() - started).toBeLessThan(500);
   });
 
+  describe("under the production 5000ms ambient busy_timeout", () => {
+    /** Largest gap between 5ms ticks while `work` runs: the longest the loop was frozen. */
+    async function maxLoopFreezeMs(work: () => Promise<unknown>): Promise<number> {
+      let last = performance.now();
+      let maxGap = 0;
+      const ticker = setInterval(() => {
+        const now = performance.now();
+        maxGap = Math.max(maxGap, now - last);
+        last = now;
+      }, 5);
+      try {
+        await work();
+        // One more tick so a freeze that ended on the last attempt is seen.
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      } finally {
+        clearInterval(ticker);
+      }
+      return maxGap;
+    }
+
+    beforeEach(() => {
+      main.exec("PRAGMA busy_timeout = 5000");
+    });
+
+    test("a contended write still succeeds via the async retry", async () => {
+      const released = holdWriteLock(300);
+      const freezeMs = await maxLoopFreezeMs(() =>
+        client.run("INSERT INTO items (name) VALUES (?)", ["contended"]),
+      );
+      await released;
+      const landed = await client.get<{ name: string }>(
+        "SELECT name FROM items WHERE name = 'contended'",
+      );
+      expect(landed?.name).toBe("contended");
+      // Every attempt spins at most attemptSpinMs (25ms) or finalAttemptSpinMs;
+      // the release happened during an async backoff sleep.
+      expect(freezeMs).toBeLessThan(1_000);
+    });
+
+    test("the final statement attempt spins finalAttemptSpinMs, not the ambient timeout", async () => {
+      const tight = createBunSqliteClient(() => main, {
+        maxWaitMs: 60,
+        backoffMs: [20, 20],
+        attemptSpinMs: 25,
+        finalAttemptSpinMs: 50,
+      });
+      // The holder releases on a timer, which cannot fire while the final
+      // attempt blocks the loop: pre-fix this froze for the full 5000ms.
+      const released = holdWriteLock(3_000);
+      let caught: unknown;
+      const startedAt = performance.now();
+      const freezeMs = await maxLoopFreezeMs(async () => {
+        try {
+          await tight.run("INSERT INTO items (name) VALUES (?)", ["never"]);
+        } catch (err) {
+          caught = err;
+        }
+      });
+      const wallMs = performance.now() - startedAt;
+      await released;
+      expect((caught as { code?: string }).code).toBe("SQLITE_BUSY");
+      expect(wallMs).toBeLessThan(2_000);
+      expect(freezeMs).toBeLessThan(1_000);
+      const row = main.query<{ timeout: number }, []>("PRAGMA busy_timeout").get();
+      expect(row?.timeout).toBe(5000);
+    });
+
+    test("the final BEGIN IMMEDIATE attempt spins finalAttemptSpinMs, not the ambient timeout", async () => {
+      const tight = createBunSqliteClient(() => main, {
+        maxWaitMs: 60,
+        backoffMs: [20, 20],
+        attemptSpinMs: 25,
+        finalAttemptSpinMs: 50,
+      });
+      const released = holdWriteLock(3_000);
+      let caught: unknown;
+      const startedAt = performance.now();
+      const freezeMs = await maxLoopFreezeMs(async () => {
+        try {
+          await tight.transaction(async (tx) => {
+            await tx.run("INSERT INTO items (name) VALUES (?)", ["never-tx"]);
+          });
+        } catch (err) {
+          caught = err;
+        }
+      });
+      const wallMs = performance.now() - startedAt;
+      await released;
+      expect((caught as { code?: string }).code).toBe("SQLITE_BUSY");
+      expect(wallMs).toBeLessThan(2_000);
+      expect(freezeMs).toBeLessThan(1_000);
+      const row = main.query<{ timeout: number }, []>("PRAGMA busy_timeout").get();
+      expect(row?.timeout).toBe(5000);
+    });
+  });
+
   test("reads proceed under an external write lock without needing the retry path", async () => {
     await client.run("INSERT INTO items (name) VALUES (?)", ["pre-existing"]);
     const released = holdWriteLock(150);

package/src/tests/db-client.test.ts

@@ -1,5 +1,5 @@
 import { Database } from "bun:sqlite";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -427,3 +427,62 @@ describe("db-client transactions on a shared WAL file (second connection)", () =
     expect(row?.n).toBe(11);
   });
 });
+
+describe("db-client slow statement warning", () => {
+  // A recursive CTE is pure CPU inside one driver call, so it blocks the
+  // event loop the same way a slow production query does.
+  const SLOW_SQL = `/* ${"padding ".repeat(40)} */ WITH RECURSIVE c(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM c WHERE x < ?) SELECT count(*) AS n FROM c WHERE ? IS NOT NULL`;
+  const SLOW_ROWS = 3_000_000;
+  const PARAM_SECRET = "param-value-that-must-not-be-logged";
+
+  const slowWarnings = (spy: ReturnType<typeof spyOn>): string[] =>
+    spy.mock.calls
+      .map((args) => String(args[0]))
+      .filter((line) => line.includes("[db-client] slow sync statement"));
+
+  test("logs a statement that blocked the loop past 100ms, with truncated SQL and no params", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const startedAt = performance.now();
+      const row = await client.get<{ n: number }>(SLOW_SQL, [SLOW_ROWS, PARAM_SECRET]);
+      const elapsedMs = performance.now() - startedAt;
+      expect(row?.n).toBe(SLOW_ROWS);
+      // Guard the premise: on a machine fast enough to finish under the
+      // threshold, the warning is correctly absent and this test says so.
+      expect(elapsedMs).toBeGreaterThan(100);
+      const lines = slowWarnings(warn);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toMatch(/blocked the event loop for \d+ms: \/\* padding/);
+      expect(lines[0]).not.toContain(PARAM_SECRET);
+      expect(lines[0]).not.toContain("WITH RECURSIVE");
+      expect(lines[0]?.endsWith("…")).toBe(true);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("logs a slow statement run inside a transaction", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await client.transaction(async (tx) => {
+        await tx.get(SLOW_SQL, [SLOW_ROWS, PARAM_SECRET]);
+      });
+      const lines = slowWarnings(warn);
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).not.toContain(PARAM_SECRET);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("does not log fast statements", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      await client.run("INSERT INTO items (name) VALUES (?)", ["fast"]);
+      await client.query("SELECT name FROM items");
+      expect(slowWarnings(warn)).toHaveLength(0);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});