create-ailk 0.5.0 → 0.6.0

package/templates/apps/api/src/routes/leads/__tests__/index.test.ts

@@ -31,6 +31,15 @@ jest.mock("@working-theory/email", () => ({
     ok: true,
     messageId: "msg-test",
   }),
+  // #5970 — the request-and-confirm tenant sender. Declared here because the
+  // callback route now reaches it, and because without it the feature-ON cases
+  // below would pass for the wrong reason: with the flag unset,
+  // `sendRequestConfirmLink` no-ops before it ever touches this import.
+  sendRequestConfirmEmail: jest.fn().mockResolvedValue({
+    ok: true,
+    messageId: "msg-confirm",
+  }),
+  sendRequestPaidLinkEmail: jest.fn(),
 }));
 
 // @working-theory/license: consumed transitively by enrichment-shim; mocked to avoid
@@ -50,7 +59,12 @@ import {
   leadSubscribeRoute,
   leadCallbackRoute,
 } from "../index";
+import {
+  mockNoWorkspace,
+  mockSentinelWorkspaceExists,
+} from "../../../lib/__mocks__/prisma.js";
 import { prisma } from "../../../lib/prisma.js";
+import { __resetSiteWorkspaceCacheForTests } from "../../../lib/site.js";
 import { setupLeadFileEnv } from "../../../__tests__/factories/lead-fixture";
 // #3979 AC1 — the single shared fixture (packages/validation, which apps/api
 // may_import_from per architecture.yaml) for the NewsletterFormInline
@@ -68,6 +82,42 @@ import {
 
 const fileEnv = setupLeadFileEnv("index");
 
+// #6203 — every lead-capture kind now resolves its tenant SERVER-SIDE
+// (routes/leads/index.ts), never from a body-supplied `siteId`. A test's
+// body may still send a `siteId` (a client-embed artifact, or a spoof
+// attempt) but it is silently ignored — the SEEDED default workspace id
+// (`database/tenancy.ts DEFAULT_WORKSPACE_ID`) is what actually lands, on
+// both `siteId` and the new `workspaceId` column.
+//
+// #6335 — that resolution used to come off the shared prisma mock's
+// PERMISSIVE `workspace.findUnique` default, which resolved any id it was
+// handed. The default is gone, so this suite states the workspace it
+// expects: `stateSentinelWorkspaceExists()` below, called wherever this
+// file clears its mocks.
+const RESOLVED_WORKSPACE_ID = "wksp_00000000-0000-7000-8000-000000000001";
+
+/**
+ * A second, real workspace the deployment is NOT serving. The three spoof
+ * cases below make it resolvable for their own duration, so "the row did
+ * not land there" is a statement about what the route READ rather than a
+ * side effect of the id resolving to nothing.
+ */
+const FOREIGN_WORKSPACE_ID = "wksp_00000000-0000-7000-8000-00000000dead";
+
+/**
+ * #6335 — the ONE workspace every case in this file expects to exist: the
+ * seeded sentinel `currentSiteId()`'s "default" alias names. Keyed on the
+ * requested id inside the helper, so a body-supplied foreign `siteId`
+ * resolves to nothing — which is what makes the spoof cases below prove
+ * the route never reads it, rather than proving a permissive mock resolves
+ * everything. The resolver's memo is cleared alongside, so no case answers
+ * out of a previous one's successful resolution.
+ */
+function stateSentinelWorkspaceExists(): void {
+  __resetSiteWorkspaceCacheForTests();
+  mockSentinelWorkspaceExists(prisma);
+}
+
 // ─── Suite setup ──────────────────────────────────────────────────────────────
 
 describe("POST /api/leads — id isolation", () => {
@@ -75,6 +125,7 @@ describe("POST /api/leads — id isolation", () => {
 
   beforeEach(async () => {
     jest.clearAllMocks();
+    stateSentinelWorkspaceExists();
     process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
     process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
     process.env.DATABASE_URL = "postgres://stub";
@@ -97,7 +148,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("POST /api/leads/submit — attacker-supplied id is not returned (server uuid used)", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000a1";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -124,7 +177,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("POST /api/leads/subscribe — attacker-supplied id is not returned (server uuid used)", async () => {
     const serverGeneratedId = "subscr_00000000-0000-7000-8000-0000000000a2";
-    (prisma.subscriber.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -154,7 +209,9 @@ describe("POST /api/leads — id isolation", () => {
   // values), with nothing catching it.
   it("POST /v1/leads/subscribe — the block's emitted JSON shape ({ siteId, source, email }) is accepted and persisted", async () => {
     const serverGeneratedId = "subscr_00000000-0000-7000-8000-0000000000b1";
-    (prisma.subscriber.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     // The exact body NewsletterFormInline emits at its defaults (#3965 D1) —
     // no `kind` key: buildInput() injects `kind` server-side from the route,
@@ -185,7 +242,9 @@ describe("POST /api/leads — id isolation", () => {
   // the id-isolation walls hold regardless of validation outcome.
   it("POST /v1/leads/submit — the agency-waitlist instance's emitted JSON shape ({ siteId, source, email }) is accepted and persisted", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000b2";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     // The exact body NewsletterFormInline emits for the agency-waitlist
     // instance — no `kind`, no `payload` key: buildInput() injects `kind`
@@ -217,7 +276,9 @@ describe("POST /api/leads — id isolation", () => {
   // this layer asserting a stale contract.
   it("POST /v1/leads/submit — the ContactForm section's emitted JSON shape ({ siteId, source, email, payload }) is accepted and persisted", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000b3";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     // The exact body ContactForm emits at its component defaults (#4017 D1) —
     // no `kind` key: buildInput() injects `kind` server-side from the route,
@@ -236,7 +297,9 @@ describe("POST /api/leads — id isolation", () => {
     expect(prisma.lead.create).toHaveBeenCalledTimes(1);
     expect(prisma.lead.create).toHaveBeenCalledWith({
       data: {
-        siteId: CONTACT_FORM_LEAD_BODY.siteId,
+        // #6203 — the RESOLVED workspace, never the body's own `siteId`.
+        siteId: RESOLVED_WORKSPACE_ID,
+        workspaceId: RESOLVED_WORKSPACE_ID,
         source: CONTACT_FORM_LEAD_BODY.source,
         email: CONTACT_FORM_LEAD_BODY.email,
         payload: CONTACT_FORM_LEAD_BODY.payload,
@@ -254,7 +317,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("POST /api/leads/callback — attacker-supplied id is not returned (server uuid used)", async () => {
     const serverGeneratedId = "callbk_00000000-0000-7000-8000-0000000000a3";
-    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.callback.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -281,7 +346,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("file-on-success — appendLeadRecord writes to LEAD_CAPTURE_FILE on successful DB persist", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000a4";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -306,7 +373,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("dual-write — real lead-capture-store AND DB are both invoked on success", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000a5";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -331,7 +400,9 @@ describe("POST /api/leads — id isolation", () => {
     process.env.LEAD_CAPTURE_FILE_DISABLED = "true";
 
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000a6";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -349,9 +420,7 @@ describe("POST /api/leads — id isolation", () => {
     if (res.statusCode === 201) {
       // The real lead-capture-store short-circuits when LEAD_CAPTURE_FILE_DISABLED=true.
       // The capture file must not be written.
-      await expect(
-        fs.access(fileEnv.getCaptureFilePath()),
-      ).rejects.toThrow();
+      await expect(fs.access(fileEnv.getCaptureFilePath())).rejects.toThrow();
     }
   });
 
@@ -381,7 +450,9 @@ describe("POST /api/leads — id isolation", () => {
   it("IP-include — metadata.ip present in capture record when LEAD_CAPTURE_INCLUDE_IP=true", async () => {
     process.env.LEAD_CAPTURE_INCLUDE_IP = "true";
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000a7";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -398,7 +469,7 @@ describe("POST /api/leads — id isolation", () => {
 
     if (res.statusCode === 201) {
       const record = await fileEnv.readLastCaptureRecord();
-      expect((record.metadata as Record<string, unknown>)).toHaveProperty("ip");
+      expect(record.metadata as Record<string, unknown>).toHaveProperty("ip");
     }
   });
 
@@ -406,7 +477,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("lead — payload absent from body defaults to empty object via ?? (payload ?? {} branch)", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000a8";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const bodyWithoutPayload: Record<string, unknown> = {
       kind: "submit",
@@ -430,7 +503,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("callback — preferredTime included when provided (preferredTime spread branch)", async () => {
     const serverGeneratedId = "callbk_00000000-0000-7000-8000-0000000000a9";
-    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.callback.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -453,7 +528,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("callback — payload absent from body defaults to empty object via ?? (callback payload ?? {} branch)", async () => {
     const serverGeneratedId = "callbk_00000000-0000-7000-8000-0000000000aa";
-    (prisma.callback.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.callback.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const bodyWithoutPayload: Record<string, unknown> = {
       kind: "callback",
@@ -481,7 +558,9 @@ describe("POST /api/leads — id isolation", () => {
     delete process.env.AILK_LEAD_NOTIFICATION_TO;
     delete process.env.AILK_LEAD_NOTIFICATION_FROM;
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000ab";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -511,7 +590,9 @@ describe("POST /api/leads — id isolation", () => {
   it("envelope submit — { siteId, source, payload: { email, ... } } returns 201, writes one Lead with that email and the full payload, and routes the notification email", async () => {
     const { sendLeadNotification } = jest.requireMock("@working-theory/email");
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000e1";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const envelopePayload = {
       email: "envelope@example.com",
@@ -535,7 +616,9 @@ describe("POST /api/leads — id isolation", () => {
     expect(prisma.lead.create).toHaveBeenCalledTimes(1);
     expect(prisma.lead.create).toHaveBeenCalledWith({
       data: {
-        siteId: "site-abc",
+        // #6203 — the RESOLVED workspace; the body's "site-abc" is ignored.
+        siteId: RESOLVED_WORKSPACE_ID,
+        workspaceId: RESOLVED_WORKSPACE_ID,
         source: "step-flow",
         email: "envelope@example.com",
         payload: envelopePayload,
@@ -548,7 +631,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("envelope subscribe — { siteId, source, payload: { email } } returns 201 and writes one Subscriber", async () => {
     const serverGeneratedId = "subscr_00000000-0000-7000-8000-0000000000e2";
-    (prisma.subscriber.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -566,7 +651,14 @@ describe("POST /api/leads — id isolation", () => {
     expect(prisma.subscriber.create).toHaveBeenCalledTimes(1);
     expect(prisma.subscriber.create).toHaveBeenCalledWith({
       data: {
-        siteId: "site-abc",
+        // #6203 — the RESOLVED workspace; the body's "site-abc" is ignored.
+        siteId: RESOLVED_WORKSPACE_ID,
+        // #6374 — `subscribers.workspace_id` is NOT NULL as of
+        // database/migrations/20260922120000_tenancy_fence, and
+        // `subscribers_workspace_site_agree` forces it to EQUAL `site_id`.
+        // Asserted as the same RESOLVED value, so a raw alias leaking into
+        // either column fails this test rather than the database.
+        workspaceId: RESOLVED_WORKSPACE_ID,
         email: "sub-envelope@example.com",
         source: "step-flow",
       },
@@ -610,7 +702,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("submit — a top-level email wins over a payload email", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000e3";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -626,7 +720,9 @@ describe("POST /api/leads — id isolation", () => {
     expect(res.statusCode).toBe(201);
     expect(prisma.lead.create).toHaveBeenCalledWith({
       data: {
-        siteId: "site-abc",
+        // #6203 — the RESOLVED workspace; the body's "site-abc" is ignored.
+        siteId: RESOLVED_WORKSPACE_ID,
+        workspaceId: RESOLVED_WORKSPACE_ID,
         source: "step-flow",
         email: "top-level@example.com",
         payload: { email: "shadowed-payload@example.com", message: "hi" },
@@ -637,7 +733,9 @@ describe("POST /api/leads — id isolation", () => {
 
   it("subscribe — a top-level email wins over a payload email", async () => {
     const serverGeneratedId = "subscr_00000000-0000-7000-8000-0000000000e4";
-    (prisma.subscriber.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -653,7 +751,11 @@ describe("POST /api/leads — id isolation", () => {
     expect(res.statusCode).toBe(201);
     expect(prisma.subscriber.create).toHaveBeenCalledWith({
       data: {
-        siteId: "site-abc",
+        // #6203 — the RESOLVED workspace; the body's "site-abc" is ignored.
+        siteId: RESOLVED_WORKSPACE_ID,
+        // #6374 — equal to `siteId` by construction; see the note on the
+        // envelope-subscribe assertion above.
+        workspaceId: RESOLVED_WORKSPACE_ID,
         email: "top-level-sub@example.com",
         source: "step-flow",
       },
@@ -668,7 +770,9 @@ describe("POST /api/leads — id isolation", () => {
       error: { kind: "send_error", message: "SMTP timeout" },
     });
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000ac";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const res = await app.inject({
       method: "POST",
@@ -702,12 +806,15 @@ describe("POST /v1/leads/submit — structured log stays PII-safe for envelope i
 
   it("the 'lead routed' log line carries no email or payload value when email is lifted from payload", async () => {
     jest.clearAllMocks();
+    stateSentinelWorkspaceExists();
     process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
     process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
     process.env.DATABASE_URL = "postgres://stub";
 
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000e5";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     const logLines: string[] = [];
     const logCapture = require("fastify")({
@@ -744,7 +851,8 @@ describe("POST /v1/leads/submit — structured log stays PII-safe for envelope i
       expect(logged).not.toHaveProperty("email");
       expect(logged).not.toHaveProperty("payload");
       expect(logged).toMatchObject({
-        siteId: "site-abc",
+        // #6203 — the RESOLVED workspace; the body's "site-abc" is ignored.
+        siteId: RESOLVED_WORKSPACE_ID,
         kind: "submit",
         persisted: "db",
       });
@@ -754,6 +862,164 @@ describe("POST /v1/leads/submit — structured log stays PII-safe for envelope i
   });
 });
 
+// ── #6203 AC-4 — tenant resolution: per-kind, unresolved-rejects, spoof-proof ──
+//
+// Every capture kind resolves its tenant SERVER-SIDE (routes/leads/index.ts's
+// header). These tests assert the two halves that matter: (1) an unresolved
+// resolution — DATABASE_URL set, but the alias names no workspace this
+// database holds — rejects the write with a 503 BEFORE any create call, for
+// each of the three kinds; (2) a client-supplied `siteId` naming a DIFFERENT,
+// otherwise-resolvable workspace never places a row there — the resolved
+// value always wins, proving the body value is truly ignored rather than
+// merely unpreferred.
+
+describe("POST /api/leads/:kind — tenant resolution (#6203 AC-4)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    stateSentinelWorkspaceExists();
+    process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    process.env.DATABASE_URL = "postgres://stub";
+    delete process.env.AILK_SITE_ID;
+
+    const fastify = require("fastify")();
+    await fastify.register(leadSubmitRoute);
+    await fastify.register(leadSubscribeRoute);
+    await fastify.register(leadCallbackRoute);
+    app = fastify;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    __resetSiteWorkspaceCacheForTests();
+    delete process.env.AILK_LEAD_NOTIFICATION_TO;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+    delete process.env.DATABASE_URL;
+    delete process.env.AILK_SITE_ID;
+  });
+
+  it("submit: an unresolved workspace is a 503 tenant_unresolved and writes no Lead", async () => {
+    mockNoWorkspace(prisma);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/submit",
+      payload: {
+        siteId: "default",
+        source: "contact-form",
+        email: "nobody@example.com",
+        payload: {},
+      },
+    });
+
+    expect(res.statusCode).toBe(503);
+    expect(res.json()).toMatchObject({ error: "tenant_unresolved" });
+    expect(prisma.lead.create).not.toHaveBeenCalled();
+  });
+
+  it("subscribe: an unresolved workspace is a 503 tenant_unresolved and writes no Subscriber", async () => {
+    mockNoWorkspace(prisma);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/subscribe",
+      payload: { siteId: "default", source: "footer", email: "nobody@example.com" },
+    });
+
+    expect(res.statusCode).toBe(503);
+    expect(res.json()).toMatchObject({ error: "tenant_unresolved" });
+    expect(prisma.subscriber.create).not.toHaveBeenCalled();
+  });
+
+  it("callback: an unresolved workspace is a 503 tenant_unresolved and writes no Callback", async () => {
+    mockNoWorkspace(prisma);
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/callback",
+      payload: { siteId: "default", name: "Nobody", phone: "+15550000000" },
+    });
+
+    expect(res.statusCode).toBe(503);
+    expect(res.json()).toMatchObject({ error: "tenant_unresolved" });
+    expect(prisma.callback.create).not.toHaveBeenCalled();
+  });
+
+  it("submit: a body siteId naming another workspace never places the row there — the resolved workspace always wins", async () => {
+    mockSentinelWorkspaceExists(prisma, FOREIGN_WORKSPACE_ID);
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: "lead_00000000-0000-7000-8000-0000000000f1",
+    });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/submit",
+      payload: {
+        // A DIFFERENT workspace id, which this test has deliberately made
+        // RESOLVABLE (`FOREIGN_WORKSPACE_ID` above) — so the row landing on
+        // the sentinel proves buildInput() never reads the body value at
+        // all, rather than proving the read merely failed closed.
+        siteId: FOREIGN_WORKSPACE_ID,
+        source: "contact-form",
+        email: "spoof@example.com",
+        payload: {},
+      },
+    });
+
+    expect(res.statusCode).toBe(201);
+    const { data } = (prisma.lead.create as jest.Mock).mock.calls[0]![0];
+    expect(data.siteId).toBe(RESOLVED_WORKSPACE_ID);
+    expect(data.workspaceId).toBe(RESOLVED_WORKSPACE_ID);
+    expect(data.siteId).not.toBe(FOREIGN_WORKSPACE_ID);
+  });
+
+  it("subscribe: a body siteId naming another workspace never places the row there", async () => {
+    mockSentinelWorkspaceExists(prisma, FOREIGN_WORKSPACE_ID);
+    (prisma.subscriber.create as jest.Mock).mockResolvedValue({
+      id: "subscr_00000000-0000-7000-8000-0000000000f2",
+    });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/subscribe",
+      payload: {
+        siteId: FOREIGN_WORKSPACE_ID,
+        source: "footer",
+        email: "spoof-sub@example.com",
+      },
+    });
+
+    expect(res.statusCode).toBe(201);
+    const { data } = (prisma.subscriber.create as jest.Mock).mock.calls[0]![0];
+    expect(data.siteId).toBe(RESOLVED_WORKSPACE_ID);
+    expect(data.siteId).not.toBe(FOREIGN_WORKSPACE_ID);
+  });
+
+  it("callback: a body siteId naming another workspace never places the row there", async () => {
+    mockSentinelWorkspaceExists(prisma, FOREIGN_WORKSPACE_ID);
+    (prisma.callback.create as jest.Mock).mockResolvedValue({
+      id: "callbk_00000000-0000-7000-8000-0000000000f3",
+    });
+
+    const res = await app.inject({
+      method: "POST",
+      url: "/v1/leads/callback",
+      payload: {
+        siteId: FOREIGN_WORKSPACE_ID,
+        name: "Spoofer",
+        phone: "+15559999999",
+      },
+    });
+
+    expect(res.statusCode).toBe(201);
+    const { data } = (prisma.callback.create as jest.Mock).mock.calls[0]![0];
+    expect(data.siteId).toBe(RESOLVED_WORKSPACE_ID);
+    expect(data.siteId).not.toBe(FOREIGN_WORKSPACE_ID);
+  });
+});
+
 // ── D5 — registration binds the client's literal path (issue #3964) ───────────
 //
 // The drift class this issue fixed: every test above hand-supplied the same
@@ -768,6 +1034,7 @@ describe("POST /v1/leads/submit — registration binds the client's literal path
 
   beforeEach(async () => {
     jest.clearAllMocks();
+    stateSentinelWorkspaceExists();
     process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
     process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
     process.env.DATABASE_URL = "postgres://stub";
@@ -786,7 +1053,9 @@ describe("POST /v1/leads/submit — registration binds the client's literal path
 
   it("resolves POST /v1/leads/submit — the exact literal packages/api-client/src/leads.ts's leads.submit() posts to", async () => {
     const serverGeneratedId = "lead_00000000-0000-7000-8000-0000000000d1";
-    (prisma.lead.create as jest.Mock).mockResolvedValue({ id: serverGeneratedId });
+    (prisma.lead.create as jest.Mock).mockResolvedValue({
+      id: serverGeneratedId,
+    });
 
     // Cross-reference: packages/api-client/src/leads.ts —
     //   submit: (payload) => post<LeadWriteResponse>("/v1/leads/submit", payload)
@@ -820,3 +1089,150 @@ describe("POST /v1/leads/submit — registration binds the client's literal path
     expect(res.statusCode).toBe(404);
   });
 });
+
+// ── #5970 — the route wiring itself, at route grain ────────────────────────
+//
+// The #5970 acceptance review's one residual: the suppression half is measured
+// through the real `routeLead`, and the send half through the real
+// `sendRequestConfirmLink`, but the three lines in `routes/leads/index.ts`
+// that CONNECT them were asserted by construction only. Delete that call and
+// every other test in the branch stays green while the tenant receives zero
+// emails. These two cases drive the endpoint the acceptance criterion names,
+// so that deletion turns something red.
+//
+// NFR-1 is untouched by this block: every pre-existing case above runs with
+// the feature unset, exactly as before, and none of them is edited. What is
+// added here is the feature-ON path, which did not exist to be covered.
+describe("POST /v1/leads/callback — request-and-confirm wiring (#5970)", () => {
+  // Registers its own hooks, so it must sit at describe level. It provisions
+  // the file-fallback destination the second case needs; the first case never
+  // reaches the fallback because its `callback.create` resolves.
+  setupLeadFileEnv();
+
+  const CONFIRM_ENV = [
+    "AILK_REQUEST_CONFIRM_ENABLED",
+    "AILK_REQUEST_CONFIRM_TO",
+    "AILK_REQUEST_CONFIRM_FROM",
+    "AILK_PUBLIC_API_URL",
+  ] as const;
+
+  function enableConfirm() {
+    process.env.AILK_REQUEST_CONFIRM_ENABLED = "true";
+    process.env.AILK_REQUEST_CONFIRM_TO = "owner@example.com";
+    process.env.AILK_REQUEST_CONFIRM_FROM = "hello@example.com";
+    process.env.AILK_PUBLIC_API_URL = "https://api.example.com";
+    process.env.AILK_LEAD_NOTIFICATION_TO = "owner@example.com";
+    process.env.AILK_LEAD_NOTIFICATION_FROM = "noreply@example.com";
+    process.env.DATABASE_URL = "postgres://stub";
+  }
+
+  afterEach(() => {
+    for (const key of CONFIRM_ENV) delete process.env[key];
+    delete process.env.AILK_LEAD_NOTIFICATION_TO;
+    delete process.env.AILK_LEAD_NOTIFICATION_FROM;
+    delete process.env.DATABASE_URL;
+  });
+
+  /** Awaitable equivalent of the route's fire-and-forget confirm send. */
+  const flush = () => new Promise((resolve) => setImmediate(resolve));
+
+  async function postCallback(fastify: FastifyInstance) {
+    return fastify.inject({
+      method: "POST",
+      url: "/v1/leads/callback",
+      payload: {
+        siteId: "site-abc",
+        name: "Ada Lovelace",
+        phone: "+44 7700 900000",
+        payload: {},
+      },
+    });
+  }
+
+  it("on the DB path the confirm email goes and the generic notification does not", async () => {
+    jest.clearAllMocks();
+    stateSentinelWorkspaceExists();
+    enableConfirm();
+    const email = require("@working-theory/email");
+    (prisma.callback.create as jest.Mock).mockResolvedValue({
+      id: "callbk_00000000-0000-7000-8000-00000000f001",
+    });
+    (prisma.callback.updateMany as jest.Mock).mockResolvedValue({ count: 1 });
+
+    const fastify = require("fastify")({ logger: false }) as FastifyInstance;
+    await fastify.register(leadCallbackRoute);
+    await fastify.ready();
+    try {
+      const res = await postCallback(fastify);
+      expect(res.statusCode).toBe(201);
+      await flush();
+
+      // Exactly one email, and it is the one carrying the confirm link.
+      expect(email.sendRequestConfirmEmail).toHaveBeenCalledTimes(1);
+      expect(email.sendLeadNotification).not.toHaveBeenCalled();
+    } finally {
+      await fastify.close();
+    }
+  });
+
+  it("on the FILE-FALLBACK path the generic notification goes and the confirm email does not", async () => {
+    jest.clearAllMocks();
+    stateSentinelWorkspaceExists();
+    enableConfirm();
+    const email = require("@working-theory/email");
+    (prisma.callback.create as jest.Mock).mockRejectedValue(
+      new Error("connection reset"),
+    );
+
+    const fastify = require("fastify")({ logger: false }) as FastifyInstance;
+    await fastify.register(leadCallbackRoute);
+    await fastify.ready();
+    try {
+      const res = await postCallback(fastify);
+      expect(res.statusCode).toBe(201);
+      await flush();
+
+      // No row exists to carry a credential, so the confirm send must not run
+      // — and the notification it would otherwise supersede must.
+      expect(email.sendRequestConfirmEmail).not.toHaveBeenCalled();
+      expect(email.sendLeadNotification).toHaveBeenCalledTimes(1);
+    } finally {
+      await fastify.close();
+    }
+  });
+});
+
+// ── #6335 — the fixture's own guard ───────────────────────────────────────
+//
+// Every other case in this file proves a ROUTE behaves. This one proves the
+// FIXTURE does: that the shared prisma mock ships `workspace.findUnique`
+// with no implementation at all, so a suite gets "no such workspace" until
+// it says otherwise. Re-adding a permissive default — the #6203 shape this
+// issue removed, or any catch-all under another name — fails here, and
+// fails for that reason rather than as a side effect three suites away.
+//
+// Read from a FRESH module instance so the assertion is about what the file
+// DECLARES, not about whatever the suites above have programmed onto the
+// double they share.
+describe("#6335 — the shared prisma mock declares no workspace default", () => {
+  it("workspace.findUnique ships with no implementation, and answers nothing", async () => {
+    await jest.isolateModulesAsync(async () => {
+      const fresh = (
+        require("../../../lib/__mocks__/prisma.js") as {
+          prisma: { workspace: { findUnique: jest.Mock } };
+        }
+      ).prisma;
+
+      expect(fresh.workspace.findUnique.getMockImplementation()).toBeUndefined();
+      // A bare `jest.fn()` returns `undefined` rather than a promise, and
+      // `await undefined` is `undefined` — which every resolver in
+      // `lib/site.ts` reads as "no such workspace" and rejects. That is the
+      // fail-closed default this fixture is supposed to have.
+      const answer: unknown = fresh.workspace.findUnique({
+        where: { id: "wksp_00000000-0000-7000-8000-0000000000ff" },
+      });
+      expect(answer).toBeUndefined();
+      await expect(Promise.resolve(answer)).resolves.toBeUndefined();
+    });
+  });
+});