@desplega.ai/agent-swarm 1.164.1 → 1.166.0

package/src/tests/check-pr-body.test.ts

@@ -3,6 +3,10 @@ import {
   checkPrBody,
   isFixTitle,
   pickedChoices,
+  prBodyWarnings,
+  proseWordCount,
+  riskLevel,
+  templateLeadLines,
   templateSections,
 } from "../../scripts/check-pr-body";
 
@@ -40,6 +44,13 @@ describe("check-pr-body", () => {
     ]);
   });
 
+  test("headings inside HTML comments or still-open fences are not sections", () => {
+    const hidden = "<!--\n## Intent\n-->\n````md\n```\n## Intent\n````\n";
+    expect(checkPrBody(TEMPLATE, `${hidden}${URGENT}`, "feat: x")).toEqual([
+      "missing section: ## Intent",
+    ]);
+  });
+
   test("fix titles are detected by conventional-commit type", () => {
     expect(isFixTitle("fix: x")).toBe(true);
     expect(isFixTitle("fix(slack): x")).toBe(true);
@@ -91,15 +102,147 @@ describe("check-pr-body", () => {
     expect(checkPrBody(TEMPLATE, body)).toEqual(["missing section: ## Urgency"]);
   });
 
-  test("the real template fails unedited and passes once every section is filled", async () => {
+  test("the real template fails unedited and passes once every part is filled", async () => {
     const template = await Bun.file(".github/pull_request_template.md").text();
+    const leads = templateLeadLines(template);
+    expect(leads).toEqual(["Why", "Risk"]);
     const sections = templateSections(template).filter((s) => s.when !== "optional");
     expect(sections.length).toBeGreaterThan(0);
-    expect(checkPrBody(template, template, "fix: x")).toHaveLength(sections.length);
+    const all = { title: "fix: x", author: "desplega-bot", changedFiles: ["apps/ui/a.tsx"] };
+    // Unknown risk keeps the outline required, so every section and lead line is reported.
+    expect(checkPrBody(template, template, all)).toHaveLength(sections.length + leads.length);
+
+    const filled = [
+      "**Why:** because.",
+      "**Risk:** medium",
+      ...sections.map(
+        (s) => `## ${s.heading}\n\n${s.choices.length ? `- [x] ${s.choices[0]}` : "filled"}\n`,
+      ),
+    ].join("\n");
+    expect(checkPrBody(template, filled, all)).toEqual([]);
+  });
+
+  test("the real template's markers", async () => {
+    const template = await Bun.file(".github/pull_request_template.md").text();
+    const when = Object.fromEntries(templateSections(template).map((s) => [s.heading, s.when]));
+    expect(when).toMatchObject({
+      "Review map": "always",
+      "Change outline": "outline",
+      "Before / after": "ui",
+      Repro: "fix",
+      Urgency: "always",
+      "Swarm provenance": "bot",
+    });
+  });
+});
+
+describe("check-pr-body: lead lines, risk and conditional sections", () => {
+  const T = `<!-- top -->
+
+**Why:** <!-- one sentence -->
+
+**Risk:** <!-- low | medium | high -->
+
+## Outline <!-- outline -->
+
+<!-- g -->
+
+## Before / after <!-- ui -->
+
+<!-- g -->
+
+## Swarm provenance <!-- bot -->
+
+<!-- g -->
+`;
+  const human = { author: "octocat" };
+  const leads = (risk: string) => `**Why:** It broke.\n\n**Risk:** ${risk}\n\n`;
+  const outline = "## Outline\n\n```\n+ new\n```\n";
+
+  test("lead lines are read from the template preamble", () => {
+    expect(templateLeadLines(T)).toEqual(["Why", "Risk"]);
+  });
+
+  test("the Why and Risk lines are required and Risk must be a known level", () => {
+    expect(checkPrBody(T, outline, human)).toEqual([
+      "missing line: **Why:**",
+      "missing line: **Risk:**",
+    ]);
+    expect(checkPrBody(T, `**Why:**\n**Risk:** <!-- x -->\n${outline}`, human)).toEqual([
+      "empty line: **Why:**",
+      "empty line: **Risk:**",
+    ]);
+    expect(checkPrBody(T, `${leads("spicy")}${outline}`, human)).toEqual([
+      "**Risk:** must start with one of: low, medium, high",
+    ]);
+    expect(checkPrBody(T, `${leads("High (secrets)")}${outline}`, human)).toEqual([]);
+  });
+
+  test("a lead line after the first heading does not count", () => {
+    expect(checkPrBody(T, `${outline}\n**Why:** x\n**Risk:** low\n`, human)).toContain(
+      "missing line: **Why:**",
+    );
+  });
+
+  test("riskLevel parses the first word only", () => {
+    expect(riskLevel("**Risk:** high (secrets)")).toBe("high");
+    expect(riskLevel("**Risk:** medium")).toBe("medium");
+    expect(riskLevel("**Risk:** lowish")).toBeUndefined();
+    expect(riskLevel("no risk line")).toBeUndefined();
+  });
+
+  test("the outline may be skipped only when Risk is low and the diff is small", () => {
+    const missing = ["missing section: ## Outline"];
+    expect(checkPrBody(T, leads("medium"), { ...human, changedLines: 3 })).toEqual(missing);
+    expect(checkPrBody(T, leads("low"), { ...human, changedLines: 51 })).toEqual(missing);
+    expect(checkPrBody(T, leads("low"), { ...human, changedLines: 50 })).toEqual([]);
+    expect(checkPrBody(T, leads("low"), human)).toEqual([]);
+  });
+
+  test("Before / after is required only when the diff touches a UI app", () => {
+    const body = `${leads("medium")}${outline}`;
+    const missing = ["missing section: ## Before / after"];
+    expect(checkPrBody(T, body, { ...human, changedFiles: ["apps/ui/src/App.tsx"] })).toEqual(
+      missing,
+    );
+    expect(checkPrBody(T, body, { ...human, changedFiles: ["apps/templates-ui/x.ts"] })).toEqual(
+      missing,
+    );
+    expect(checkPrBody(T, body, { ...human, changedFiles: ["src/apps/ui-thing.ts"] })).toEqual([]);
+    expect(checkPrBody(T, body, human)).toEqual([]);
+  });
+
+  test("Swarm provenance is required for the bot and for a local run without an author", () => {
+    const body = `${leads("medium")}${outline}`;
+    const missing = ["missing section: ## Swarm provenance"];
+    expect(checkPrBody(T, body, { author: "desplega-bot" })).toEqual(missing);
+    expect(checkPrBody(T, body, {})).toEqual(missing);
+    expect(checkPrBody(T, body, human)).toEqual([]);
+    const withProvenance = `${body}\n## Swarm provenance\n- Task: link\n`;
+    expect(checkPrBody(T, withProvenance, { author: "desplega-bot" })).toEqual([]);
+  });
+});
+
+describe("check-pr-body: prose budget", () => {
+  test("code fences, tables, details, comments, headings and URLs do not count", () => {
+    const body = [
+      "**Why:** three words here.",
+      "## Review map",
+      "| Area | Depth | Why |",
+      "|---|---|---|",
+      "```",
+      "lots of code words here",
+      "```",
+      "<details>hidden words here</details>",
+      "<!-- hidden comment words -->",
+      "See https://example.com/a/b and #12.",
+    ].join("\n");
+    // "**Why:**", "three", "words", "here.", "See", "and". "#12." has no letter.
+    expect(proseWordCount(body)).toBe(6);
+  });
 
-    const filled = sections
-      .map((s) => `## ${s.heading}\n\n${s.choices.length ? `- [x] ${s.choices[0]}` : "filled"}\n`)
-      .join("\n");
-    expect(checkPrBody(template, filled, "fix: x")).toEqual([]);
+  test("a long body warns but never fails", () => {
+    expect(prBodyWarnings("word ".repeat(300))).toEqual([]);
+    expect(prBodyWarnings("word ".repeat(301))).toHaveLength(1);
   });
 });

package/src/tests/check-text-columns.test.ts

@@ -0,0 +1,145 @@
+import { Database } from "bun:sqlite";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  checkTextColumns,
+  listTextColumns,
+  TEXT_COLUMNS_PATH,
+  type TextColumnClassification,
+} from "../../scripts/check-text-columns";
+import {
+  closeDb,
+  createAgent,
+  createTask,
+  getDbClient,
+  initDb,
+  updateTaskProgress,
+} from "../be/db";
+import { runMigrations } from "../be/migrations/runner";
+import { type SyntheticSecret, syntheticSecret } from "./synthetic-secret-helpers";
+
+const repoRoot = join(import.meta.dir, "..", "..");
+
+async function loadCommitted(): Promise<TextColumnClassification> {
+  return (await Bun.file(join(repoRoot, TEXT_COLUMNS_PATH)).json()) as TextColumnClassification;
+}
+
+describe("TEXT-column classification check", () => {
+  let db: Database;
+
+  beforeAll(() => {
+    db = new Database(":memory:");
+    const originalLog = console.log;
+    console.log = () => {};
+    try {
+      runMigrations(db);
+    } finally {
+      console.log = originalLog;
+    }
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  test("the committed classification covers the migrated schema exactly", async () => {
+    const classification = await loadCommitted();
+    expect(listTextColumns(db).length).toBeGreaterThan(100);
+    expect(checkTextColumns(db, classification)).toEqual([]);
+  });
+
+  test("a new TEXT column from a later migration fails until it is classified", async () => {
+    const classification = await loadCommitted();
+    const scratch = new Database(":memory:");
+    try {
+      const originalLog = console.log;
+      console.log = () => {};
+      try {
+        runMigrations(scratch);
+      } finally {
+        console.log = originalLog;
+      }
+      // Stand-in for a future migration that adds a free-text sink.
+      scratch.run("CREATE TABLE canary_notes (id TEXT PRIMARY KEY, body TEXT NOT NULL, n INTEGER)");
+
+      const violations = checkTextColumns(scratch, classification);
+      expect(violations).toEqual([
+        "canary_notes.id: unclassified TEXT column",
+        "canary_notes.body: unclassified TEXT column",
+      ]);
+
+      const classified: TextColumnClassification = {
+        ...classification,
+        canary_notes: { id: { exempt: "identifier" }, body: { pending: "test batch" } },
+      };
+      expect(checkTextColumns(scratch, classified)).toEqual([]);
+    } finally {
+      scratch.close();
+    }
+  });
+
+  test("stale and malformed entries are rejected", async () => {
+    const classification = await loadCommitted();
+    const firstTable = Object.keys(classification)[0] as string;
+    const firstColumn = Object.keys(classification[firstTable] ?? {})[0] as string;
+    const bad = {
+      ...classification,
+      [firstTable]: { ...classification[firstTable], [firstColumn]: { exempt: "" } },
+      gone_table: { note: "scrubbed" },
+    } as TextColumnClassification;
+
+    const violations = checkTextColumns(db, bad);
+    expect(violations).toContain("gone_table.note: stale entry, no such TEXT column");
+    expect(
+      violations.some((v) => v.startsWith(`${firstTable}.${firstColumn}: invalid entry`)),
+    ).toBe(true);
+  });
+});
+
+describe("ScrubbedText at a production writer", () => {
+  const dbPath = "./test-check-text-columns-writer.sqlite";
+  let secret: SyntheticSecret;
+
+  async function removeDbFiles(): Promise<void> {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(dbPath + suffix);
+      } catch {}
+    }
+  }
+
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(dbPath);
+    secret = syntheticSecret("textcol");
+  });
+
+  afterAll(async () => {
+    secret.cleanup();
+    closeDb();
+    await removeDbFiles();
+  });
+
+  test("a column classified scrubbed holds no secret after its real writer runs", async () => {
+    const committed = await loadCommitted();
+    expect(committed.agent_tasks?.progress).toBe("scrubbed");
+
+    const agent = await createAgent({
+      name: "text-columns-writer",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = await createTask(agent.id, "classification writer check");
+    await updateTaskProgress(task.id, `step 2 of 3 token=${secret.value} done`);
+
+    const row = await getDbClient().get<{ progress: string }>(
+      "SELECT progress FROM agent_tasks WHERE id = ?",
+      [task.id],
+    );
+    expect(row?.progress).toContain("step 2 of 3");
+    expect(row?.progress).toContain(`[REDACTED:${secret.name}]`);
+    expect(row?.progress.includes(secret.value)).toBe(false);
+  });
+});

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

@@ -639,7 +639,7 @@ describe("preseedClaudeTrustDialog", () => {
     const data = JSON.parse(await readFile(join(homeDir, ".claude.json"), "utf-8"));
     expect(data.projects["/a"].hasTrustDialogAccepted).toBe(true);
     expect(data.projects["/b"].hasTrustDialogAccepted).toBe(true);
-    expect(await readdir(homeDir)).toEqual([".claude.json", ".claude.json.swarm-lock"]);
+    expect((await readdir(homeDir)).sort()).toEqual([".claude.json", ".claude.json.swarm-lock"]);
   });
 
   test("many writers on an expired mkdir lock keep every entry of every round", async () => {

package/src/tests/claude-sdk-process.fixture.ts

@@ -1,3 +1,5 @@
+import { rename } from "node:fs/promises";
+
 const mode = process.env.CLAUDE_SDK_FIXTURE_MODE;
 const stateFile = process.env.CLAUDE_SDK_FIXTURE_STATE_FILE;
 const sessionId = "11111111-1111-4111-8111-111111111111";
@@ -13,6 +15,15 @@ if (!mode || !stateFile) {
   process.exit(2);
 }
 
+// The test polls for the state file and parses it as soon as it exists.
+// Bun.write creates the file before filling it, so write-then-rename keeps
+// the reader from ever seeing an empty file.
+async function writeStateFile(path: string, state: Record<string, unknown>): Promise<void> {
+  const temporaryPath = `${path}.tmp`;
+  await Bun.write(temporaryPath, JSON.stringify(state));
+  await rename(temporaryPath, path);
+}
+
 function writeMessage(message: Record<string, unknown>): void {
   console.log(JSON.stringify(message));
 }
@@ -145,7 +156,7 @@ if (mode === "cancel") {
     stdout: "ignore",
     stderr: "ignore",
   });
-  await Bun.write(stateFile, JSON.stringify({ fixturePid: process.pid, childPid: child.pid }));
+  await writeStateFile(stateFile, { fixturePid: process.pid, childPid: child.pid });
 }
 
 async function handleLine(line: string): Promise<boolean> {
@@ -191,7 +202,7 @@ async function handleLine(line: string): Promise<boolean> {
   }
 
   if (mode !== "queue" || userMessages.length < 3) return false;
-  await Bun.write(stateFile, JSON.stringify({ argv, userMessages }));
+  await writeStateFile(stateFile, { argv, userMessages });
   for (let index = 0; index < userMessages.length; index++) {
     const turn = index + 1;
     writeMessage(assistantMessage(`accepted:${userMessages[index]}`, turn));

package/src/tests/codex-oauth-device.test.ts

@@ -1,15 +1,8 @@
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
 import { createServer, type Server } from "node:http";
 import { decryptSecret, encryptSecret, getEncryptionKey } from "../be/crypto";
-import {
-  closeDb,
-  getDbClient,
-  getKv,
-  getSwarmConfigs,
-  initDb,
-  upsertKv,
-  upsertSwarmConfig,
-} from "../be/db";
+import { closeDb, getDbClient, getSwarmConfigs, initDb, upsertSwarmConfig } from "../be/db";
+import { getCodexDeviceFlow, upsertCodexDeviceFlow } from "../be/db/codex-oauth-device-flows";
 import type { OnboardingState } from "../be/onboarding";
 import { handleCodexOAuthDevice } from "../http/codex-oauth-device";
 import { handleCore } from "../http/core";
@@ -97,7 +90,7 @@ afterAll(async () => {
 });
 
 beforeEach(async () => {
-  await getDbClient().run("DELETE FROM kv_entries");
+  await getDbClient().run("DELETE FROM codex_oauth_device_flows");
   await getDbClient().run("DELETE FROM swarm_config");
   fetchImpl = async () => {
     throw new Error("Unexpected fetch");
@@ -221,8 +214,8 @@ describe("Codex device HTTP routes", () => {
 
     const started = await startFlow();
     expect(Number.isNaN(Date.parse(started.expiresAt))).toBe(false);
-    const encrypted = await getKv("codex-oauth-device", started.flowId);
-    expect(encrypted?.value).not.toContain("device-auth-full");
+    const encrypted = await getCodexDeviceFlow(started.flowId);
+    expect(encrypted?.state).not.toContain("device-auth-full");
 
     const poll = await request(`/api/codex-oauth/device/${started.flowId}/poll`);
     expect(await poll.json()).toEqual({ status: "complete", slot: 1 });
@@ -318,17 +311,15 @@ describe("Codex device HTTP routes", () => {
     const secondResponse = await request(path);
     const secondBody = await secondResponse.json();
     const callsBeforeRelease = { pollCalls, exchangeCalls };
-    const entry = await getKv("codex-oauth-device", started.flowId);
-    const state = JSON.parse(decryptSecret(String(entry!.value), getEncryptionKey())) as Record<
+    const entry = await getCodexDeviceFlow(started.flowId);
+    const state = JSON.parse(decryptSecret(entry!.state, getEncryptionKey())) as Record<
       string,
       unknown
     >;
     state.pollLeaseExpiresAt = Date.now() - 1;
-    await upsertKv({
-      namespace: "codex-oauth-device",
-      key: started.flowId,
-      value: encryptSecret(JSON.stringify(state), getEncryptionKey()),
-      valueType: "string",
+    await upsertCodexDeviceFlow({
+      flowId: started.flowId,
+      state: encryptSecret(JSON.stringify(state), getEncryptionKey()),
       expiresAt: Number(state.expiresAt),
     });
     releaseExchange();
@@ -359,19 +350,17 @@ describe("Codex device HTTP routes", () => {
     }) as typeof fetch;
 
     const started = await startFlow();
-    const entry = await getKv("codex-oauth-device", started.flowId);
-    const state = JSON.parse(decryptSecret(String(entry!.value), getEncryptionKey())) as Record<
+    const entry = await getCodexDeviceFlow(started.flowId);
+    const state = JSON.parse(decryptSecret(entry!.state, getEncryptionKey())) as Record<
       string,
       unknown
     >;
     state.lastPolledAt = Date.now() - 10_000;
     state.pollLeaseId = crypto.randomUUID();
     state.pollLeaseExpiresAt = Date.now() - 1;
-    await upsertKv({
-      namespace: "codex-oauth-device",
-      key: started.flowId,
-      value: encryptSecret(JSON.stringify(state), getEncryptionKey()),
-      valueType: "string",
+    await upsertCodexDeviceFlow({
+      flowId: started.flowId,
+      state: encryptSecret(JSON.stringify(state), getEncryptionKey()),
       expiresAt: Number(state.expiresAt),
     });
 
@@ -380,9 +369,9 @@ describe("Codex device HTTP routes", () => {
     });
     expect(pollCalls).toBe(1);
 
-    const recovered = await getKv("codex-oauth-device", started.flowId);
+    const recovered = await getCodexDeviceFlow(started.flowId);
     const recoveredState = JSON.parse(
-      decryptSecret(String(recovered!.value), getEncryptionKey()),
+      decryptSecret(recovered!.state, getEncryptionKey()),
     ) as Record<string, unknown>;
     expect(recoveredState.pollLeaseId).toBeNull();
     expect(recoveredState.pollLeaseExpiresAt).toBeNull();
@@ -403,17 +392,15 @@ describe("Codex device HTTP routes", () => {
     }) as typeof fetch;
 
     const started = await startFlow();
-    const entry = await getKv("codex-oauth-device", started.flowId);
-    const state = JSON.parse(decryptSecret(String(entry!.value), getEncryptionKey())) as Record<
+    const entry = await getCodexDeviceFlow(started.flowId);
+    const state = JSON.parse(decryptSecret(entry!.state, getEncryptionKey())) as Record<
       string,
       unknown
     >;
     state.expiresAt = Date.now() - 1;
-    await upsertKv({
-      namespace: "codex-oauth-device",
-      key: started.flowId,
-      value: encryptSecret(JSON.stringify(state), getEncryptionKey()),
-      valueType: "string",
+    await upsertCodexDeviceFlow({
+      flowId: started.flowId,
+      state: encryptSecret(JSON.stringify(state), getEncryptionKey()),
       expiresAt: Number(state.expiresAt),
     });
 
@@ -482,8 +469,7 @@ describe("Codex device HTTP routes", () => {
     }) as typeof fetch;
     await getDbClient().run(
       `CREATE TRIGGER fail_device_flow_write
-       BEFORE INSERT ON kv_entries
-       WHEN NEW.namespace = 'codex-oauth-device'
+       BEFORE INSERT ON codex_oauth_device_flows
        BEGIN
          SELECT RAISE(ABORT, 'forced local write failure');
        END`,

package/src/tests/codex-oauth-keep-warm.test.ts

@@ -255,6 +255,35 @@ describe("POST /api/oauth/keep-warm/codex", () => {
     expect(body.results).toEqual([]);
   });
 
+  it("loads slots through MCP_BASE_URL, not the public base URL", async () => {
+    const savedMcp = process.env.MCP_BASE_URL;
+    const savedPublic = process.env.PUBLIC_MCP_BASE_URL;
+    process.env.MCP_BASE_URL = "http://swarm-internal.example.test:3013";
+    process.env.PUBLIC_MCP_BASE_URL = "https://swarm-public.example.test";
+    installMockTransport(new Map());
+    const transport = globalThis.fetch;
+    const requested: string[] = [];
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      requested.push(typeof url === "string" ? url : url.toString());
+      return transport(url, init);
+    }) as typeof fetch;
+
+    try {
+      const { req, res, captured } = fakeReqRes();
+      await handleCodexOAuthKeepWarm(req, res, ["api", "oauth", "keep-warm", "codex"]);
+
+      expect(captured.status).toBe(200);
+      const configLoad = requested.find((u) => u.includes("/api/config/resolved"));
+      expect(configLoad).toBeDefined();
+      expect(new URL(configLoad as string).origin).toBe("http://swarm-internal.example.test:3013");
+    } finally {
+      if (savedMcp === undefined) delete process.env.MCP_BASE_URL;
+      else process.env.MCP_BASE_URL = savedMcp;
+      if (savedPublic === undefined) delete process.env.PUBLIC_MCP_BASE_URL;
+      else process.env.PUBLIC_MCP_BASE_URL = savedPublic;
+    }
+  });
+
   it("does not match unrelated paths", async () => {
     const { req, res } = fakeReqRes();
     const handled = await handleCodexOAuthKeepWarm(req, res, [

package/src/tests/console-scrub.test.ts

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { inspect } from "node:util";
+import { installConsoleLogBridge, uninstallConsoleLogBridge } from "../otel-impl";
+import { installConsoleScrub, uninstallConsoleScrub } from "../utils/console-scrub";
+
+// Built at runtime so no secret-shaped literal sits in the repo.
+const SECRET = `ghp_${"Q".repeat(36)}`;
+const REDACTED = "[REDACTED:";
+
+const METHODS = ["log", "info", "warn", "error", "debug"] as const;
+type Method = (typeof METHODS)[number];
+
+let saved: Record<Method, (...args: unknown[]) => void>;
+let written: { method: Method; args: unknown[] }[];
+
+// Stand-ins for the underlying stream writers; the scrub wraps these.
+beforeEach(() => {
+  written = [];
+  saved = { ...console } as typeof saved;
+  for (const method of METHODS) {
+    console[method] = (...args: unknown[]) => {
+      written.push({ method, args });
+    };
+  }
+});
+
+afterEach(() => {
+  uninstallConsoleLogBridge();
+  uninstallConsoleScrub();
+  for (const method of METHODS) console[method] = saved[method];
+});
+
+function lastLine(): string {
+  const entry = written.at(-1);
+  if (!entry) throw new Error("nothing written");
+  expect(entry.args).toHaveLength(1);
+  return entry.args[0] as string;
+}
+
+describe("installConsoleScrub", () => {
+  test("redacts strings, Error message and stack, and objects on every method", () => {
+    installConsoleScrub();
+    for (const method of METHODS) {
+      console[method]("token is", SECRET);
+      const line = lastLine();
+      expect(written.at(-1)?.method).toBe(method);
+      expect(line).toStartWith("token is ");
+      expect(line).not.toContain(SECRET);
+      expect(line).toContain(REDACTED);
+    }
+
+    const err = new Error(`auth failed with ${SECRET}`);
+    console.error("boom:", err);
+    const errLine = lastLine();
+    expect(errLine).toContain("auth failed with");
+    expect(errLine).toContain("console-scrub.test.ts"); // the stack survived
+    expect(errLine).not.toContain(SECRET);
+    expect(errLine).toContain(REDACTED);
+
+    console.log({ service: "github", nested: { value: SECRET } });
+    const objLine = lastLine();
+    expect(objLine).toContain("github");
+    expect(objLine).not.toContain(SECRET);
+    expect(objLine).toContain(REDACTED);
+  });
+
+  test("keeps printf-style substitution", () => {
+    installConsoleScrub();
+    console.log("%s has %d items and key %s", "queue", 3, SECRET);
+    const line = lastLine();
+    expect(line).toStartWith("queue has 3 items and key ");
+    expect(line).not.toContain(SECRET);
+    expect(line).not.toContain("%s");
+  });
+
+  test("a second install is a no-op", () => {
+    installConsoleScrub();
+    const wrapped = console.log;
+    installConsoleScrub();
+    expect(console.log).toBe(wrapped);
+    uninstallConsoleScrub();
+    console.log("plain", SECRET);
+    expect(written.at(-1)?.args).toEqual(["plain", SECRET]);
+  });
+
+  test("an OTel bridge installed afterwards forwards only scrubbed text", () => {
+    installConsoleScrub();
+    installConsoleLogBridge();
+    console.warn(`leaked ${SECRET}`);
+    const line = lastLine();
+    expect(line).not.toContain(SECRET);
+    expect(line).toContain(REDACTED);
+  });
+
+  test("a log written by a custom inspector during formatting fails closed", () => {
+    installConsoleScrub();
+    const noisy = {
+      [inspect.custom]() {
+        console.log("nested", SECRET);
+        return "noisy-object";
+      },
+    };
+    console.log("outer", noisy);
+    expect(written).toHaveLength(2);
+    const [nested, outer] = written.map((entry) => entry.args);
+    expect(nested).toEqual([
+      "[console-scrub] suppressed a log line written while formatting another",
+    ]);
+    expect(outer).toEqual(["outer noisy-object"]);
+    expect(JSON.stringify(written)).not.toContain(SECRET);
+  });
+
+  test("a formatting throw writes a fixed line, never the raw arguments", () => {
+    installConsoleScrub();
+    const broken = {
+      [inspect.custom]() {
+        throw new Error(`inspector failed near ${SECRET}`);
+      },
+    };
+    console.error("payload", SECRET, broken);
+    expect(written).toHaveLength(1);
+    expect(written[0]?.args).toEqual(["[console-scrub] failed to scrub log line"]);
+    expect(JSON.stringify(written)).not.toContain(SECRET);
+  });
+
+  test("zero arguments still print an empty line", () => {
+    installConsoleScrub();
+    console.log();
+    expect(written.at(-1)?.args).toEqual([]);
+  });
+
+  test("10k lines stay cheap", () => {
+    installConsoleScrub();
+    const started = performance.now();
+    for (let i = 0; i < 10_000; i++) console.log(`[worker] polling task ${i}`, { attempt: i });
+    const elapsedMs = performance.now() - started;
+    expect(written).toHaveLength(10_000);
+    // Generous bound for slow CI runners; measured about 450 ms in a worker container.
+    expect(elapsedMs).toBeLessThan(3_000);
+  });
+});