create-ailk 0.18.0 → 0.19.0

package/templates/apps/mcp/__tests__/http-transport.test.ts

@@ -20,12 +20,20 @@
  * - Blocked UA returns 403
  * - #5971: a start_purchase burst past the per-IP daily cap is refused with
  *   the rate-limit error, and no Checkout Session is created
+ * - #8071: create_booking and submit_flow_step take the same write branch —
+ *   the origin allow-list, each tool's own daily cap (no hub call for a
+ *   refused one), one cap unit per batched call, and for create_booking an
+ *   attendee.email format check
+ * - #8073: a capture_lead call forwards the socket address the transport
+ *   trusted (never a caller-forged X-Forwarded-For) plus
+ *   AILK_VISITOR_FORWARD_KEY as the two visitor-forwarding headers, and sends
+ *   neither when the key is unset
  */
 
 import type { AddressInfo } from "node:net";
 
 import type { FastifyInstance, FastifyRequest } from "fastify";
-import { checkout } from "@working-theory/api-client";
+import { apiClient, checkout } from "@working-theory/api-client";
 
 import {
   __setMcpCommerceClaimForTest,
@@ -41,7 +49,17 @@ import { listRegisteredTools } from "../src/server.js";
 
 jest.mock("@working-theory/api-client", () => {
   const actual = jest.requireActual("@working-theory/api-client");
-  return { ...actual, checkout: { createSession: jest.fn() } };
+  // The hub stubs for the two #8071 write tools: every other surface stays
+  // real, so a tool these tests do not name behaves exactly as before.
+  return {
+    ...actual,
+    checkout: { createSession: jest.fn() },
+    apiClient: {
+      ...actual.apiClient,
+      schedule: { ...actual.apiClient.schedule, book: jest.fn() },
+      flows: { ...actual.apiClient.flows, submitStep: jest.fn() },
+    },
+  };
 });
 
 /** Permissive JSON-RPC 2.0 envelope type for response body assertions. */
@@ -340,6 +358,70 @@ describe("Abuse rules", () => {
   });
 });
 
+/**
+ * #8073 — the lead-write tools forward the address the transport TRUSTED
+ * (`request.ip`), not a caller-supplied `X-Forwarded-For` value. The
+ * long-running entry (`buildHttpTransportApp`, used throughout this file)
+ * sets no `trustProxy`, so `request.ip` is always the real socket address —
+ * 127.0.0.1 here — exactly the D5 guarantee a forged header cannot move.
+ */
+describe("capture_lead forwards the trusted caller address (#8073)", () => {
+  let app: FastifyInstance;
+  let port: number;
+  let submitSpy: jest.SpiedFunction<typeof apiClient.leads.submit>;
+
+  beforeEach(async () => {
+    submitSpy = jest
+      .spyOn(apiClient.leads, "submit")
+      .mockResolvedValue({ ok: true, body: { id: "lead_1", persisted: "db" } });
+    app = await buildHttpTransportApp(DEFAULT_CONFIG);
+    await app.listen({ host: "127.0.0.1", port: 0 });
+    port = (app.server.address() as AddressInfo).port;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    submitSpy.mockRestore();
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+  });
+
+  function capturePayload(id: number, email: string) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      method: "tools/call",
+      params: { name: "capture_lead", arguments: { name: "Jane", email } },
+    };
+  }
+
+  it("sends the socket address and the forward key as the two visitor headers", async () => {
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    const res = await mcpPost(port, capturePayload(40, "jane@example.com"), {
+      // A caller-forged hop: D5 says this must not move the key.
+      "x-forwarded-for": "203.0.113.7",
+    });
+
+    expect(res.status).toBe(200);
+    expect(submitSpy).toHaveBeenCalledTimes(1);
+    const init = submitSpy.mock.calls[0]?.[1];
+    expect(init?.headers).toEqual({
+      "x-ailk-visitor-ip": "127.0.0.1",
+      "x-ailk-visitor-forward-key": "spoke-key",
+    });
+  });
+
+  it("sends no visitor headers (and no second argument) when the key is unset", async () => {
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+
+    const res = await mcpPost(port, capturePayload(41, "jane2@example.com"));
+
+    expect(res.status).toBe(200);
+    expect(submitSpy).toHaveBeenCalledTimes(1);
+    expect(submitSpy.mock.calls[0]).toHaveLength(1);
+  });
+});
+
 /**
  * AC-3 — a `start_purchase` burst beyond the AbuseGuard per-IP cap is refused
  * with the rate-limit error and creates no Checkout Session (#5971 D6).
@@ -860,3 +942,210 @@ describe("abuse refusal status is keyed on the typed reason code (#5994)", () =>
     expect(ABUSE_REFUSAL_STATUS[AbuseReasonCode.INVALID_EMAIL]).toBe(422);
   });
 });
+
+/**
+ * #8071 — `create_booking` and `submit_flow_step` send caller-chosen data to
+ * the hub, so they take the same write branch as `capture_lead`: the
+ * write-origin allow-list, then the AbuseGuard once per call — each on its OWN
+ * daily-cap tracker.
+ *
+ * Every assertion here is a refusal the preHandler makes, so the suite holds
+ * in a scaffold that does not register the tool (no `scheduling` or
+ * `signal-collectors` module): the hub stub is checked for "no request for the
+ * refused call", never for a count the handler would have to produce.
+ */
+const HUB_WRITE_TOOLS = [
+  {
+    toolName: "create_booking",
+    capField: "createBookingDailyCapPerIp",
+    hubStub: () => apiClient.schedule.book as jest.Mock,
+    args: () => ({
+      calLink: "acme/intro",
+      start: "2030-01-07T15:00:00.000Z",
+      attendee: { name: "Ada", email: "ada@example.com" },
+    }),
+  },
+  {
+    toolName: "submit_flow_step",
+    capField: "submitFlowStepDailyCapPerIp",
+    hubStub: () => apiClient.flows.submitStep as jest.Mock,
+    args: () => ({
+      slug: "intake",
+      stepKey: "contact",
+      values: { company: "Acme" },
+    }),
+  },
+] as const;
+
+describe.each(HUB_WRITE_TOOLS)(
+  "$toolName takes the write branch of the HTTP guard (#8071)",
+  ({ toolName, capField, hubStub, args }) => {
+    const CAP = 2;
+    const config = {
+      ...DEFAULT_CONFIG,
+      cors: { writeAllowedOrigins: ["https://allowed.example"] as string[] },
+      abuse: {
+        captureLeadDailyCapPerIp: 50,
+        startPurchaseDailyCapPerIp: 20,
+        [capField]: CAP,
+        blockedUserAgents: "",
+      },
+    };
+
+    let app: FastifyInstance;
+    let port: number;
+
+    function call(id: number, callArgs: object = args()) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        method: "tools/call",
+        params: { name: toolName, arguments: callArgs },
+      };
+    }
+
+    beforeEach(async () => {
+      hubStub().mockResolvedValue({ ok: false, status: 503, body: {} });
+      app = await buildHttpTransportApp(config);
+      await app.listen({ host: "127.0.0.1", port: 0 });
+      port = (app.server.address() as AddressInfo).port;
+    });
+
+    afterEach(async () => {
+      await app.close();
+      jest.clearAllMocks();
+    });
+
+    it("is a member of WRITE_TOOLS", () => {
+      expect(WRITE_TOOLS.has(toolName)).toBe(true);
+    });
+
+    it("refuses a call from an origin not on writeAllowedOrigins with 403", async () => {
+      const res = await mcpPost(port, call(80), {
+        origin: "https://evil.example",
+      });
+
+      expect(res.status).toBe(403);
+      const body = (await res.json()) as { error?: string };
+      expect(body.error).toContain("CORS");
+      expect(hubStub()).not.toHaveBeenCalled();
+    });
+
+    it("refuses the call past its daily cap with 403, and the hub gets no request for it", async () => {
+      for (let i = 0; i < CAP; i += 1) {
+        const res = await mcpPost(port, call(81 + i));
+        expect(res.status).toBe(200);
+      }
+      const hubCallsBefore = hubStub().mock.calls.length;
+
+      const capped = await mcpPost(port, call(90));
+
+      expect(capped.status).toBe(403);
+      const body = (await capped.json()) as { error?: string };
+      expect(body.error).toContain(toolName);
+      expect(hubStub().mock.calls.length).toBe(hubCallsBefore);
+    });
+
+    it("a batch of N calls charges N cap units", async () => {
+      const res = await mcpPost(port, [call(91), call(92), call(93)]);
+
+      expect(res.status).toBe(403);
+      expect(hubStub()).not.toHaveBeenCalled();
+    });
+
+    it("its cap is its own — spending it leaves capture_lead callable", async () => {
+      for (let i = 0; i < CAP; i += 1) await mcpPost(port, call(94 + i));
+      expect((await mcpPost(port, call(97))).status).toBe(403);
+
+      const lead = await mcpPost(port, {
+        jsonrpc: "2.0",
+        id: 98,
+        method: "tools/call",
+        params: {
+          name: "capture_lead",
+          arguments: { name: "Ada", email: "ada@example.com" },
+        },
+      });
+      expect(lead.status).not.toBe(403);
+    });
+
+    it("a refusal maps through the typed code: past the cap is DAILY_CAP_REACHED", () => {
+      const guard = new AbuseGuard({
+        captureLeadDailyCapPerIp: 50,
+        [capField]: 1,
+        blockedUserAgents: "",
+      });
+      // @ts-expect-error: a stub carrying only the two members the guard reads.
+      const request: FastifyRequest = {
+        headers: { "user-agent": "Mozilla/5.0 (compatible; TestAgent/1.0)" },
+        ip: "203.0.113.9",
+      };
+
+      expect(guard.validate(toolName, args(), request).allowed).toBe(true);
+      const refused = guard.validate(toolName, args(), request);
+
+      expect(refused.allowed).toBe(false);
+      if (refused.allowed) return;
+      expect(refused.code).toBe(AbuseReasonCode.DAILY_CAP_REACHED);
+      expect(ABUSE_REFUSAL_STATUS[refused.code]).toBe(403);
+    });
+  },
+);
+
+describe("create_booking — attendee.email is format-checked before the hub (#8071)", () => {
+  let app: FastifyInstance;
+  let port: number;
+
+  const book = () => apiClient.schedule.book as jest.Mock;
+
+  function booking(id: number, attendee: unknown) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      method: "tools/call",
+      params: {
+        name: "create_booking",
+        arguments: {
+          calLink: "acme/intro",
+          start: "2030-01-07T15:00:00.000Z",
+          attendee,
+        },
+      },
+    };
+  }
+
+  beforeEach(async () => {
+    book().mockResolvedValue({ ok: false, status: 503, body: {} });
+    app = await buildHttpTransportApp(DEFAULT_CONFIG);
+    await app.listen({ host: "127.0.0.1", port: 0 });
+    port = (app.server.address() as AddressInfo).port;
+  });
+
+  afterEach(async () => {
+    await app.close();
+    jest.clearAllMocks();
+  });
+
+  it("refuses a malformed attendee.email with 422 and leaves the hub stub untouched", async () => {
+    const res = await mcpPost(
+      port,
+      booking(100, { name: "Spammer", email: "not-an-email" }),
+    );
+
+    expect(res.status).toBe(422);
+    const body = (await res.json()) as { error?: string };
+    expect(body.error).toContain("email");
+    expect(book()).not.toHaveBeenCalled();
+  });
+
+  it.each([null, "ada@example.com", ["ada@example.com"], 42])(
+    "a non-object attendee (%p) is not a guard refusal and never a 500",
+    async (attendee) => {
+      const res = await mcpPost(port, booking(101, attendee));
+
+      // The handler's own Zod schema is the authority on the shape.
+      expect(res.status).toBe(200);
+      expect(book()).not.toHaveBeenCalled();
+    },
+  );
+});

package/templates/apps/mcp/__tests__/request_callback.test.ts

@@ -7,17 +7,27 @@
  * 3. API 400 → { ok: false, error: { kind: 'api_error', status: 400 } }
  * 4. API 503 → { ok: false, error: { kind: 'api_error', status: 503 } }
  * 5. API 429 → { ok: false, error: { kind: 'api_error', status: 429 } }
+ * 6. #8073 — forwards the trusted caller address + AILK_VISITOR_FORWARD_KEY
+ *    as the two visitor-forwarding headers only when both are present
  */
 
 import { ailkRequestCallback } from "../src/tools/request_callback.js";
-
-jest.mock("@working-theory/api-client", () => ({
-  apiClient: {
-    leads: {
-      callback: jest.fn(),
+import { trustedCallerAddress } from "../src/request-context.js";
+
+// Everything but `apiClient.leads.callback` stays the ACTUAL
+// implementation — in particular `visitorForwardHeaders`, which
+// `request-context.ts` (imported above, for `trustedCallerAddress`) reads
+// for real.
+jest.mock("@working-theory/api-client", () => {
+  const actual = jest.requireActual("@working-theory/api-client");
+  return {
+    ...actual,
+    apiClient: {
+      ...actual.apiClient,
+      leads: { ...actual.apiClient.leads, callback: jest.fn() },
     },
-  },
-}));
+  };
+});
 
  
 const { apiClient } = require("@working-theory/api-client") as {
@@ -161,3 +171,55 @@ describe("ailkRequestCallback — siteId override", () => {
     expect(call.siteId).toBe("site-abc");
   });
 });
+
+describe("ailkRequestCallback — visitor-forwarding headers (#8073)", () => {
+  afterEach(() => {
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+  });
+
+  it("calls api-client with exactly one argument when there is no trusted address", async () => {
+    apiClient.leads.callback.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "fallback-1700000000000-e1", persisted: "file" },
+    });
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    await ailkRequestCallback(VALID_INPUT);
+
+    expect(apiClient.leads.callback.mock.calls[0]).toHaveLength(1);
+  });
+
+  it("forwards the trusted address and the forward key as the two visitor headers", async () => {
+    apiClient.leads.callback.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "fallback-1700000000000-e2", persisted: "file" },
+    });
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    await trustedCallerAddress.run("203.0.113.9", () =>
+      ailkRequestCallback(VALID_INPUT),
+    );
+
+    const init = apiClient.leads.callback.mock.calls[0][1] as
+      | { headers?: Record<string, string> }
+      | undefined;
+    expect(init?.headers).toEqual({
+      "x-ailk-visitor-ip": "203.0.113.9",
+      "x-ailk-visitor-forward-key": "spoke-key",
+    });
+  });
+
+  it("sends no headers when there is a trusted address but no forward key", async () => {
+    apiClient.leads.callback.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "fallback-1700000000000-e3", persisted: "file" },
+    });
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+
+    await trustedCallerAddress.run("203.0.113.9", () =>
+      ailkRequestCallback(VALID_INPUT),
+    );
+
+    expect(apiClient.leads.callback.mock.calls[0]).toHaveLength(1);
+  });
+});

package/templates/apps/mcp/__tests__/submit_lead.test.ts

@@ -7,19 +7,28 @@
  * 3. API 400 → { ok: false, error: { kind: 'api_error', status: 400 } }
  * 4. API 503 → { ok: false, error: { kind: 'api_error', status: 503 } }
  * 5. API 429 → { ok: false, error: { kind: 'api_error', status: 429 } }
+ * 6. #8073 — forwards the trusted caller address + AILK_VISITOR_FORWARD_KEY
+ *    as the two visitor-forwarding headers only when both are present
  */
 
 import { LEAD_SITE_MARKER_KEY, leadSubmitSchema } from "@working-theory/validation";
 import { ailkCaptureLead } from "../src/tools/capture_lead.js";
-
-// Mock @working-theory/api-client before importing the handler
-jest.mock("@working-theory/api-client", () => ({
-  apiClient: {
-    leads: {
-      submit: jest.fn(),
+import { trustedCallerAddress } from "../src/request-context.js";
+
+// Mock @working-theory/api-client before importing the handler. Everything
+// but `apiClient.leads.submit` stays the ACTUAL implementation — in
+// particular `visitorForwardHeaders`, which `request-context.ts` (imported
+// above, for `trustedCallerAddress`) reads for real.
+jest.mock("@working-theory/api-client", () => {
+  const actual = jest.requireActual("@working-theory/api-client");
+  return {
+    ...actual,
+    apiClient: {
+      ...actual.apiClient,
+      leads: { ...actual.apiClient.leads, submit: jest.fn() },
     },
-  },
-}));
+  };
+});
 
  
 const { apiClient } = require("@working-theory/api-client") as {
@@ -244,3 +253,55 @@ describe("ailkCaptureLead — payload site marker (#7397)", () => {
     expect(call.payload["site"]).toBe("spoke-a.example");
   });
 });
+
+describe("ailkCaptureLead — visitor-forwarding headers (#8073)", () => {
+  afterEach(() => {
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+  });
+
+  it("calls api-client with exactly one argument when there is no trusted address", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_00000000-0000-7000-8000-0000000000e1", persisted: "db" },
+    });
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    await ailkCaptureLead(VALID_INPUT);
+
+    expect(apiClient.leads.submit.mock.calls[0]).toHaveLength(1);
+  });
+
+  it("forwards the trusted address and the forward key as the two visitor headers", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_00000000-0000-7000-8000-0000000000e2", persisted: "db" },
+    });
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    await trustedCallerAddress.run("203.0.113.9", () =>
+      ailkCaptureLead(VALID_INPUT),
+    );
+
+    const init = apiClient.leads.submit.mock.calls[0][1] as
+      | { headers?: Record<string, string> }
+      | undefined;
+    expect(init?.headers).toEqual({
+      "x-ailk-visitor-ip": "203.0.113.9",
+      "x-ailk-visitor-forward-key": "spoke-key",
+    });
+  });
+
+  it("sends no headers when there is a trusted address but no forward key", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_00000000-0000-7000-8000-0000000000e3", persisted: "db" },
+    });
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+
+    await trustedCallerAddress.run("203.0.113.9", () =>
+      ailkCaptureLead(VALID_INPUT),
+    );
+
+    expect(apiClient.leads.submit.mock.calls[0]).toHaveLength(1);
+  });
+});

package/templates/apps/mcp/__tests__/subscribe_newsletter.test.ts

@@ -7,17 +7,27 @@
  * 3. API 400 → { ok: false, error: { kind: 'api_error', status: 400 } }
  * 4. API 503 → { ok: false, error: { kind: 'api_error', status: 503 } }
  * 5. API 429 → { ok: false, error: { kind: 'api_error', status: 429 } }
+ * 6. #8073 — forwards the trusted caller address + AILK_VISITOR_FORWARD_KEY
+ *    as the two visitor-forwarding headers only when both are present
  */
 
 import { ailkSubscribeNewsletter } from "../src/tools/subscribe_newsletter.js";
-
-jest.mock("@working-theory/api-client", () => ({
-  apiClient: {
-    leads: {
-      subscribe: jest.fn(),
+import { trustedCallerAddress } from "../src/request-context.js";
+
+// Everything but `apiClient.leads.subscribe` stays the ACTUAL
+// implementation — in particular `visitorForwardHeaders`, which
+// `request-context.ts` (imported above, for `trustedCallerAddress`) reads
+// for real.
+jest.mock("@working-theory/api-client", () => {
+  const actual = jest.requireActual("@working-theory/api-client");
+  return {
+    ...actual,
+    apiClient: {
+      ...actual.apiClient,
+      leads: { ...actual.apiClient.leads, subscribe: jest.fn() },
     },
-  },
-}));
+  };
+});
 
  
 const { apiClient } = require("@working-theory/api-client") as {
@@ -159,3 +169,55 @@ describe("ailkSubscribeNewsletter — siteId override", () => {
     expect(call.siteId).toBe("site-abc");
   });
 });
+
+describe("ailkSubscribeNewsletter — visitor-forwarding headers (#8073)", () => {
+  afterEach(() => {
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+  });
+
+  it("calls api-client with exactly one argument when there is no trusted address", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "subscr_00000000-0000-7000-8000-0000000000e1", persisted: "db" },
+    });
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    await ailkSubscribeNewsletter(VALID_INPUT);
+
+    expect(apiClient.leads.subscribe.mock.calls[0]).toHaveLength(1);
+  });
+
+  it("forwards the trusted address and the forward key as the two visitor headers", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "subscr_00000000-0000-7000-8000-0000000000e2", persisted: "db" },
+    });
+    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
+
+    await trustedCallerAddress.run("203.0.113.9", () =>
+      ailkSubscribeNewsletter(VALID_INPUT),
+    );
+
+    const init = apiClient.leads.subscribe.mock.calls[0][1] as
+      | { headers?: Record<string, string> }
+      | undefined;
+    expect(init?.headers).toEqual({
+      "x-ailk-visitor-ip": "203.0.113.9",
+      "x-ailk-visitor-forward-key": "spoke-key",
+    });
+  });
+
+  it("sends no headers when there is a trusted address but no forward key", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "subscr_00000000-0000-7000-8000-0000000000e3", persisted: "db" },
+    });
+    delete process.env.AILK_VISITOR_FORWARD_KEY;
+
+    await trustedCallerAddress.run("203.0.113.9", () =>
+      ailkSubscribeNewsletter(VALID_INPUT),
+    );
+
+    expect(apiClient.leads.subscribe.mock.calls[0]).toHaveLength(1);
+  });
+});

package/templates/apps/mcp/jest.config.cjs

@@ -12,16 +12,8 @@ module.exports = {
   testMatch: ['**/__tests__/**/*.test.ts'],
   moduleFileExtensions: ['ts', 'js', 'json'],
   moduleNameMapper: {
-    // Mock server-only in Jest environments — the package throws by design
-    // outside Next.js. The real guard runs in production Next.js builds.
-    '^server-only$': '<rootDir>/../../__mocks__/server-only.ts',
-    // Map workspace packages to their TypeScript source so ts-jest compiles them
-    // directly (the published dist is ESM, which Jest's CJS preset can't load).
-    '^@working-theory/aeo$': '<rootDir>/../../packages/aeo/src/index.ts',
-    '^@working-theory/common$': '<rootDir>/../../packages/common/src/index.ts',
-    '^@working-theory/aeo/(.*)$': '<rootDir>/../../packages/aeo/src/$1',
-    '^@working-theory/content-adapters$': '<rootDir>/../../packages/content-adapters/src/index.ts',
-    '^@working-theory/content-adapters/(.*)$': '<rootDir>/../../packages/content-adapters/src/$1',
+    // @working-theory/* resolve from the installed packages; their ESM
+    // dist is converted by the transform below.
     // The constants + one-workspace predicate subpath only (#5876 spec D11) —
     // no @prisma/client import, so ts-jest compiles it directly like every
     // other workspace mapping below. The database/dist/ build is empty in a
@@ -29,23 +21,11 @@ module.exports = {
     // can't load. The CLIENT root (`@working-theory/database`) stays
     // deliberately UNMAPPED — see apps/mcp/src/lib/prisma.ts.
     '^@working-theory/database/tenancy$': '<rootDir>/../../database/tenancy.ts',
-    // tenancy.ts's isSentinel import (above) is a VALUE import, so every
-    // suite that loads the tenancy subpath transitively loads this one too
-    // — mirrors apps/api/jest.config.cjs's identical mapping.
-    '^@working-theory/ids$': '<rootDir>/../../packages/ids/src/index.ts',
-    '^@working-theory/license$': '<rootDir>/../../packages/license/src/index.ts',
-    '^@working-theory/metadata$': '<rootDir>/../../packages/metadata/src/index.ts',
-    '^@working-theory/schema$': '<rootDir>/../../packages/schema/src/index.ts',
-    '^@working-theory/schema/(.*)$': '<rootDir>/../../packages/schema/src/$1',
-    '^@working-theory/schema-validator$': '<rootDir>/../../packages/schema-validator/src/index.ts',
-    '^@working-theory/schema-pack-registry$': '<rootDir>/../../packages/schema-pack-registry/src/index.ts',
-    '^@working-theory/validation$': '<rootDir>/../../packages/validation/src/index.ts',
-    '^@working-theory/api-client$': '<rootDir>/../../packages/api-client/src/index.ts',
     '^(\\.{1,2}/.*)\\.js$': '$1',
   },
   collectCoverageFrom: ['src/**/*.ts', '!src/**/*.d.ts'],
   transformIgnorePatterns: [
-    '/node_modules/(?!(\\.pnpm/)?jose@?[^/]*?(/|$))',
+    '/node_modules/(?!(\\.pnpm/)?(jose@?[^/]*?|cookie@?[^/]*?|@vercel(?:\\+analytics@[^/]*?|/analytics)|@working-theory(?:\\+[^/]*?@?[^/]*?|/[^/]+))(/|$))',
   ],
   transform: {
     '^.+\\.(tsx?|jsx?|mjs)$': [
@@ -61,27 +41,6 @@ module.exports = {
           skipLibCheck: true,
           ignoreDeprecations: '6.0',
           allowJs: true,
-          // paths must mirror moduleNameMapper above so ts-jest's TypeScript
-          // type-checker can resolve workspace package imports during compile.
-          // Jest's moduleNameMapper handles runtime resolution; TS uses paths.
-          baseUrl: '.',
-          paths: {
-            '@working-theory/aeo': ['../../packages/aeo/src/index.ts'],
-            '@working-theory/common': ['../../packages/common/src/index.ts'],
-            '@working-theory/aeo/*': ['../../packages/aeo/src/*'],
-            '@working-theory/api-client': ['../../packages/api-client/src/index.ts'],
-            '@working-theory/content-adapters': ['../../packages/content-adapters/src/index.ts'],
-            '@working-theory/content-adapters/*': ['../../packages/content-adapters/src/*'],
-            '@working-theory/database/tenancy': ['../../database/tenancy.ts'],
-            '@working-theory/ids': ['../../packages/ids/src/index.ts'],
-            '@working-theory/license': ['../../packages/license/src/index.ts'],
-            '@working-theory/metadata': ['../../packages/metadata/src/index.ts'],
-            '@working-theory/schema': ['../../packages/schema/src/index.ts'],
-            '@working-theory/schema/*': ['../../packages/schema/src/*'],
-            '@working-theory/schema-validator': ['../../packages/schema-validator/src/index.ts'],
-            '@working-theory/schema-pack-registry': ['../../packages/schema-pack-registry/src/index.ts'],
-            '@working-theory/validation': ['../../packages/validation/src/index.ts'],
-          },
         },
         // Suppress "import.meta only allowed in ESM modules" — source is ESM,
         // but ts-jest compiles to CommonJS for Jest. The import.meta fallback