create-ailk 0.23.0 → 0.24.0

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

@@ -1,13 +1,15 @@
 /**
  * Tests for the subscribe_newsletter MCP tool handler.
  *
- * Acceptance criteria verified here:
+ * The tool takes the body `POST /v1/leads/subscribe` takes — `{ email,
+ * source }` — and returns the route's 201 body (#7172 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.subscribe, 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.subscribe —
+ *    no `siteId`, whatever AILK_SITE_ID says, no stamped `source`, no
+ *    `firstName` — and returns the route's body unchanged, `email` included
+ * 3. API 400 / 503 / 429 → { ok: false, error: { kind: 'api_error', status } }
+ * 4. #8073 — forwards the trusted caller address + AILK_VISITOR_FORWARD_KEY
  *    as the two visitor-forwarding headers only when both are present
  */
 
@@ -29,145 +31,81 @@ jest.mock("@working-theory/api-client", () => {
   };
 });
 
- 
+
 const { apiClient } = require("@working-theory/api-client") as {
   apiClient: { leads: { subscribe: jest.Mock } };
 };
 
-const VALID_INPUT = {
-  email: "jane@example.com",
+/** The route body, as an agent sends it. */
+const VALID_INPUT = { email: "jane@example.com", source: "mcp" };
+
+/** The route's 201 body, as the api-client hands it back. */
+const WIRE = {
+  id: "subscr_00000000-0000-7000-8000-0000000000d1",
+  persisted: "db",
+  email: { skipped: true, reason: "no sender configured" },
 };
 
 beforeEach(() => {
   jest.clearAllMocks();
+  delete process.env.AILK_SITE_ID;
 });
 
 describe("ailkSubscribeNewsletter — input validation", () => {
-  it("rejects malformed input (invalid email) without calling api-client", async () => {
-    const result = await ailkSubscribeNewsletter({ email: "not-an-email" });
-
-    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);
-      }
+  it.each([
+    ["an invalid email", { email: "not-an-email", source: "mcp" }],
+    ["no source", { email: "jane@example.com" }],
+    ["a source with a control character", { email: "jane@example.com", source: "a\nb" }],
+  ])("rejects %s without calling api-client", async (_label, input) => {
+    const result = await ailkSubscribeNewsletter(input as never);
+
+    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.subscribe).not.toHaveBeenCalled();
   });
 });
 
 describe("ailkSubscribeNewsletter — happy path", () => {
-  it("forwards canonical body to api-client and returns ok:true with id and persisted", async () => {
-    apiClient.leads.subscribe.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "subscr_00000000-0000-7000-8000-0000000000d1", persisted: "db" },
-    });
-
-    const result = await ailkSubscribeNewsletter(VALID_INPUT);
-
-    expect(apiClient.leads.subscribe).toHaveBeenCalledWith({
-      siteId: "default",
-      email: "jane@example.com",
-      source: "mcp",
-    });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.id).toBe("subscr_00000000-0000-7000-8000-0000000000d1");
-      expect(result.persisted).toBe("db");
-    }
-  });
-});
-
-describe("ailkSubscribeNewsletter — API error mapping", () => {
-  it("maps API 400 to { ok: false, error: { kind: 'api_error', status: 400 } }", async () => {
-    apiClient.leads.subscribe.mockResolvedValueOnce({
-      ok: false,
-      status: 400,
-      body: { error: "bad_request" },
-    });
-
-    const result = await ailkSubscribeNewsletter(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.subscribe.mockResolvedValueOnce({
-      ok: false,
-      status: 503,
-      body: { error: "service_unavailable" },
-    });
-
-    const result = await ailkSubscribeNewsletter(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.subscribe.mockResolvedValueOnce({
-      ok: false,
-      status: 429,
-      body: { error: "rate_limited" },
-    });
+  it("posts exactly the parsed body and returns the route's body unchanged, email included", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({ ok: true, body: WIRE });
 
     const result = await ailkSubscribeNewsletter(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.subscribe).toHaveBeenCalledWith(VALID_INPUT);
+    expect(result).toEqual(WIRE);
   });
-});
 
-describe("ailkSubscribeNewsletter — siteId default", () => {
-  it("uses siteId 'default' when AILK_SITE_ID is unset", async () => {
-    delete process.env.AILK_SITE_ID;
-    apiClient.leads.subscribe.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "subscr_00000000-0000-7000-8000-0000000000d2", persisted: "db" },
-    });
+  it("never sends a siteId or a firstName, whatever AILK_SITE_ID says or the agent sent", async () => {
+    process.env.AILK_SITE_ID = "site-abc";
+    apiClient.leads.subscribe.mockResolvedValueOnce({ ok: true, body: WIRE });
 
-    await ailkSubscribeNewsletter(VALID_INPUT);
+    await ailkSubscribeNewsletter({
+      ...VALID_INPUT,
+      siteId: "site-xyz",
+      firstName: "Jane",
+    } as never);
 
-    const call = apiClient.leads.subscribe.mock.calls[0][0] as { siteId: string };
-    expect(call.siteId).toBe("default");
+    expect(apiClient.leads.subscribe.mock.calls[0][0]).toEqual(VALID_INPUT);
   });
 });
 
-describe("ailkSubscribeNewsletter — 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.subscribe.mockResolvedValueOnce({
-      ok: true,
-      body: { id: "subscr_00000000-0000-7000-8000-0000000000d3", persisted: "db" },
-    });
-
-    await ailkSubscribeNewsletter(VALID_INPUT);
-
-    const call = apiClient.leads.subscribe.mock.calls[0][0] as { siteId: string };
-    expect(call.siteId).toBe("site-abc");
-  });
+describe("ailkSubscribeNewsletter — API error mapping", () => {
+  it.each([400, 503, 429])(
+    "maps API %i to { ok: false, error: { kind: 'api_error', status } }",
+    async (status) => {
+      apiClient.leads.subscribe.mockResolvedValueOnce({
+        ok: false,
+        status,
+        body: { error: "refused" },
+      });
+
+      const result = await ailkSubscribeNewsletter(VALID_INPUT);
+
+      expect(result).toEqual({ ok: false, error: { kind: "api_error", status } });
+    },
+  );
 });
 
 describe("ailkSubscribeNewsletter — visitor-forwarding headers (#8073)", () => {
@@ -176,10 +114,7 @@ describe("ailkSubscribeNewsletter — visitor-forwarding headers (#8073)", () =>
   });
 
   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" },
-    });
+    apiClient.leads.subscribe.mockResolvedValueOnce({ ok: true, body: WIRE });
     process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
 
     await ailkSubscribeNewsletter(VALID_INPUT);
@@ -188,10 +123,7 @@ describe("ailkSubscribeNewsletter — visitor-forwarding headers (#8073)", () =>
   });
 
   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" },
-    });
+    apiClient.leads.subscribe.mockResolvedValueOnce({ ok: true, body: WIRE });
     process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
 
     await trustedCallerAddress.run("203.0.113.9", () =>
@@ -208,10 +140,7 @@ describe("ailkSubscribeNewsletter — visitor-forwarding headers (#8073)", () =>
   });
 
   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" },
-    });
+    apiClient.leads.subscribe.mockResolvedValueOnce({ ok: true, body: WIRE });
     delete process.env.AILK_VISITOR_FORWARD_KEY;
 
     await trustedCallerAddress.run("203.0.113.9", () =>

package/templates/apps/mcp/package.json

@@ -27,6 +27,7 @@
     "@working-theory/license": "workspace:*",
     "@working-theory/metadata": "workspace:*",
     "@working-theory/schema": "workspace:*",
+    "@working-theory/site-config": "workspace:*",
     "@working-theory/validation": "workspace:*",
     "fastify": "^5.12.5",
     "yaml": "^2.9.0",

package/templates/apps/mcp/src/abuse/index.ts

@@ -28,14 +28,18 @@ import { buildDenyList, isUserAgentBlocked } from "./user-agent-deny.js";
 
 /**
  * Tools that require email format validation on their input, each mapped to
- * where the email sits in it: top level for the lead tools, `attendee.email`
- * for create_booking (#8071 D3). submit_flow_step has no fixed email field —
- * its `values` is a free record the hub's flow engine validates.
+ * the paths the email may sit at, read in order — the first string wins: top
+ * level for the lead tools, then `payload.email`, since the route lifts the
+ * address from there when the top level has none (#7171, #7172: `email` is
+ * optional at the top level of both bodies, so an agent could otherwise nest
+ * a malformed one past this check); `attendee.email` for create_booking
+ * (#8071 D3). submit_flow_step has no fixed email field — its `values` is a
+ * free record the hub's flow engine validates.
  */
-const EMAIL_VALIDATED_TOOLS = new Map<string, readonly string[]>([
-  ["capture_lead", ["email"]],
-  ["subscribe_newsletter", ["email"]],
-  ["create_booking", ["attendee", "email"]],
+const EMAIL_VALIDATED_TOOLS = new Map<string, readonly (readonly string[])[]>([
+  ["capture_lead", [["email"], ["payload", "email"]]],
+  ["subscribe_newsletter", [["email"], ["payload", "email"]]],
+  ["create_booking", [["attendee", "email"]]],
 ]);
 
 /**
@@ -274,12 +278,15 @@ export class AbuseGuard {
       };
     }
 
-    // Rule 3: Email format validation, at the tool's own email path. A
+    // Rule 3: Email format validation, at the tool's own email paths — the
+    // first path holding a string is the address the route will read. A
     // missing or non-string email passes — the handler's Zod schema is the
     // authority on required fields.
-    const emailPath = EMAIL_VALIDATED_TOOLS.get(toolName);
-    if (emailPath !== undefined) {
-      const email = valueAt(input, emailPath);
+    const emailPaths = EMAIL_VALIDATED_TOOLS.get(toolName);
+    if (emailPaths !== undefined) {
+      const email = emailPaths
+        .map((path) => valueAt(input, path))
+        .find((value) => typeof value === "string");
       if (typeof email === "string" && !isValidEmail(email)) {
         return {
           allowed: false,

package/templates/apps/mcp/src/http-transport.ts

@@ -201,6 +201,17 @@ function isOriginAllowedForWrite(
   return allowedOrigins.includes(origin);
 }
 
+/**
+ * The "retry in …" wording of the write bucket's refusal, matching what
+ * @fastify/rate-limit's default error says for the same window — `format()`
+ * from `@lukeed/ms` over whole seconds, which for a one-minute window is
+ * "1 minute" or "N second(s)".
+ */
+function retryIn(seconds: number): string {
+  if (seconds >= 60) return "1 minute";
+  return `${seconds} second${seconds === 1 ? "" : "s"}`;
+}
+
 /**
  * An agent key's shape (#3591 D2): `ailk_agt_` plus 32 random bytes in
  * base64url. apps/mcp checks only this; apps/api is where the key is checked.
@@ -322,14 +333,25 @@ export async function registerHttpTransport(
   });
 
   // ── Rate limiting ─────────────────────────────────────────────────────────
-  // Global ceiling — the lower write limit is enforced per-request via the
-  // preHandler by checking the tool name after body parse.
+  // Global ceiling — readPerMin per IP, counted on every request (writes
+  // included) by the plugin's own onRequest hook.
   await app.register(rateLimit, {
     max: config.rateLimits.readPerMin,
     timeWindow: "1 minute",
     keyGenerator: (request: FastifyRequest) => request.ip,
   });
 
+  // The write bucket — writePerMin per IP, charged in the POST preHandler
+  // below once per write-tool call, after the body is parsed and classified
+  // (#9251). `createRateLimit()` gives it its own in-memory store with the
+  // ceiling's key generator and window; it is the plugin's seam for a second
+  // limiter on a request the ceiling has already counted (a hook from
+  // `app.rateLimit()` would skip such a request as already limited).
+  const writeLimit = app.createRateLimit({
+    max: config.rateLimits.writePerMin,
+    timeWindow: "1 minute",
+  });
+
   // ── MCP route ─────────────────────────────────────────────────────────────
 
   // GET — SSE stream for an existing session
@@ -362,13 +384,29 @@ export async function registerHttpTransport(
           return;
         }
 
-        // Write-tool rate limit (stricter than read ceiling)
-        // We re-use the same in-memory store but apply a tighter key.
-        // @fastify/rate-limit tracks by keyGenerator; we check manually here.
-        // Simple approach: use a second rate-limit store baked into the guard.
-        // For now, we rely on the global ceiling for writes (configurable).
-        // TODO: per-tool write rate limit when @fastify/rate-limit v11 lands
-        // a per-route override API compatible with our stateless route design.
+        // Write-tool rate limit (#9251) — writePerMin per IP, tighter than
+        // the ceiling and counting write-tool calls only. Charged once per
+        // call, like the abuse guard below, so a batch of N spends N units.
+        // The refusal is the one the ceiling emits — the plugin's four
+        // headers and Fastify's 429 error body — so a caller sees one
+        // rate-limit shape whichever bucket ran out, never a tool-level
+        // error (see ABUSE_REFUSAL_STATUS on why that distinction matters).
+        for (const _call of writeCalls) {
+          const limit = await writeLimit(request);
+          if (limit.isAllowed || !limit.isExceeded) continue;
+          reply
+            .code(429)
+            .header("x-ratelimit-limit", limit.max)
+            .header("x-ratelimit-remaining", 0)
+            .header("x-ratelimit-reset", limit.ttlInSeconds)
+            .header("retry-after", limit.ttlInSeconds)
+            .send({
+              statusCode: 429,
+              error: "Too Many Requests",
+              message: `Rate limit exceeded, retry in ${retryIn(limit.ttlInSeconds)}`,
+            });
+          return;
+        }
 
         // Abuse heuristics — charged ONCE PER CALL, not once per request, so a
         // batch of N cannot spend one cap unit and execute N times. The whole

package/templates/apps/mcp/src/lib/content-adapter.ts

@@ -114,29 +114,3 @@ export function getMcpContentAdapter(
   // untouched and gate only the four write methods (D13).
   return readOnlyContentAdapter(adapter as MdxContentAdapter);
 }
-
-/**
- * The same resolution, narrowed to the MDX adapter's richer surface.
- *
- * `read_content` returns a page's raw MDX body, which only
- * `MdxContentAdapter.getPageSource()` provides — the base `ContentAdapter`
- * contract returns frontmatter only. Rather than cast, this asserts the
- * capability on the adapter the resolver actually built, so a server pointed
- * at a non-MDX `CONTENT_ADAPTER` gets a named error instead of a
- * `getPageSource is not a function` TypeError. On the default `mdx` path the
- * check always passes and behaviour is unchanged. Under `database`, both the
- * fail-closed empty adapter and the read-only-wrapped database adapter also
- * provide `getPageSource`, so the check passes there too (D5).
- */
-export function getMcpMdxContentAdapter(
-  options: McpContentAdapterOptions = {},
-): MdxContentAdapter {
-  const adapter = getMcpContentAdapter(options);
-  if (typeof (adapter as MdxContentAdapter).getPageSource !== "function") {
-    throw new Error(
-      "This tool needs the MDX adapter's getPageSource(): the adapter selected by " +
-        "CONTENT_ADAPTER does not provide a raw MDX body. Use CONTENT_ADAPTER=mdx (the default).",
-    );
-  }
-  return adapter as MdxContentAdapter;
-}

package/templates/apps/mcp/src/lib/empty-content-adapter.ts

@@ -18,12 +18,13 @@
  *
  *   1. Every content tool's own not-found/empty mapping fires with NO tool
  *      edit — `read_content` and `get_*` already treat `null` as not-found;
- *      `list_pages` and `search_content` already treat `[]` as empty.
+ *      `list_pages` and `search_content` already answer their empty
+ *      `ItemList` over `[]` (#7167: the routes' own envelopes).
  *   2. "Before any content lookup" (NFR-5) is structural, not asserted —
  *      there is nothing here to look anything up in.
- *   3. `getMcpMdxContentAdapter()`'s `typeof getPageSource === "function"`
- *      capability check (`content-adapter.ts`) passes, so `read_content`
- *      never sees THAT named throw on the fail-closed path.
+ *   3. `readContentDocument`'s `typeof getPageSource === "function"`
+ *      capability check (`@working-theory/content-adapters`) passes, so
+ *      `read_content` never sees THAT named throw on the fail-closed path.
  */
 import type {
   ContentPage,

package/templates/apps/mcp/src/lib/site-config.ts

@@ -0,0 +1,53 @@
+/**
+ * The deployment's `_site.mdx`, read once per content root (#7169).
+ *
+ * `read_content` answers through `readContentDocument` in
+ * `@working-theory/content-adapters`, which takes the parsed site config for
+ * the `HomePage` graph and the `origin` read. That package may not import
+ * `@working-theory/site-config` (`architecture.yaml`), so the read stays with
+ * each app: this is the same reader `apps/api/src/routes/content/get-page.ts`
+ * carries — the one duplication the import rule leaves, kept identical so a
+ * `HomePage` read through the tool is the route's to the byte. The rejected
+ * alternative, `@working-theory/aeo`'s `loadSitewideIdentity`, applies its own
+ * acceptance rules and a parent-directory fallback, which could make the two
+ * differ on an edge site.
+ *
+ * A local read with the client-safe `/schema` entry:
+ * `@working-theory/site-config/server` imports `server-only`, which throws
+ * outside a React Server Components runtime.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  SiteConfigSchema,
+  type SiteConfig,
+} from "@working-theory/site-config/schema";
+import { parse as parseYaml } from "yaml";
+
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+/** `_site.mdx` per content root, read once; `null` when it does not load. */
+const siteConfigByRoot = new Map<string, SiteConfig | null>();
+
+/**
+ * The deployment's `_site.mdx`, validated against `SiteConfigSchema`, or
+ * `undefined` on any failure (absent, unreadable, invalid).
+ */
+export function readSiteConfig(contentRoot: string): SiteConfig | undefined {
+  if (!siteConfigByRoot.has(contentRoot)) {
+    let config: SiteConfig | null = null;
+    try {
+      const raw = readFileSync(join(contentRoot, "_site.mdx"), "utf8");
+      const match = FRONTMATTER_RE.exec(raw);
+      if (match) {
+        const parsed = SiteConfigSchema.safeParse(parseYaml(match[1] ?? ""));
+        if (parsed.success) config = parsed.data;
+      }
+    } catch {
+      // Absent or unreadable — no site.
+    }
+    siteConfigByRoot.set(contentRoot, config);
+  }
+  return siteConfigByRoot.get(contentRoot) ?? undefined;
+}

package/templates/apps/mcp/src/tools/capture_lead.ts

@@ -1,9 +1,18 @@
 /**
- * capture_lead — capture a contact-form lead.
+ * capture_lead — capture a lead: the body `POST /v1/leads/submit` takes.
  *
- * Validates input via Zod, forwards to POST /v1/leads/submit via
- * @working-theory/api-client, and shapes the response into the MCP output schema.
- * No business logic — orchestration lives in apps/api B6.
+ * The tool adopted the API, arguments and results (#7171 — the operator's
+ * decision of 2026-10-19). Its input IS the route's `leadSubmitBodySchema`
+ * (the catalog registers the same shape, so the SDK has already parsed the
+ * arguments against it; the `safeParse` here keeps the stdio path and the
+ * `invalid_input` branch honest), the parsed body is posted as the agent
+ * sent it — no `siteId`, no stamped `source`, no wrapping — and the route's
+ * 201 body `{ id, persisted, email }` comes back unchanged. One addition
+ * survives, because it is deployment attribution rather than an argument:
+ * the spoke marker `payload.site` from `AILK_LEAD_SITE` (#7397), spread LAST
+ * over the agent's `payload` as the site's own writer
+ * (`apps/web/src/lib/lead-write.ts`) does; unset or blank, the payload goes
+ * as sent. No business logic — orchestration lives in apps/api.
  *
  * Paired with captureLeadAction Server Action per ADR 0013.
  */
@@ -11,21 +20,21 @@
 import { apiClient } from "@working-theory/api-client";
 import {
   LEAD_SITE_MARKER_KEY,
-  submitLeadInputSchema,
-  submitLeadOutputSchema,
-  type SubmitLeadInput,
-  type SubmitLeadOutput,
+  leadSubmitBodySchema,
+  leadWriteOutputSchema,
+  type LeadSubmitBody,
+  type LeadWriteOutput,
 } from "@working-theory/validation";
 
 import { visitorForwardHeadersForThisCall } from "../request-context.js";
 
-export { submitLeadInputSchema, submitLeadOutputSchema };
-export type { SubmitLeadInput, SubmitLeadOutput };
+export { leadSubmitBodySchema, leadWriteOutputSchema };
+export type { LeadSubmitBody, LeadWriteOutput };
 
 export async function ailkCaptureLead(
-  input: SubmitLeadInput,
-): Promise<SubmitLeadOutput> {
-  const parsed = submitLeadInputSchema.safeParse(input);
+  input: LeadSubmitBody,
+): Promise<LeadWriteOutput> {
+  const parsed = leadSubmitBodySchema.safeParse(input);
   if (!parsed.success) {
     return {
       ok: false,
@@ -33,21 +42,14 @@ export async function ailkCaptureLead(
     };
   }
 
-  const { name, email, message, phone } = parsed.data;
-  const siteId = process.env.AILK_SITE_ID ?? "default";
-  // The spoke marker (#7397) — unset or blank leaves the payload unmarked.
+  // The spoke marker (#7397) — unset or blank leaves the payload as sent.
   const site = process.env.AILK_LEAD_SITE?.trim();
-  const body = {
-    siteId,
-    source: "mcp",
-    email,
-    payload: {
-      name,
-      ...(message !== undefined && { message }),
-      ...(phone !== undefined && { phone }),
-      ...(site && { [LEAD_SITE_MARKER_KEY]: site }),
-    },
-  };
+  const body = site
+    ? {
+        ...parsed.data,
+        payload: { ...parsed.data.payload, [LEAD_SITE_MARKER_KEY]: site },
+      }
+    : parsed.data;
 
   // #8073 — forward the address the transport trusted (never an identity
   // argument on this tool's own schema) so the hub counts the write in that
@@ -60,5 +62,5 @@ export async function ailkCaptureLead(
     return { ok: false, error: { kind: "api_error", status: res.status } };
   }
 
-  return { ok: true, id: res.body.id, persisted: res.body.persisted };
+  return res.body;
 }