create-ailk 0.23.0 → 0.24.0

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

@@ -2,15 +2,19 @@
  * Tests for the search_content MCP tool handler.
  *
  * Acceptance criteria verified here:
- * - searchContentInputSchema validates correct inputs (query required, type + limit optional)
- * - searchContentInputSchema rejects query longer than 200 chars
- * - searchContentInputSchema rejects limit > 50
- * - searchContentInputSchema rejects empty query
- * - ailkSearchContent happy path returns results array with correct shape
- * - ailkSearchContent returns empty results for a query with no matches
+ * - contentSearchQuerySchema validates correct inputs (q required, type + limit optional)
+ * - contentSearchQuerySchema rejects q longer than 200 chars
+ * - contentSearchQuerySchema rejects limit > 50
+ * - contentSearchQuerySchema rejects empty q
+ * - ailkSearchContent happy path returns the route's ItemList with items of the correct shape
+ * - ailkSearchContent returns an empty ItemList for a query with no matches
  * - Malformed input causes Zod rejection
- * - #5831: searchContentInputSchema accepts a registry category slug and
+ * - #5831: contentSearchQuerySchema accepts a registry category slug and
  *   rejects one outside the registry; the handler forwards it to the adapter
+ *
+ * #7167 (the operator's decision of 2026-10-19): the tool adopted its route's
+ * arguments (`q`, not `query`) and result (the `ItemList`, not `{ results }`),
+ * so the cases below read the new names.
  */
 
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -19,102 +23,108 @@ import { join, resolve } from "node:path";
 
 import {
   ailkSearchContent,
-  searchContentInputSchema,
-  searchContentOutputSchema,
+  contentSearchQuerySchema,
+  contentSearchResultSchema,
 } from "../src/tools/search_content.js";
 
 const REPO_ROOT = resolve(__dirname, "../../..");
 const CONTENT_ROOT = `${REPO_ROOT}/content`;
 
-describe("searchContentInputSchema", () => {
-  it("accepts a valid query", () => {
-    const result = searchContentInputSchema.safeParse({ query: "hello" });
+describe("contentSearchQuerySchema", () => {
+  it("accepts a valid q", () => {
+    const result = contentSearchQuerySchema.safeParse({ q: "hello" });
     expect(result.success).toBe(true);
   });
 
-  it("accepts query with optional type filter", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
+  it("accepts q with optional type filter", () => {
+    const result = contentSearchQuerySchema.safeParse({
+      q: "hello",
       type: "HomePage",
     });
     expect(result.success).toBe(true);
   });
 
-  it("accepts query with optional limit", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
+  it("accepts q with optional limit", () => {
+    const result = contentSearchQuerySchema.safeParse({
+      q: "hello",
       limit: 10,
     });
     expect(result.success).toBe(true);
   });
 
-  it("rejects an empty query", () => {
-    const result = searchContentInputSchema.safeParse({ query: "" });
+  it("rejects an empty q", () => {
+    const result = contentSearchQuerySchema.safeParse({ q: "" });
     expect(result.success).toBe(false);
   });
 
-  it("rejects a query longer than 200 chars", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "a".repeat(201),
+  it("rejects a q longer than 200 chars", () => {
+    const result = contentSearchQuerySchema.safeParse({
+      q: "a".repeat(201),
     });
     expect(result.success).toBe(false);
   });
 
-  it("accepts a query exactly 200 chars", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "a".repeat(200),
+  it("accepts a q exactly 200 chars", () => {
+    const result = contentSearchQuerySchema.safeParse({
+      q: "a".repeat(200),
     });
     expect(result.success).toBe(true);
   });
 
   it("rejects limit of 0", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "hello",
       limit: 0,
     });
     expect(result.success).toBe(false);
   });
 
   it("rejects limit > 50", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "hello",
       limit: 51,
     });
     expect(result.success).toBe(false);
   });
 
   it("accepts limit of 50", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "hello",
       limit: 50,
     });
     expect(result.success).toBe(true);
   });
 
+  it("coerces a string limit, as the route's query string parses (#7167 DD1)", () => {
+    const result = contentSearchQuerySchema.safeParse({ q: "hello", limit: "5" });
+    expect(result.success).toBe(true);
+    expect(result.data!.limit).toBe(5);
+  });
+
   it("rejects an unknown type string", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "hello",
       type: "NotAType",
     });
     expect(result.success).toBe(false);
   });
 
-  it("rejects missing query (malformed input)", () => {
-    const result = searchContentInputSchema.safeParse({});
+  it("rejects missing q (malformed input)", () => {
+    const result = contentSearchQuerySchema.safeParse({});
     expect(result.success).toBe(false);
   });
 
   it("accepts a category slug from the registry (#5831)", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "roof",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "roof",
       category: "roofing",
     });
     expect(result.success).toBe(true);
   });
 
   it("rejects a category slug outside the registry with an enum error (#5831)", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "roof",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "roof",
       category: "not-a-real-category",
     });
     expect(result.success).toBe(false);
@@ -125,8 +135,8 @@ describe("searchContentInputSchema", () => {
   });
 
   it("rejects a GROUP slug — groups are derived, never tagged (#5831)", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "roof",
+    const result = contentSearchQuerySchema.safeParse({
+      q: "roof",
       category: "professional-services",
     });
     expect(result.success).toBe(false);
@@ -182,15 +192,15 @@ describe("ailkSearchContent — category filter (#5831)", () => {
 
   it("forwards category to the adapter — only the tagged page comes back", async () => {
     const result = await ailkSearchContent(
-      { query: "roof", category: "roofing" },
+      { q: "roof", category: "roofing" },
       root,
     );
-    expect(result.results.map((r) => r.slug)).toEqual(["roof-replacement"]);
+    expect(result.items.map((r) => r.slug)).toEqual(["roof-replacement"]);
   });
 
   it("returns every match when no category is passed", async () => {
-    const result = await ailkSearchContent({ query: "roof" }, root);
-    expect(result.results.map((r) => r.slug).sort()).toEqual([
+    const result = await ailkSearchContent({ q: "roof" }, root);
+    expect(result.items.map((r) => r.slug).sort()).toEqual([
       "attic-ventilation",
       "roof-replacement",
     ]);
@@ -198,22 +208,26 @@ describe("ailkSearchContent — category filter (#5831)", () => {
 
   it("returns [] for a registry slug nothing is tagged with", async () => {
     const result = await ailkSearchContent(
-      { query: "roof", category: "legal" },
+      { q: "roof", category: "legal" },
       root,
     );
-    expect(result.results).toEqual([]);
+    expect(result.items).toEqual([]);
   });
 });
 
 describe("ailkSearchContent handler", () => {
-  it("returns a results array on a known query", async () => {
-    const result = await ailkSearchContent({ query: "launch" }, CONTENT_ROOT);
-    expect(Array.isArray(result.results)).toBe(true);
+  it("returns the route's ItemList on a known query", async () => {
+    const result = await ailkSearchContent({ q: "launch" }, CONTENT_ROOT);
+    expect(result["@context"]).toBe("https://schema.org");
+    expect(result["@type"]).toBe("ItemList");
+    expect(result.query).toBe("launch");
+    expect(Array.isArray(result.items)).toBe(true);
+    expect(result.totalItems).toBe(result.items.length);
   });
 
   it("result items have required shape fields", async () => {
-    const result = await ailkSearchContent({ query: "launch" }, CONTENT_ROOT);
-    for (const item of result.results) {
+    const result = await ailkSearchContent({ q: "launch" }, CONTENT_ROOT);
+    for (const item of result.items) {
       expect(typeof item.slug).toBe("string");
       expect(typeof item.type).toBe("string");
       expect(typeof item.title).toBe("string");
@@ -222,25 +236,26 @@ describe("ailkSearchContent handler", () => {
     }
   });
 
-  it("returns empty results for a query that matches nothing", async () => {
+  it("returns an empty ItemList for a query that matches nothing", async () => {
     const result = await ailkSearchContent(
-      { query: "xqzxqzxqzxqz_no_match_ever" },
+      { q: "xqzxqzxqzxqz_no_match_ever" },
       CONTENT_ROOT,
     );
-    expect(result.results).toEqual([]);
+    expect(result.items).toEqual([]);
+    expect(result.totalItems).toBe(0);
   });
 
   it("respects limit option", async () => {
     const result = await ailkSearchContent(
-      { query: "a", limit: 1 },
+      { q: "a", limit: 1 },
       CONTENT_ROOT,
     );
-    expect(result.results.length).toBeLessThanOrEqual(1);
+    expect(result.items.length).toBeLessThanOrEqual(1);
   });
 
-  it("output validates against searchContentOutputSchema", async () => {
-    const result = await ailkSearchContent({ query: "launch" }, CONTENT_ROOT);
-    const parsed = searchContentOutputSchema.safeParse(result);
+  it("output validates against contentSearchResultSchema", async () => {
+    const result = await ailkSearchContent({ q: "launch" }, CONTENT_ROOT);
+    const parsed = contentSearchResultSchema.safeParse(result);
     expect(parsed.success).toBe(true);
   });
 });

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

@@ -1,17 +1,22 @@
 /**
- * Tests for the submit_lead MCP tool handler.
+ * Tests for the capture_lead MCP tool handler.
  *
- * Acceptance criteria verified here:
+ * The tool takes the body `POST /v1/leads/submit` takes and returns the
+ * route's 201 body (#7171 AC-11 — the tool adopted the API). Verified here:
  * 1. Malformed input → { ok: false, error: { kind: 'invalid_input', issues } }, api-client never called
- * 2. Happy path → forwards to apiClient.leads.submit, returns { ok: true, id, persisted }
- * 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
+ * 2. Happy path → posts exactly the parsed body to apiClient.leads.submit —
+ *    no `siteId`, whatever AILK_SITE_ID says, and no stamped `source` — and
+ *    returns the route's body unchanged, `email` included
+ * 3. API 400 / 503 / 429 → { ok: false, error: { kind: 'api_error', status } }
+ * 4. #7397 — the spoke marker `payload.site` from AILK_LEAD_SITE, spread last
+ * 5. #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 {
+  LEAD_SITE_MARKER_KEY,
+  leadSubmitBodySchema,
+} from "@working-theory/validation";
 import { ailkCaptureLead } from "../src/tools/capture_lead.js";
 import { trustedCallerAddress } from "../src/request-context.js";
 
@@ -30,222 +35,141 @@ jest.mock("@working-theory/api-client", () => {
   };
 });
 
- 
+
 const { apiClient } = require("@working-theory/api-client") as {
   apiClient: { leads: { submit: jest.Mock } };
 };
 
+/** The route body, as an agent sends it. */
 const VALID_INPUT = {
-  name: "Jane Smith",
+  source: "mcp",
   email: "jane@example.com",
-  message: "I am interested in your services.",
+  payload: { name: "Jane Smith", message: "I am interested in your services." },
+};
+
+/** The route's 201 body, as the api-client hands it back. */
+const WIRE = {
+  id: "lead_00000000-0000-7000-8000-0000000000d1",
+  persisted: "db",
+  email: { ok: true, messageId: "msg-1" },
 };
 
 beforeEach(() => {
   jest.clearAllMocks();
   // The exact-body assertions below assume no spoke marker (#7397).
   delete process.env.AILK_LEAD_SITE;
+  delete process.env.AILK_SITE_ID;
 });
 
 describe("ailkCaptureLead — input validation", () => {
-  it("rejects malformed input (missing required fields) without calling api-client", async () => {
+  it("rejects malformed input (no source) without calling api-client", async () => {
     const result = await ailkCaptureLead({ email: "not-an-email" } as never);
 
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("invalid_input");
-      if (result.error.kind === "invalid_input") {
-        expect(Array.isArray(result.error.issues)).toBe(true);
-        expect(result.error.issues.length).toBeGreaterThan(0);
-      }
+    expect(result).toMatchObject({ ok: false, error: { kind: "invalid_input" } });
+    if (!result.ok && result.error.kind === "invalid_input") {
+      expect(result.error.issues.length).toBeGreaterThan(0);
     }
     expect(apiClient.leads.submit).not.toHaveBeenCalled();
   });
-});
 
-describe("ailkCaptureLead — happy path", () => {
-  it("forwards canonical body to api-client and returns ok:true with id and persisted", async () => {
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d1", persisted: "db" },
-    });
+  it("admits the StepFlow envelope — email inside payload, none at the top level — as the route does", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
+    const envelope = { source: "step-flow", payload: { email: "env@example.com" } };
 
-    const result = await ailkCaptureLead(VALID_INPUT);
+    await ailkCaptureLead(envelope);
 
-    expect(apiClient.leads.submit).toHaveBeenCalledWith({
-      siteId: "default",
-      source: "mcp",
-      email: "jane@example.com",
-      payload: { name: "Jane Smith", message: "I am interested in your services." },
-    });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.id).toBe("lead_00000000-0000-7000-8000-0000000000d1");
-      expect(result.persisted).toBe("db");
-    }
+    expect(apiClient.leads.submit).toHaveBeenCalledWith(envelope);
   });
 });
 
-describe("ailkCaptureLead — API error mapping", () => {
-  it("maps API 400 to { ok: false, error: { kind: 'api_error', status: 400 } }", async () => {
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      body: { error: "bad_request" },
-    });
-
-    const result = await ailkCaptureLead(VALID_INPUT);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("api_error");
-      if (result.error.kind === "api_error") {
-        expect(result.error.status).toBe(400);
-      }
-    }
-  });
-
-  it("maps API 503 to { ok: false, error: { kind: 'api_error', status: 503 } }", async () => {
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: false,
-      status: 503,
-      body: { error: "service_unavailable" },
-    });
-
-    const result = await ailkCaptureLead(VALID_INPUT);
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("api_error");
-      if (result.error.kind === "api_error") {
-        expect(result.error.status).toBe(503);
-      }
-    }
-  });
-
-  it("maps API 429 to { ok: false, error: { kind: 'api_error', status: 429 } }", async () => {
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: false,
-      status: 429,
-      body: { error: "rate_limited" },
-    });
+describe("ailkCaptureLead — happy path", () => {
+  it("posts exactly the parsed body and returns the route's body unchanged, email included", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
 
     const result = await ailkCaptureLead(VALID_INPUT);
 
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.kind).toBe("api_error");
-      if (result.error.kind === "api_error") {
-        expect(result.error.status).toBe(429);
-      }
-    }
+    expect(apiClient.leads.submit).toHaveBeenCalledWith(VALID_INPUT);
+    expect(result).toEqual(WIRE);
   });
-});
 
-describe("ailkCaptureLead — siteId default", () => {
-  it("uses siteId 'default' when AILK_SITE_ID is unset", async () => {
-    delete process.env.AILK_SITE_ID;
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d2", persisted: "db" },
-    });
+  it("never sends a siteId, whatever AILK_SITE_ID says, and strips one the agent sent", async () => {
+    process.env.AILK_SITE_ID = "site-abc";
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
 
-    await ailkCaptureLead(VALID_INPUT);
+    await ailkCaptureLead({ ...VALID_INPUT, siteId: "site-xyz" } as never);
 
-    const call = apiClient.leads.submit.mock.calls[0][0] as { siteId: string };
-    expect(call.siteId).toBe("default");
+    expect(apiClient.leads.submit.mock.calls[0][0]).toEqual(VALID_INPUT);
   });
 });
 
-describe("ailkCaptureLead — siteId override", () => {
-  afterEach(() => {
-    delete process.env.AILK_SITE_ID;
-  });
-
-  it("uses AILK_SITE_ID env var when set", async () => {
-    process.env.AILK_SITE_ID = "site-abc";
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d3", persisted: "db" },
-    });
-
-    await ailkCaptureLead(VALID_INPUT);
-
-    const call = apiClient.leads.submit.mock.calls[0][0] as { siteId: string };
-    expect(call.siteId).toBe("site-abc");
-  });
+describe("ailkCaptureLead — API error mapping", () => {
+  it.each([400, 503, 429])(
+    "maps API %i to { ok: false, error: { kind: 'api_error', status } }",
+    async (status) => {
+      apiClient.leads.submit.mockResolvedValueOnce({
+        ok: false,
+        status,
+        body: { error: "refused" },
+      });
+
+      const result = await ailkCaptureLead(VALID_INPUT);
+
+      expect(result).toEqual({ ok: false, error: { kind: "api_error", status } });
+    },
+  );
 });
 
 // #7397 — a spoke of a hub-and-spokes deployment is marked in the lead
-// PAYLOAD (`payload.site`); `source` stays "mcp" because
-// MESSAGE_LEAD_SOURCE_LIST is frozen. The marker comes from the MCP server's
-// own env, so an MCP-origin lead reaches the hub inbox attributed.
+// PAYLOAD (`payload.site`). The marker comes from the MCP server's own env,
+// so an MCP-origin lead reaches the hub inbox attributed; it is the one key
+// the tool adds to the body the agent sent.
 describe("ailkCaptureLead — payload site marker (#7397)", () => {
-  afterEach(() => {
-    delete process.env.AILK_LEAD_SITE;
-  });
-
   it("names the marker key 'site', the key the issue's hub-and-spokes design names", () => {
     expect(LEAD_SITE_MARKER_KEY).toBe("site");
   });
 
-  it("carries payload.site from AILK_LEAD_SITE, leaving source 'mcp'", async () => {
+  it("spreads payload.site from AILK_LEAD_SITE LAST, over an agent's own value", async () => {
     process.env.AILK_LEAD_SITE = "spoke-a.example";
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d4", persisted: "db" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
 
-    await ailkCaptureLead(VALID_INPUT);
+    await ailkCaptureLead({
+      ...VALID_INPUT,
+      payload: { ...VALID_INPUT.payload, site: "agent-said" },
+    });
 
     expect(apiClient.leads.submit).toHaveBeenCalledWith({
-      siteId: "default",
-      source: "mcp",
-      email: "jane@example.com",
-      payload: {
-        name: "Jane Smith",
-        message: "I am interested in your services.",
-        site: "spoke-a.example",
-      },
+      ...VALID_INPUT,
+      payload: { ...VALID_INPUT.payload, site: "spoke-a.example" },
     });
   });
 
-  it("sends a marked body the API's submit schema accepts", async () => {
+  it("marks a body the agent sent without a payload", async () => {
     process.env.AILK_LEAD_SITE = "spoke-a.example";
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d5", persisted: "db" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
 
-    await ailkCaptureLead(VALID_INPUT);
+    await ailkCaptureLead({ source: "mcp", email: "jane@example.com" });
 
     const body = apiClient.leads.submit.mock.calls[0][0] as Record<string, unknown>;
-    expect(leadSubmitSchema.safeParse({ kind: "submit", ...body }).success).toBe(true);
+    expect(body["payload"]).toEqual({ site: "spoke-a.example" });
+    expect(leadSubmitBodySchema.safeParse(body).success).toBe(true);
   });
 
   it.each([
     ["unset", undefined],
     ["empty", ""],
     ["whitespace only", "   "],
-  ])("omits payload.site when AILK_LEAD_SITE is %s", async (_label, value) => {
+  ])("sends the payload as it came when AILK_LEAD_SITE is %s", async (_label, value) => {
     if (value !== undefined) process.env.AILK_LEAD_SITE = value;
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d6", persisted: "db" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
 
     await ailkCaptureLead(VALID_INPUT);
 
-    const call = apiClient.leads.submit.mock.calls[0][0] as { payload: Record<string, unknown> };
-    expect(call.payload).not.toHaveProperty("site");
+    expect(apiClient.leads.submit.mock.calls[0][0]).toEqual(VALID_INPUT);
   });
 
   it("trims surrounding whitespace from AILK_LEAD_SITE", async () => {
     process.env.AILK_LEAD_SITE = "  spoke-a.example\n";
-    apiClient.leads.submit.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "lead_00000000-0000-7000-8000-0000000000d7", persisted: "db" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
 
     await ailkCaptureLead(VALID_INPUT);
 
@@ -260,10 +184,7 @@ describe("ailkCaptureLead — visitor-forwarding headers (#8073)", () => {
   });
 
   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" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
     process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
 
     await ailkCaptureLead(VALID_INPUT);
@@ -272,10 +193,7 @@ describe("ailkCaptureLead — visitor-forwarding headers (#8073)", () => {
   });
 
   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" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
     process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
 
     await trustedCallerAddress.run("203.0.113.9", () =>
@@ -292,10 +210,7 @@ describe("ailkCaptureLead — visitor-forwarding headers (#8073)", () => {
   });
 
   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" },
-    });
+    apiClient.leads.submit.mockResolvedValueOnce({ ok: true, body: WIRE });
     delete process.env.AILK_VISITOR_FORWARD_KEY;
 
     await trustedCallerAddress.run("203.0.113.9", () =>