create-ailk 0.5.0 → 0.6.0

package/templates/apps/api/src/services/__tests__/audit-log.test.ts

@@ -0,0 +1,620 @@
+/**
+ * @file audit-log.test.ts
+ * @description Unit tests for the agent-action audit writer (#6040,
+ * REL-017 row 5 / FEAT-084 SUB-096), scored against docs/specs/6040-one-auditlog-row-per-agent-spec.md §5.1.
+ *
+ * External dependency boundaries mocked:
+ *   - apps/api/src/lib/prisma — the repo-standard `__mocks__/prisma.ts`
+ *     manual mock (`jest.mock("../../lib/prisma.js")`). Not read directly by
+ *     any case below — `recordAgentAction`'s injectable `AuditWriteClient`
+ *     (D1) means every case supplies its own stub delegate — this mock is
+ *     kept only so importing `audit-log.ts` never constructs a real
+ *     `PrismaPg` adapter (the repo-standard reason every sibling service
+ *     test carries this line regardless of whether it touches `prisma`
+ *     directly).
+ *   - @working-theory/observability `logger` — a partial mock (`...actual`
+ *     plus an overridden `logger`) so `redactHighEntropy` and `sanitizePII`
+ *     still run for real (AC-2 case 5 pins the real `sanitizePII`'s
+ *     behaviour) while `logger.error` / `logger.warn` are observable.
+ */
+
+// eslint-disable-next-line no-restricted-syntax -- lib/prisma.ts wraps the external DB boundary (PrismaClient requires a live connection); __mocks__/prisma.ts is the repo-standard test double for this boundary.
+jest.mock("../../lib/prisma.js");
+
+const mockLoggerError = jest.fn();
+const mockLoggerWarn = jest.fn();
+jest.mock("@working-theory/observability", () => {
+  const actual = jest.requireActual("@working-theory/observability");
+  return {
+    ...actual,
+    logger: {
+      info: jest.fn(),
+      debug: jest.fn(),
+      warn: (...args: unknown[]) => mockLoggerWarn(...args),
+      error: (...args: unknown[]) => mockLoggerError(...args),
+    },
+  };
+});
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { zAuditLogId, zWorkspaceId, type Id } from "@working-theory/ids";
+import { sanitizePII } from "@working-theory/observability";
+
+import type { TenantContext } from "../default-tenant.js";
+import {
+  deriveAuditRowId,
+  recordAgentAction,
+  redactPersonalData,
+  type AuditRowDigestInput,
+  type AuditWriteClient,
+  type RecordAgentActionInput,
+} from "../audit-log.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+// v7-shaped, RFC-4122-variant uuids — each satisfies the same
+// `[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}` CHECK
+// grammar `zWorkspaceId` / `zAuditLogId` enforce.
+const WORKSPACE_ID = "wksp_0190f3a2-7c1d-7e4a-9b2c-000000000001";
+const ORG_ID = "org_0190f3a2-7c1d-7e4a-9b2c-000000000002";
+const USER_ID = "user_0190f3a2-7c1d-7e4a-9b2c-000000000003";
+
+const TENANT: TenantContext = {
+  userId: USER_ID as Id<"user">,
+  organizationId: ORG_ID as Id<"organization">,
+  workspaceId: WORKSPACE_ID as Id<"workspace">,
+  role: "owner",
+};
+
+const BASE_INPUT: RecordAgentActionInput = {
+  tenant: TENANT,
+  actorId: "agent_abc123",
+  tool: "refund",
+  outcome: "succeeded",
+  idempotencyKey: "req_abc123",
+};
+
+/** A resolved row's `data` argument, as `AuditWriteClient.auditLog.create`
+ * would have received it — loosely typed here since the test asserts on
+ * individual fields rather than importing the module-private row shape. */
+interface WrittenRow {
+  id: string;
+  workspaceId: string;
+  actorId: string;
+  actorType: string;
+  action: string;
+  targetType?: string;
+  targetId?: string;
+  metadata: Record<string, unknown>;
+}
+
+function stubDb(
+  create: jest.Mock = jest.fn().mockResolvedValue({ id: "ignored" }),
+): {
+  db: AuditWriteClient;
+  create: jest.Mock;
+} {
+  return { db: { auditLog: { create } }, create };
+}
+
+function firstWrittenRow(create: jest.Mock): WrittenRow {
+  return (create.mock.calls[0]![0] as { data: WrittenRow }).data;
+}
+
+beforeEach(() => {
+  mockLoggerError.mockClear();
+  mockLoggerWarn.mockClear();
+});
+
+// ─── AC-1 — exactly one row, carrying the five facts ───────────────────────
+
+describe("AC-1 — exactly one row, carrying the five facts", () => {
+  it("calls create exactly once for one recordAgentAction call", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(BASE_INPUT, db);
+    expect(create).toHaveBeenCalledTimes(1);
+  });
+
+  it("writes workspaceId from the resolved tenant, satisfying zWorkspaceId", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(BASE_INPUT, db);
+    const row = firstWrittenRow(create);
+    expect(row.workspaceId).toBe(TENANT.workspaceId);
+    expect(zWorkspaceId.safeParse(row.workspaceId).success).toBe(true);
+  });
+
+  it("writes actorType 'agent' unconditionally — a regression guard, not caller-influenced", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction({ ...BASE_INPUT, outcome: "refused" }, db);
+    const row = firstWrittenRow(create);
+    expect(row.actorType).toBe("agent");
+  });
+
+  it("writes actorId verbatim", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(BASE_INPUT, db);
+    const row = firstWrittenRow(create);
+    expect(row.actorId).toBe(BASE_INPUT.actorId);
+  });
+
+  it("writes action as 'agent.commerce.' + tool — the tool name in the column, not only metadata", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction({ ...BASE_INPUT, tool: "start_purchase" }, db);
+    const row = firstWrittenRow(create);
+    expect(row.action).toBe("agent.commerce.start_purchase");
+  });
+
+  it.each([
+    "succeeded",
+    "failed",
+    "refused",
+    "awaiting_approval",
+  ] satisfies RecordAgentActionInput["outcome"][])(
+    "writes metadata.outcome = %s for every AgentActionOutcome member",
+    async (outcome) => {
+      const { db, create } = stubDb();
+      await recordAgentAction({ ...BASE_INPUT, outcome }, db);
+      const row = firstWrittenRow(create);
+      expect(row.metadata.outcome).toBe(outcome);
+    },
+  );
+
+  it("omits createdAt so the database clock supplies it — an agent cannot backdate its own row", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(BASE_INPUT, db);
+    const row = firstWrittenRow(create) as WrittenRow & { createdAt?: unknown };
+    expect(row.createdAt).toBeUndefined();
+  });
+
+  it("writes an id satisfying zAuditLogId and the migration's literal CHECK regex", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(BASE_INPUT, db);
+    const row = firstWrittenRow(create);
+    // database/migrations/20260713192429_prefixed_uuid_entity_ids/migration.sql:158
+    expect(row.id).toMatch(
+      /^audit_[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+    );
+    expect(zAuditLogId.safeParse(row.id).success).toBe(true);
+  });
+});
+
+// ─── AC-2 — personal data never reaches the stored row in clear form ───────
+
+describe("AC-2 — personal data never reaches the stored row in clear form", () => {
+  it("redacts an email and phone number from summary/failureReason on the serialized row", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(
+      {
+        ...BASE_INPUT,
+        outcome: "failed",
+        summary: "refunded buyer jane.doe@example.com, phone +1 415 555 0134",
+        failureReason: "declined for jane.doe@example.com",
+      },
+      db,
+    );
+    const row = firstWrittenRow(create);
+    const serialized = JSON.stringify(row);
+    expect(serialized).not.toContain("jane.doe@example.com");
+    expect(serialized).not.toContain("555 0134");
+    expect(serialized).toContain("[REDACTED:email]");
+  });
+
+  it("folds a full-width @ via NFKC so an email survives a unicode homoglyph domain", async () => {
+    const { db, create } = stubDb();
+    const fullWidthAt = "＠";
+    const cyrillicA = "а"; // homoglyph for latin "a" — NOT folded by NFKC
+    const summary = `contact jane.doe${fullWidthAt}ex${cyrillicA}mple.com`;
+    await recordAgentAction({ ...BASE_INPUT, summary }, db);
+    const row = firstWrittenRow(create);
+    const serialized = JSON.stringify(row);
+    expect(serialized).not.toContain(summary);
+    expect(serialized).toContain("[REDACTED:email]");
+  });
+
+  it.each([
+    ["tool", { tool: "refund_jane.doe@example.com" }],
+    ["targetType", { targetType: "jane@example.com" }],
+    ["targetId", { targetId: "jane@example.com" }],
+    ["actorId", { actorId: "agent jane@example.com" }],
+  ] as [string, Partial<RecordAgentActionInput>][])(
+    "refuses a personal-data-shaped %s rather than writing it verbatim",
+    async (_name, override) => {
+      const { db, create } = stubDb();
+      const result = await recordAgentAction(
+        { ...BASE_INPUT, ...override },
+        db,
+      );
+      expect(result).toEqual({
+        ok: false,
+        error: {
+          kind: "invalid_input",
+          message: expect.any(String),
+          persisted: false,
+        },
+      });
+      expect(create).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([
+    ["summary", { summary: "a".repeat(2001) }],
+    ["failureReason", { failureReason: "a".repeat(2001) }],
+  ] as [string, Partial<RecordAgentActionInput>][])(
+    "refuses a %s over the 2000-character cap rather than truncating it",
+    async (_name, override) => {
+      const { db, create } = stubDb();
+      const result = await recordAgentAction(
+        { ...BASE_INPUT, ...override },
+        db,
+      );
+      expect(result.ok).toBe(false);
+      if (!result.ok) expect(result.error.kind).toBe("invalid_input");
+      expect(create).not.toHaveBeenCalled();
+    },
+  );
+
+  it("refuses an idempotencyKey outside the required identifier grammar (a space)", async () => {
+    const { db, create } = stubDb();
+    const result = await recordAgentAction(
+      { ...BASE_INPUT, idempotencyKey: "req 1" },
+      db,
+    );
+    expect(result.ok).toBe(false);
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  it.each([
+    ["actorId", { actorId: "4155550134" }],
+    ["idempotencyKey", { idempotencyKey: "4155550134" }],
+  ] as [string, Partial<RecordAgentActionInput>][])(
+    "refuses a charset-valid but personal-data-shaped %s (a bare digit run) rather than silently rewriting an identifier",
+    async (_name, override) => {
+      const { db, create } = stubDb();
+      const result = await recordAgentAction(
+        { ...BASE_INPUT, ...override },
+        db,
+      );
+      expect(result.ok).toBe(false);
+      expect(create).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each([
+    ["tool", { tool: "refund" }],
+    ["summary", { summary: "notehere" }],
+  ] as [string, Partial<RecordAgentActionInput>][])(
+    "refuses a %s containing a NUL character — a reliable audit-disable switch if it reached Postgres",
+    async (_name, override) => {
+      const { db, create } = stubDb();
+      const result = await recordAgentAction(
+        { ...BASE_INPUT, ...override },
+        db,
+      );
+      expect(result.ok).toBe(false);
+      expect(create).not.toHaveBeenCalled();
+    },
+  );
+
+  it("never stores a hash or pseudonym of the redacted value", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(
+      { ...BASE_INPUT, summary: "contact jane.doe@example.com" },
+      db,
+    );
+    const row = firstWrittenRow(create);
+    expect(JSON.stringify(row)).not.toMatch(/[0-9a-f]{32,}/);
+  });
+
+  it("writes exactly the allow-listed metadata keys on the success path", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction({ ...BASE_INPUT, summary: "ok" }, db);
+    const row = firstWrittenRow(create);
+    expect(Object.keys(row.metadata).sort()).toEqual(
+      ["idempotencyKey", "outcome", "summary", "tool", "v"].sort(),
+    );
+  });
+
+  it("adds failureReason to the allow-listed metadata keys on the failure path", async () => {
+    const { db, create } = stubDb();
+    await recordAgentAction(
+      { ...BASE_INPUT, outcome: "failed", failureReason: "declined" },
+      db,
+    );
+    const row = firstWrittenRow(create);
+    expect(Object.keys(row.metadata).sort()).toEqual(
+      ["failureReason", "idempotencyKey", "outcome", "tool", "v"].sort(),
+    );
+  });
+
+  it("declares no member whose purpose is a buyer's identity", () => {
+    void recordAgentAction({
+      ...BASE_INPUT,
+      // @ts-expect-error — `buyerEmail` is not a declared member of
+      // RecordAgentActionInput (D5(a), D11). This proves the member is
+      // UNDECLARED, not that no declared member can carry personal data —
+      // `summary` can (D5 concedes this; § 9 SEC-12).
+      buyerEmail: "buyer@example.com",
+    });
+  });
+
+  it("pins the tree's sanitizePII helper NOT redacting an email — a canary on a module this writer does not use", () => {
+    expect(sanitizePII({ email: "jane@example.com" }).email).toBe(
+      "jane@example.com",
+    );
+  });
+});
+
+// ─── AC-3 — a write failure is surfaced, and the block decision is explicit ─
+
+describe("AC-3 — a write failure is surfaced, and the block decision is explicit in the code", () => {
+  it("resolves with ok:false rather than throwing on a write failure", async () => {
+    const { db } = stubDb(jest.fn().mockRejectedValue(new Error("boom")));
+    const result = await recordAgentAction(BASE_INPUT, db);
+    expect(result).toEqual({
+      ok: false,
+      error: {
+        kind: "write_failed",
+        message: expect.any(String),
+        persisted: false,
+      },
+    });
+  });
+
+  it("never returns or logs the raw error message — Prisma's data argument IS the audit row", async () => {
+    const sentinel = "SENTINEL-jane.doe@example.com";
+    const { db } = stubDb(jest.fn().mockRejectedValue(new Error(sentinel)));
+    const result = await recordAgentAction(BASE_INPUT, db);
+    expect(result.ok).toBe(false);
+    if (!result.ok) expect(result.error.message).not.toContain(sentinel);
+    expect(JSON.stringify(mockLoggerError.mock.calls[0])).not.toContain(
+      sentinel,
+    );
+  });
+
+  it("logs exactly once at error, with a code but no personal data", async () => {
+    const { db } = stubDb(jest.fn().mockRejectedValue({ code: "P2025" }));
+    await recordAgentAction(
+      { ...BASE_INPUT, summary: "contact jane.doe@example.com" },
+      db,
+    );
+    expect(mockLoggerError).toHaveBeenCalledTimes(1);
+    const fields = mockLoggerError.mock.calls[0]![0] as Record<string, unknown>;
+    expect(fields.errorCode).toBe("P2025");
+    expect(JSON.stringify(fields)).not.toContain("jane.doe@example.com");
+  });
+
+  it("states the no-block decision as source text under a named docblock heading", () => {
+    const source = readFileSync(join(__dirname, "../audit-log.ts"), "utf8");
+    expect(source).toContain("AUDIT FAILURE DOES NOT BLOCK THE AUDITED ACTION");
+    expect(source).toContain("never aborts the caller's action");
+  });
+});
+
+// ─── AC-4 — a replay produces no duplicate row ─────────────────────────────
+
+describe("AC-4 — a replay produces no duplicate row", () => {
+  const DIGEST_BASE: AuditRowDigestInput = {
+    workspaceId: TENANT.workspaceId,
+    actorId: "agent_abc123",
+    actorType: "agent",
+    action: "agent.commerce.refund",
+    targetType: "lead",
+    targetId: "lead_xyz",
+    outcome: "succeeded",
+    summary: "ok",
+    failureReason: "n-a",
+    idempotencyKey: "req_1",
+  };
+
+  it("is deterministic for identical whole-row input", () => {
+    expect(deriveAuditRowId(DIGEST_BASE)).toBe(
+      deriveAuditRowId({ ...DIGEST_BASE }),
+    );
+  });
+
+  it.each(Object.keys(DIGEST_BASE))(
+    "changes the id when %s changes, holding every other field fixed",
+    (field) => {
+      const before = deriveAuditRowId(DIGEST_BASE);
+      // eslint-disable-next-line no-restricted-syntax -- generic field-flip over every AuditRowDigestInput key (incl. the AuditActorType/AgentActionOutcome unions), read purely as a string for the mutation; the digest function itself only ever sees valid AuditRowDigestInput values in production.
+      const baseAsStrings = DIGEST_BASE as unknown as Record<string, string>;
+      const changed = {
+        ...DIGEST_BASE,
+        [field]: `${baseAsStrings[field]}-x`,
+      } as AuditRowDigestInput;
+      expect(deriveAuditRowId(changed)).not.toBe(before);
+    },
+  );
+
+  it("resists boundary forgery from the length-prefixed encoding (§9 SEC-10)", () => {
+    // Shifting content across the action/idempotencyKey boundary must not
+    // collide — a separator-concatenation implementation would produce the
+    // same byte string ("a.b" + "k" === "a" + ".b.k"-shaped) for both.
+    const a = deriveAuditRowId({
+      ...DIGEST_BASE,
+      action: "a.b",
+      idempotencyKey: "k",
+    });
+    const b = deriveAuditRowId({
+      ...DIGEST_BASE,
+      action: "a",
+      idempotencyKey: "b.k",
+    });
+    expect(a).not.toBe(b);
+  });
+
+  it("does not let a byte-identical decoy suppress the real action's record (the suppression attack, §9 SEC-01)", async () => {
+    const { db, create } = stubDb();
+    const shared = {
+      ...BASE_INPUT,
+      tool: "refund",
+      idempotencyKey: "req_shared",
+    };
+    const first = await recordAgentAction(
+      { ...shared, outcome: "refused", summary: "decoy" },
+      db,
+    );
+    const second = await recordAgentAction(
+      { ...shared, outcome: "succeeded", summary: "real refund" },
+      db,
+    );
+    expect(create).toHaveBeenCalledTimes(2);
+    expect(first).toEqual({
+      ok: true,
+      outcome: "recorded",
+      id: expect.any(String),
+    });
+    expect(second).toEqual({
+      ok: true,
+      outcome: "recorded",
+      id: expect.any(String),
+    });
+    if (first.ok && second.ok) {
+      expect(first.id).not.toBe(second.id);
+    }
+  });
+
+  it("reports a replay as duplicate — ok:true, and NOT 'recorded'", async () => {
+    const create = jest
+      .fn()
+      .mockResolvedValueOnce({ id: "ignored" })
+      .mockRejectedValueOnce({ code: "P2002" });
+    const { db } = stubDb(create);
+    const first = await recordAgentAction(BASE_INPUT, db);
+    const second = await recordAgentAction(BASE_INPUT, db);
+    expect(first).toEqual({
+      ok: true,
+      outcome: "recorded",
+      id: expect.any(String),
+    });
+    expect(second).toEqual({
+      ok: true,
+      outcome: "duplicate",
+      id: expect.any(String),
+    });
+    expect(mockLoggerWarn).toHaveBeenCalledTimes(1);
+  });
+
+  it("refuses a digit-heavy dashed uuid as an idempotencyKey — the personal-data scan reads it as a phone number, so a caller must re-spell its entropy (#6231)", async () => {
+    const { db, create } = stubDb();
+    const result = await recordAgentAction(
+      { ...BASE_INPUT, idempotencyKey: "01234567-8901-4234-8567-890123456789" },
+      db,
+    );
+    expect(result).toEqual({
+      ok: false,
+      error: {
+        kind: "invalid_input",
+        message: expect.stringContaining("personal data"),
+        persisted: false,
+      },
+    });
+    // A refusal writes NO row — an unaudited action, the failure mode the
+    // magnet routes' `_`-grouped key exists to avoid.
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  it("logs the duplicate outcome at warn, naming the colliding row — a collision is never silent regardless of caller (#6231)", async () => {
+    const { db } = stubDb(jest.fn().mockRejectedValue({ code: "P2002" }));
+    const result = await recordAgentAction(BASE_INPUT, db);
+    expect(result).toEqual({
+      ok: true,
+      outcome: "duplicate",
+      id: expect.any(String),
+    });
+    const collidingId = result.ok ? result.id : undefined;
+    expect(mockLoggerError).not.toHaveBeenCalled();
+    expect(mockLoggerWarn).toHaveBeenCalledTimes(1);
+    const [payload, message] = mockLoggerWarn.mock.calls[0] as [
+      Record<string, unknown>,
+      string,
+    ];
+    expect(payload).toMatchObject({
+      workspaceId: WORKSPACE_ID,
+      auditLogId: collidingId,
+    });
+    expect(message).toMatch(/duplicate/i);
+  });
+
+  it("never reads before writing — no find*/update/delete on the delegate (a narrow claim; §6.2's manual psql insert is the real evidence)", () => {
+    const source = readFileSync(join(__dirname, "../audit-log.ts"), "utf8");
+    expect(source).not.toMatch(/auditLog\.(find|update|delete|count)/);
+  });
+
+  it("classifies a non-P2002 rejection as write_failed, never as duplicate", async () => {
+    const { db } = stubDb(jest.fn().mockRejectedValue({ code: "P2025" }));
+    const result = await recordAgentAction(BASE_INPUT, db);
+    expect(result).toEqual({
+      ok: false,
+      error: {
+        kind: "write_failed",
+        message: expect.any(String),
+        persisted: false,
+      },
+    });
+  });
+});
+
+// ─── Supplementary — targetType/targetId pass-through (§3 D3, D5(a2)) ──────
+
+describe("targetType/targetId pass-through", () => {
+  it("validates targetId against its named entity's own id grammar when targetType names a registered entity", async () => {
+    const { db, create } = stubDb();
+    const result = await recordAgentAction(
+      { ...BASE_INPUT, targetType: "workspace", targetId: TENANT.workspaceId },
+      db,
+    );
+    expect(result.ok).toBe(true);
+    const row = firstWrittenRow(create);
+    expect(row.targetType).toBe("workspace");
+    expect(row.targetId).toBe(TENANT.workspaceId);
+  });
+
+  it("refuses a targetId that does not match its named entity's id grammar", async () => {
+    const { db, create } = stubDb();
+    const result = await recordAgentAction(
+      {
+        ...BASE_INPUT,
+        targetType: "workspace",
+        targetId: "not-a-workspace-id",
+      },
+      db,
+    );
+    expect(result.ok).toBe(false);
+    expect(create).not.toHaveBeenCalled();
+  });
+
+  it("refuses a malformed tenant.workspaceId", async () => {
+    const { db, create } = stubDb();
+    const result = await recordAgentAction(
+      {
+        ...BASE_INPUT,
+        tenant: {
+          ...TENANT,
+          workspaceId: "not-a-workspace-id" as Id<"workspace">,
+        },
+      },
+      db,
+    );
+    expect(result.ok).toBe(false);
+    expect(create).not.toHaveBeenCalled();
+  });
+});
+
+// ─── redactPersonalData — the exported pure helper, directly ───────────────
+
+describe("redactPersonalData (exported pure helper)", () => {
+  it("returns the input unchanged when it carries no personal-data-shaped substring", () => {
+    expect(redactPersonalData("nothing to see here")).toBe(
+      "nothing to see here",
+    );
+  });
+
+  it("redacts a long digit run (account/card-shaped) not caught by the phone pattern", () => {
+    expect(redactPersonalData("card 411111111111111")).toContain(
+      "[REDACTED:number]",
+    );
+  });
+});

package/templates/apps/api/src/services/__tests__/consent.test.ts

@@ -212,6 +212,8 @@ describe("recordLegacyConsent (#5275 D11)", () => {
     expect(rows).toHaveLength(1);
     expect(rows[0]).toEqual({
       siteId: SITE_ID,
+      // #6374 — the fence's isolation key, equal to `siteId` by construction.
+      workspaceId: SITE_ID,
       ...SUBJECT,
       purposeId: DEFAULT_CONSENT_PURPOSE_ID,
       granted: true,