@desplega.ai/agent-swarm 1.165.0 → 1.167.0

package/src/tests/boot-scrub-sweep.test.ts

@@ -0,0 +1,390 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  BOOT_SCRUB_TARGETS,
+  bootScrubCursorKey,
+  bootScrubDoneKey,
+  runBootScrubSweep,
+} from "../be/boot-scrub-sweep";
+import { closeDb, getDb, getDbClient, initDb, isSqliteVecAvailable } from "../be/db";
+import { getMemoryStore } from "../be/memory";
+import { contentSha256 } from "../commands/profile-sync";
+import {
+  refreshSecretScrubberCache,
+  registerVolatileSecret,
+  SCRUBBER_RULES_VERSION,
+} from "../utils/secret-scrubber";
+import { randomToken, type SyntheticSecret, syntheticSecret } from "./synthetic-secret-helpers";
+
+const TEST_DB_PATH = "./test-boot-scrub-sweep.sqlite";
+const AGENT_ID = "5c2b0000-0000-4000-8000-000000000001";
+// Distinctive non-secret words: FTS must still find the row by them after redaction.
+const MARKER_WORD = "quokkazebra";
+
+let known: SyntheticSecret;
+let envName: string;
+let envValue: string;
+let password: string;
+
+/** Text carrying all three secret forms: known value, env value and a `*_PASSWORD=` assignment. */
+function secretText(label: string): string {
+  return `${label} ${MARKER_WORD} token=${known.value} env=${envValue} X_DEMO_PASSWORD=${password} end`;
+}
+
+function expectRedacted(value: string | null | undefined, where: string): void {
+  expect(value, where).toBeString();
+  for (const secret of [known.value, envValue, password]) {
+    expect(value!.includes(secret), `${where} still holds a secret`).toBe(false);
+  }
+  expect(value!, where).toContain("[REDACTED:");
+}
+
+async function writeAudit(): Promise<{ tbl: string; id: string }[]> {
+  return getDbClient().query<{ tbl: string; id: string }>("SELECT tbl, id FROM scrub_write_audit");
+}
+
+async function ftsHits(term: string): Promise<string[]> {
+  const rows = await getDbClient().query<{ memory_id: string }>(
+    "SELECT memory_id FROM memory_fts WHERE memory_fts MATCH ?",
+    [`"${term}"`],
+  );
+  return rows.map((r) => r.memory_id);
+}
+
+const ids = {
+  log: crypto.randomUUID(),
+  logControl: crypto.randomUUID(),
+  task: crypto.randomUUID(),
+  taskControl: crypto.randomUUID(),
+  event: crypto.randomUUID(),
+  run: crypto.randomUUID(),
+  step: crypto.randomUUID(),
+  memory: "",
+};
+
+describe("boot retro-sweep", () => {
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    // workflow_run_steps.runId references workflow_runs; the sweep never
+    // touches FKs, so seed the step without building a whole workflow.
+    getDb().run("PRAGMA foreign_keys = OFF");
+
+    known = syntheticSecret("sweep");
+    envName = "X_DEMO_SWEEP_API_KEY";
+    envValue = randomToken(32);
+    process.env[envName] = envValue;
+    refreshSecretScrubberCache();
+    password = randomToken(24);
+
+    const db = getDbClient();
+    // Every UPDATE on a swept table lands here: proves untouched rows saw no write.
+    await db.run("CREATE TABLE scrub_write_audit (tbl TEXT NOT NULL, id TEXT NOT NULL)");
+    for (const { table } of BOOT_SCRUB_TARGETS) {
+      await db.run(
+        `CREATE TRIGGER audit_${table} AFTER UPDATE ON ${table}
+         BEGIN INSERT INTO scrub_write_audit (tbl, id) VALUES ('${table}', NEW.id); END`,
+      );
+    }
+
+    const now = new Date().toISOString();
+    await db.run(
+      `INSERT INTO session_logs (id, sessionId, iteration, content, lineNumber, createdAt)
+       VALUES (?, 's1', 1, ?, 1, ?), (?, 's1', 1, ?, 2, ?)`,
+      [ids.log, secretText("log"), now, ids.logControl, "plain log line, nothing to hide", now],
+    );
+    await db.run(
+      `INSERT INTO agent_tasks (id, task, output, failureReason, progress, createdAt, lastUpdatedAt)
+       VALUES (?, ?, ?, ?, ?, ?, ?), (?, 'control task', 'control output', NULL, NULL, ?, ?)`,
+      [
+        ids.task,
+        secretText("task"),
+        secretText("output"),
+        secretText("failure"),
+        secretText("progress"),
+        now,
+        now,
+        ids.taskControl,
+        now,
+        now,
+      ],
+    );
+    await db.run(
+      `INSERT INTO events (id, category, event, source, data, createdAt)
+       VALUES (?, 'test', 'test.event', 'test', ?, ?)`,
+      [ids.event, JSON.stringify({ note: secretText("event"), nested: { n: 1 } }), now],
+    );
+    await db.run(
+      `INSERT INTO workflow_run_steps (id, runId, nodeId, nodeType, input, output, error, diagnostics)
+       VALUES (?, ?, 'n1', 'agent-task', ?, ?, ?, ?)`,
+      [
+        ids.step,
+        ids.run,
+        JSON.stringify({ prompt: secretText("input") }),
+        JSON.stringify({ result: secretText("step-output") }),
+        secretText("error"),
+        JSON.stringify({ trace: secretText("diagnostics") }),
+      ],
+    );
+
+    const store = getMemoryStore();
+    const legacy = {
+      name: `note ${known.value}`,
+      content: secretText("memory"),
+      summary: secretText("summary"),
+    };
+    const memory = await store.store({
+      agentId: AGENT_ID,
+      scope: "agent",
+      source: "manual",
+      ...legacy,
+    });
+    ids.memory = memory.id;
+    // store() now scrubs at write; put the raw text back so the row looks like
+    // one written before that, which is what the sweep exists for.
+    await db.run(
+      "UPDATE agent_memory SET name = ?, content = ?, summary = ?, contentHash = ? WHERE id = ?",
+      [legacy.name, legacy.content, legacy.summary, contentSha256(legacy.content), memory.id],
+    );
+    await db.run(
+      "UPDATE agent_memory_version SET content = ?, contentHash = ? WHERE memory_id = ?",
+      [legacy.content, contentSha256(legacy.content), memory.id],
+    );
+    await db.run("DELETE FROM memory_fts WHERE memory_id = ?", [memory.id]);
+    await db.run("INSERT INTO memory_fts(memory_id, name, content) VALUES (?, ?, ?)", [
+      memory.id,
+      legacy.name,
+      legacy.content,
+    ]);
+    const embedding = new Float32Array(512);
+    embedding[0] = 1;
+    await store.updateEmbedding(memory.id, embedding, "test");
+  });
+
+  // The test preload clears volatile secrets after every test.
+  beforeEach(() => registerVolatileSecret(known.value, known.name));
+
+  afterAll(async () => {
+    delete process.env[envName];
+    known.cleanup();
+    refreshSecretScrubberCache();
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+  });
+
+  test("redacts every target column, keeps context, JSON and FTS, drops the stale vector", async () => {
+    const db = getDbClient();
+    // Positive controls: the secret is really in the index and the vector exists.
+    expect(await ftsHits(password)).toContain(ids.memory);
+    const before = await db.get<{ embedding: Uint8Array | null }>(
+      "SELECT embedding FROM agent_memory WHERE id = ?",
+      [ids.memory],
+    );
+    expect(before?.embedding).not.toBeNull();
+    if (isSqliteVecAvailable()) {
+      expect(
+        await db.get("SELECT memory_id FROM memory_vec WHERE memory_id = ?", [ids.memory]),
+      ).not.toBeNull();
+    }
+
+    const stats = await runBootScrubSweep({ version: SCRUBBER_RULES_VERSION, reembed: false });
+    expect(stats).not.toBeNull();
+    const byTable = Object.fromEntries(stats!.map((s) => [s.table, s]));
+    expect(byTable.session_logs!.changed).toBe(1);
+    expect(byTable.agent_tasks!.changed).toBe(1);
+    expect(byTable.agent_memory!.changed).toBe(1);
+    expect(byTable.agent_memory_version!.changed).toBe(1);
+    expect(byTable.events!.changed).toBe(1);
+    expect(byTable.workflow_run_steps!.changed).toBe(1);
+
+    const log = await db.get<{ content: string }>("SELECT content FROM session_logs WHERE id = ?", [
+      ids.log,
+    ]);
+    expectRedacted(log?.content, "session_logs.content");
+    expect(log!.content).toContain(MARKER_WORD);
+
+    const task = await db.get<Record<string, string>>(
+      "SELECT task, output, failureReason, progress FROM agent_tasks WHERE id = ?",
+      [ids.task],
+    );
+    for (const col of ["task", "output", "failureReason", "progress"]) {
+      expectRedacted(task?.[col], `agent_tasks.${col}`);
+    }
+
+    const mem = await db.get<{
+      name: string;
+      content: string;
+      summary: string;
+      contentHash: string;
+      embedding: Uint8Array | null;
+    }>("SELECT name, content, summary, contentHash, embedding FROM agent_memory WHERE id = ?", [
+      ids.memory,
+    ]);
+    expectRedacted(mem?.name, "agent_memory.name");
+    expectRedacted(mem?.content, "agent_memory.content");
+    expectRedacted(mem?.summary, "agent_memory.summary");
+    expect(mem!.contentHash).toBe(contentSha256(mem!.content));
+    expect(mem!.embedding).toBeNull();
+    if (isSqliteVecAvailable()) {
+      expect(
+        await db.get("SELECT memory_id FROM memory_vec WHERE memory_id = ?", [ids.memory]),
+      ).toBeNull();
+    }
+    // FTS was rewritten from the scrubbed text, not left stale.
+    expect(await ftsHits(MARKER_WORD)).toContain(ids.memory);
+    expect(await ftsHits(password)).not.toContain(ids.memory);
+
+    const version = await db.get<{ content: string; contentHash: string }>(
+      "SELECT content, contentHash FROM agent_memory_version WHERE memory_id = ?",
+      [ids.memory],
+    );
+    expectRedacted(version?.content, "agent_memory_version.content");
+    expect(version!.contentHash).toBe(contentSha256(version!.content));
+
+    const event = await db.get<{ data: string }>("SELECT data FROM events WHERE id = ?", [
+      ids.event,
+    ]);
+    expectRedacted(event?.data, "events.data");
+    const parsed = JSON.parse(event!.data) as { note: string; nested: { n: number } };
+    expect(parsed.nested.n).toBe(1);
+    expect(parsed.note).toContain(MARKER_WORD);
+
+    const step = await db.get<Record<string, string>>(
+      "SELECT input, output, error, diagnostics FROM workflow_run_steps WHERE id = ?",
+      [ids.step],
+    );
+    for (const col of ["input", "output", "error", "diagnostics"]) {
+      expectRedacted(step?.[col], `workflow_run_steps.${col}`);
+    }
+    for (const col of ["input", "output", "diagnostics"]) {
+      expect(() => JSON.parse(step![col]!)).not.toThrow();
+    }
+  });
+
+  test("control rows without a secret see no write", async () => {
+    const audit = await writeAudit();
+    // Positive control: the trigger fired for the rows that held a secret.
+    expect(audit).toContainEqual({ tbl: "session_logs", id: ids.log });
+    expect(audit).toContainEqual({ tbl: "agent_tasks", id: ids.task });
+    // The controls were never written.
+    expect(audit.map((a) => a.id)).not.toContain(ids.logControl);
+    expect(audit.map((a) => a.id)).not.toContain(ids.taskControl);
+    const control = await getDbClient().get<{ content: string }>(
+      "SELECT content FROM session_logs WHERE id = ?",
+      [ids.logControl],
+    );
+    expect(control?.content).toBe("plain log line, nothing to hide");
+  });
+
+  test("marks the version done and is a no-op on rerun; a new version runs again", async () => {
+    const db = getDbClient();
+    expect(
+      await db.get("SELECT key FROM seed_state WHERE kind = 'maintenance' AND key = ?", [
+        bootScrubDoneKey(SCRUBBER_RULES_VERSION),
+      ]),
+    ).not.toBeNull();
+    const cursors = await db.query("SELECT key FROM seed_state WHERE key LIKE 'boot-scrub-v%:%'");
+    expect(cursors).toHaveLength(0);
+
+    const auditBefore = (await writeAudit()).length;
+    expect(await runBootScrubSweep({ version: SCRUBBER_RULES_VERSION, reembed: false })).toBeNull();
+
+    const bumped = SCRUBBER_RULES_VERSION + 100;
+    const stats = await runBootScrubSweep({ version: bumped, reembed: false });
+    expect(stats).not.toBeNull();
+    expect(stats!.every((s) => s.changed === 0)).toBe(true);
+    expect(stats!.find((s) => s.table === "session_logs")!.scanned).toBeGreaterThanOrEqual(2);
+    expect((await writeAudit()).length).toBe(auditBefore);
+    expect(
+      await db.get("SELECT key FROM seed_state WHERE kind = 'maintenance' AND key = ?", [
+        bootScrubDoneKey(bumped),
+      ]),
+    ).not.toBeNull();
+  });
+
+  test("an interrupted run resumes from the cursor without rescanning batch 1", async () => {
+    const db = getDbClient();
+    const now = new Date().toISOString();
+    for (let i = 0; i < 5; i++) {
+      await db.run(
+        `INSERT INTO session_logs (id, sessionId, iteration, content, lineNumber, createdAt)
+         VALUES (?, 's2', 1, ?, ?, ?)`,
+        [crypto.randomUUID(), secretText(`resume-${i}`), 10 + i, now],
+      );
+    }
+    const version = SCRUBBER_RULES_VERSION + 200;
+    let firstBatch: string[] = [];
+    await expect(
+      runBootScrubSweep({
+        version,
+        batchSize: 2,
+        reembed: false,
+        afterBatch: ({ table, ids: batchIds }) => {
+          if (table !== "session_logs") return;
+          firstBatch = batchIds;
+          throw new Error("interrupted after batch 1");
+        },
+      }),
+    ).rejects.toThrow("interrupted after batch 1");
+    expect(firstBatch).toHaveLength(2);
+
+    const cursor = await db.get<{ seededHash: string }>(
+      "SELECT seededHash FROM seed_state WHERE kind = 'maintenance' AND key = ?",
+      [bootScrubCursorKey(version, "session_logs")],
+    );
+    expect(cursor?.seededHash).toBe(firstBatch[1]);
+    expect(
+      await db.get("SELECT key FROM seed_state WHERE key = ?", [bootScrubDoneKey(version)]),
+    ).toBeNull();
+
+    const resumed: string[] = [];
+    const stats = await runBootScrubSweep({
+      version,
+      batchSize: 2,
+      reembed: false,
+      afterBatch: ({ table, ids: batchIds }) => {
+        if (table === "session_logs") resumed.push(...batchIds);
+      },
+    });
+    expect(resumed.length).toBeGreaterThan(0);
+    for (const id of firstBatch) expect(resumed).not.toContain(id);
+    const total = await db.get<{ n: number }>("SELECT COUNT(*) AS n FROM session_logs");
+    expect(stats!.find((s) => s.table === "session_logs")!.scanned).toBe(total!.n - 2);
+
+    // Batch 1 was committed before the interrupt, the rest by the resumed run.
+    const remaining = await db.query<{ content: string }>(
+      "SELECT content FROM session_logs WHERE sessionId = 's2'",
+    );
+    for (const row of remaining) expectRedacted(row.content, "resumed session_logs.content");
+  });
+
+  test("skips a row whose scrub would break valid JSON", async () => {
+    const db = getDbClient();
+    const id = crypto.randomUUID();
+    const data = JSON.stringify({ msg: "BREAKJSON here" });
+    await db.run(
+      `INSERT INTO events (id, category, event, source, data, createdAt)
+       VALUES (?, 'test', 'test.event', 'test', ?, ?)`,
+      [id, data, new Date().toISOString()],
+    );
+    // Force a scrub result that is not valid JSON (an unbalanced quote).
+    const stats = await runBootScrubSweep({
+      version: SCRUBBER_RULES_VERSION + 300,
+      reembed: false,
+      scrub: (text) => text.replace("BREAKJSON", '"'),
+    });
+    const events = stats!.find((s) => s.table === "events")!;
+    expect(events.skippedInvalidJson).toBe(1);
+    expect(events.changed).toBe(0);
+    const row = await db.get<{ data: string }>("SELECT data FROM events WHERE id = ?", [id]);
+    expect(row?.data).toBe(data);
+  });
+});

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/ci-unit-test-report.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { buildPayload, parseJunit } from "../../scripts/ci-unit-test-report";
+
+// Shape emitted by `bun test --reporter=junit` (bun 1.4): one testsuite per file,
+// nested testsuites per describe, and attribute values XML-escaped.
+const JUNIT = `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="bun test" tests="6" assertions="5" failures="1" skipped="2" time="0.3">
+  <testsuite name="src/a.test.ts" file="src/a.test.ts" tests="4" failures="1" skipped="1" time="0.2">
+    <testsuite name="outer" file="src/a.test.ts" line="3" tests="4" time="0">
+      <testsuite name="inner &amp; &quot;nested&quot;" file="src/a.test.ts" line="4" tests="2" time="0">
+        <testcase name="slow one" classname="inner" time="0.120" file="src/a.test.ts" line="5" assertions="1" />
+        <testcase name="breaks &lt;sometimes&gt;" classname="inner" time="0.004" file="src/a.test.ts" line="6" assertions="1">
+          <failure type="AssertionError" message="expect(received).toBe(expected)&#10;">AssertionError&#10;</failure>
+        </testcase>
+      </testsuite>
+      <testcase name="fast" classname="outer" time="0.000010" file="src/a.test.ts" line="8" assertions="1" />
+      <testcase name="later" classname="outer" time="0" file="src/a.test.ts" line="9" assertions="0">
+        <skipped message="TODO" />
+      </testcase>
+    </testsuite>
+  </testsuite>
+  <testsuite name="src/b.test.ts" file="src/b.test.ts" tests="2" failures="0" skipped="1" time="0.1">
+    <testcase name="top level" classname="" time="0.06" file="src/b.test.ts" line="2" assertions="2" />
+    <testcase name="skipped" classname="" time="0" file="src/b.test.ts" line="3" assertions="0">
+      <skipped />
+    </testcase>
+  </testsuite>
+</testsuites>`;
+
+describe("ci-unit-test-report", () => {
+  test("parses describe chains, statuses, durations and XML entities", () => {
+    expect(parseJunit(JUNIT)).toEqual([
+      {
+        file: "src/a.test.ts",
+        name: 'outer > inner & "nested" > slow one',
+        ms: 120,
+        status: "pass",
+      },
+      {
+        file: "src/a.test.ts",
+        name: 'outer > inner & "nested" > breaks <sometimes>',
+        ms: 4,
+        status: "fail",
+      },
+      { file: "src/a.test.ts", name: "outer > fast", ms: 0, status: "pass" },
+      { file: "src/a.test.ts", name: "outer > later", ms: 0, status: "skip" },
+      { file: "src/b.test.ts", name: "top level", ms: 60, status: "pass" },
+      { file: "src/b.test.ts", name: "skipped", ms: 0, status: "skip" },
+    ]);
+  });
+
+  test("keeps every non-pass and every test at or above minMs, with per-file totals", () => {
+    const payload = buildPayload(parseJunit(JUNIT), new Map([["src/a.test.ts", "abc123"]]), 50);
+    expect(payload.totals).toEqual({ tests: 6, pass: 3, fail: 1, skip: 2, testMs: 184 });
+    expect(payload.files).toEqual([
+      ["src/a.test.ts", "abc123", 4, 1, 124],
+      ["src/b.test.ts", null, 2, 0, 60],
+    ]);
+    expect(payload.tests).toEqual([
+      [0, 'outer > inner & "nested" > slow one', 120, "p"],
+      [0, 'outer > inner & "nested" > breaks <sometimes>', 4, "f"],
+      [0, "outer > later", 0, "s"],
+      [1, "top level", 60, "p"],
+      [1, "skipped", 0, "s"],
+    ]);
+  });
+
+  test("an empty report parses to no tests", () => {
+    expect(
+      parseJunit('<?xml version="1.0"?><testsuites name="bun test" tests="0"></testsuites>'),
+    ).toEqual([]);
+  });
+});

package/src/tests/claude-default-route.test.ts

@@ -12,6 +12,7 @@ import {
 import {
   buildClaudeSessionEnvironment,
   checkClaudeCredentials,
+  claudeOpenRouterAttributionEnv,
   resolveClaudeBinaryArgv,
   withClaudeRouteEnv,
 } from "../providers/claude-adapter";
@@ -258,3 +259,77 @@ describe("internal-ai credential", () => {
     expect(cred?.kind).toBe("anthropic");
   });
 });
+
+describe("claude OpenRouter attribution", () => {
+  const OPENROUTER = {
+    ANTHROPIC_BASE_URL: "https://openrouter.ai/api",
+    ANTHROPIC_AUTH_TOKEN: "sk-or",
+  };
+  const ATTRIBUTION = [
+    "HTTP-Referer: https://agent-swarm.dev",
+    "X-OpenRouter-Title: Agent Swarm",
+    "X-OpenRouter-Categories: personal-agent,cloud-agent",
+  ];
+  const spawnEnv = (env: Record<string, string>) =>
+    buildClaudeSessionEnvironment(
+      {
+        taskId: crypto.randomUUID(),
+        agentId: crypto.randomUUID(),
+        env,
+        apiUrl: "http://fixture.invalid",
+        apiKey: "example-fixture-swarm-key",
+      } as ProviderSessionConfig,
+      "sonnet",
+      "/tmp/fixture-task",
+    ).env;
+
+  test("an openrouter.ai base URL appends the attribution headers", () => {
+    expect(spawnEnv(OPENROUTER).ANTHROPIC_CUSTOM_HEADERS).toBe(ATTRIBUTION.join("\n"));
+  });
+
+  test("the operator's header lines are kept in order; ours replace same-name lines", () => {
+    const env = spawnEnv({
+      ...OPENROUTER,
+      ANTHROPIC_CUSTOM_HEADERS:
+        "X-Gateway-Key: secret\nhttp-referer: https://mine.example\nX-Team: a",
+    });
+    expect(env.ANTHROPIC_CUSTOM_HEADERS).toBe(
+      ["X-Gateway-Key: secret", "X-Team: a", ...ATTRIBUTION].join("\n"),
+    );
+  });
+
+  test("unset, Anthropic, gateway and lookalike base URLs leave ANTHROPIC_CUSTOM_HEADERS byte-identical", () => {
+    const operator = "X-Gateway-Key: secret\n\nX-Team: a  ";
+    for (const base of [
+      {},
+      { ANTHROPIC_BASE_URL: "https://api.anthropic.com" },
+      { ANTHROPIC_BASE_URL: GATEWAY_URL },
+      { ANTHROPIC_BASE_URL: "https://openrouter.ai.evil.example/api" },
+      { ANTHROPIC_BASE_URL: "not a url" },
+    ]) {
+      expect(claudeOpenRouterAttributionEnv(base)).toEqual({});
+      expect(
+        spawnEnv({ ...base, ANTHROPIC_API_KEY: "sk-ant" }).ANTHROPIC_CUSTOM_HEADERS,
+      ).toBeUndefined();
+      expect(
+        spawnEnv({ ...base, ANTHROPIC_API_KEY: "sk-ant", ANTHROPIC_CUSTOM_HEADERS: operator })
+          .ANTHROPIC_CUSTOM_HEADERS,
+      ).toBe(operator);
+    }
+  });
+
+  test("OPENROUTER_APP_ATTRIBUTION=false leaves the operator's value untouched", () => {
+    for (const off of ["false", "0", "FALSE"]) {
+      expect(
+        spawnEnv({
+          ...OPENROUTER,
+          OPENROUTER_APP_ATTRIBUTION: off,
+          ANTHROPIC_CUSTOM_HEADERS: "X-A: b",
+        }).ANTHROPIC_CUSTOM_HEADERS,
+      ).toBe("X-A: b");
+      expect(
+        spawnEnv({ ...OPENROUTER, OPENROUTER_APP_ATTRIBUTION: off }).ANTHROPIC_CUSTOM_HEADERS,
+      ).toBe(undefined);
+    }
+  });
+});