create-ailk 0.23.0 → 0.25.1

package/templates/apps/mcp/src/server.ts

@@ -1,343 +0,0 @@
-/**
- * MCP server factory.
- *
- * Creates and configures the McpServer instance with all registered tools.
- * The server is returned unconnected — callers attach a transport (stdio in
- * production, in-memory in tests).
- *
- * Tool names + descriptions + input shapes come from the canonical catalog
- * exported by `@working-theory/metadata` (issue #209). The catalog is the single source
- * of truth shared with `apps/web /.well-known/mcp` for agent discovery.
- * Handlers continue to live in `apps/mcp/src/tools/*` — this module wires
- * each catalog entry to its handler.
- */
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  getMcpToolRegistrations,
-  OSS_DISABLED_TOOLS,
-  type McpCatalogOptions,
-  type McpToolRegistration,
-} from "@working-theory/metadata";
-
-import { isModuleEnabled } from "./config/modules.js";
-import {
-  mcpCommerceClaim,
-  mcpFeatureGateOverride,
-  mcpHeldFeatures,
-} from "./lib/commerce-claim.js";
-import { notFoundError } from "./lib/errors.js";
-import { UNSERVED_MCP_TOOLS } from "./lib/topology.generated.js";
-import { ailkAudit } from "./tools/audit.js";
-import { ailkCaptureLead } from "./tools/capture_lead.js";
-import { ailkCreateProject } from "./tools/create_project.js";
-import { ailkGetBusinessHours } from "./tools/get_business_hours.js";
-import { ailkGetFaq } from "./tools/get_faq.js";
-import { ailkGetLocations } from "./tools/get_locations.js";
-import { ailkGetOfferings } from "./tools/get_offerings.js";
-import { ailkGetPricing } from "./tools/get_pricing.js";
-import { ailkGetSiteInfo } from "./tools/get_site_info.js";
-import { ailkListPages } from "./tools/list_pages.js";
-import { ailkPurchase } from "./tools/purchase.js";
-import { ailkReadContent } from "./tools/read_content.js";
-import { ailkRequestCallback } from "./tools/request_callback.js";
-import { ailkSearchContent } from "./tools/search_content.js";
-import { ailkSubscribeNewsletter } from "./tools/subscribe_newsletter.js";
-
-/**
- * Tool-name → handler map. Each handler accepts the parsed input the SDK
- * passes through after Zod validation against the catalog input shape.
- *
- * Cast via `never` is safe: each handler validates its input via its own
- * Zod parse before doing real work (see apps/mcp/src/tools/*.ts).
- */
-const HANDLERS: Record<string, (input: unknown) => Promise<unknown>> = {
-  start_purchase: (input) => ailkPurchase(input as never),
-  list_pages: (input) => ailkListPages(input as never),
-  read_content: (input) => ailkReadContent(input as never),
-  search_content: (input) => ailkSearchContent(input as never),
-  get_site_info: (input) => ailkGetSiteInfo(input as never),
-  get_business_hours: (input) => ailkGetBusinessHours(input as never),
-  get_locations: (input) => ailkGetLocations(input as never),
-  get_offerings: (input) => ailkGetOfferings(input as never),
-  get_pricing: (input) => ailkGetPricing(input as never),
-  get_faq: (input) => ailkGetFaq(input as never),
-  audit: (input) => {
-    const { slug, type, url } = input as {
-      slug?: string;
-      type?: string;
-      url?: string;
-    };
-    const handlerInput = url !== undefined ? { url } : { slug: slug!, type };
-    return ailkAudit(handlerInput as never);
-  },
-  capture_lead: (input) => ailkCaptureLead(input as never),
-  subscribe_newsletter: (input) => ailkSubscribeNewsletter(input as never),
-  request_callback: (input) => ailkRequestCallback(input as never),
-  create_project: (input) => ailkCreateProject(input as never),
-};
-
-type ToolHandler = (input: unknown) => Promise<unknown>;
-
-/**
- * Module-conditional tool handlers — the FILE-grain half of S1's registration
- * gate (#5182).
- *
- * `shouldRegister` already keeps a paid module's tools out of the registered
- * catalog when the module is absent, but that is a RUNTIME filter: a static
- * `import` of the handler still pins the file into the TYPE graph, so an OSS
- * strip that deletes it reds `tsc`. A literal `await import()` does not help —
- * `import()` defers evaluation, not resolution, so `tsc` resolves the specifier
- * either way and reports TS2307 once the file is gone.
- *
- * The specifier therefore comes from this table rather than being written
- * inline, which is what makes it non-literal at the call site and so
- * unresolvable by `tsc`. The cast in {@link resolveHandler} is the load-bearing
- * line: `import(nonLiteral)` yields `any`, and the cast is the only thing
- * restoring a type at the module boundary.
- *
- * Every entry here is a slice file the strip deletes; every entry's catalog
- * row carries the matching `module` tag, so `shouldRegister` and this table
- * appear or vanish together.
- */
-const MODULE_TOOL_ENTRIES: Record<
-  string,
-  { readonly specifier: string; readonly exportName: string }
-> = {
-  // #4416 — the scheduling twins of GET /v1/schedule/availability and
-  // POST /v1/schedule/book. Anonymous, identity-blind, credential-free: the
-  // scheduling credential lives in apps/api, which these reach via api-client.
-  list_availability: {
-    specifier: "./tools/list_availability.js",
-    exportName: "ailkListAvailability",
-  },
-  get_event_meta: {
-    specifier: "./tools/get_event_meta.js",
-    exportName: "ailkGetEventMeta",
-  },
-  create_booking: {
-    specifier: "./tools/create_booking.js",
-    exportName: "ailkCreateBooking",
-  },
-  // #8843 D5 — the twin of GET /v1/schedule/meetings.
-  list_meetings: {
-    specifier: "./tools/list_meetings.js",
-    exportName: "ailkListMeetings",
-  },
-  // D-48 signal-collectors — the flow engine's MCP twins of GET
-  // /v1/flows/:slug and POST /v1/flows/:slug/steps. Anonymous, identity-blind;
-  // free-anonymous status is now module-gated rather than unconditional.
-  get_flow: { specifier: "./tools/get_flow.js", exportName: "ailkGetFlow" },
-  submit_flow_step: {
-    specifier: "./tools/submit_flow_step.js",
-    exportName: "ailkSubmitFlowStep",
-  },
-};
-
-/**
- * Resolves a tool name to its handler: the statically-imported map first, then
- * the module-conditional table. Called from inside the already-`async`
- * `server.tool` callback so {@link createMcpServer} stays synchronous — seven
- * files call it that way, one of them production (`src/index.ts`), and making
- * it async would rewrite all seven for no gain.
- */
-async function resolveHandler(name: string): Promise<ToolHandler> {
-  const direct = HANDLERS[name];
-  if (direct) return direct;
-
-  const entry = MODULE_TOOL_ENTRIES[name];
-  if (!entry) {
-    throw new Error(`MCP catalog drift: no handler for tool '${name}'`);
-  }
-  const mod = (await import(entry.specifier)) as Record<
-    string,
-    ToolHandler | undefined
-  >;
-  const fn = mod[entry.exportName];
-  if (!fn) {
-    throw new Error(
-      `MCP slice drift: '${entry.specifier}' does not export '${entry.exportName}'`,
-    );
-  }
-  return fn;
-}
-
-/**
- * Tool descriptor returned by {@link listRegisteredTools}. A minimal shape
- * sufficient for callers that need to assert which tools are registered
- * (e.g., the S15a regression test) without depending on the SDK's internal
- * `_registeredTools` field.
- */
-export interface RegisteredToolDescriptor {
-  name: string;
-  description: string;
-}
-
-/**
- * Whether a catalog registration entry should register on this build/boot —
- * four filters:
- *
- *  0. the topology filter (#8070 D7): a name in the generated seam's
- *     `UNSERVED_MCP_TOOLS` is never served — `create_project` on a spoke,
- *     which carries no create-ailk CLI for it to spawn. `[]` on a hub. The
- *     web manifest drops the same list, so the two surfaces agree;
- *  1. the OSS-disabled filter (static per-name set; empty since #5971);
- *  2. the module-presence filter (S1, #5088): a tool tagged with `module`
- *     (e.g. `create_booking` carrying `module: "scheduling"`) registers only
- *     when {@link isModuleEnabled} says its module is present, the same way
- *     its `apps/api` HTTP route is module-conditional in `server.ts` there —
- *     so a tool and its route appear or vanish together, holding API↔MCP
- *     parity;
- *  3. the ADD-ON CLAIM filter (#5971): a tool tagged `addon: "commerce"`
- *     registers only on a deployment that positively holds the `commerce`
- *     licence claim. Deliberately NOT the module filter — D-64/#5796 moved
- *     the commerce primitives off module gating precisely so that adding
- *     commerce to a live site is a licence change that lands no files on its
- *     repo, and "keyless site" / "keyed site" name the LICENCE, not an env
- *     allowlist.
- *
- * The claim is the memoised claim, re-read every `MCP_CLAIM_REFRESH_MS`; this
- * stays synchronous — see `lib/commerce-claim.ts`. {@link isServedNow}
- * re-applies this filter at call time.
- *
- * The LICENCE-FEATURE gate (#7136) is not repeated here: it applies upstream,
- * in `getMcpToolRegistrations()`, through {@link catalogOptionsForThisBoot} —
- * only the catalog knows `MCP_FEATURE_GATE_MODE`. `catalog-drift.test.ts`
- * pins that upstream filter from this side in every claim state.
- */
-function shouldRegister(reg: {
-  name: string;
-  module?: string;
-  addon?: "commerce";
-}): boolean {
-  if (UNSERVED_MCP_TOOLS.includes(reg.name)) return false;
-  if (OSS_DISABLED_TOOLS.has(reg.name)) return false;
-  if (reg.module && !isModuleEnabled(reg.module)) return false;
-  if (reg.addon === "commerce" && mcpCommerceClaim() !== "claimed")
-    return false;
-  return true;
-}
-
-/**
- * Call-time gate (#7315). True when a server built NOW would register this
- * tool — the exact same predicate {@link listRegisteredTools} computes, so
- * the call-time answer and a fresh session's `tools/list` cannot disagree by
- * construction. A session keeps the tool list it registered at `initialize`;
- * this makes each listed entry refuse within `MCP_CLAIM_REFRESH_MS` of a
- * re-read that drops its claim.
- */
-function isServedNow(reg: McpToolRegistration): boolean {
-  return listRegisteredTools().some((current) => current.name === reg.name);
-}
-
-/**
- * The {@link McpCatalogOptions} this boot's claims imply — passed to
- * `getMcpToolRegistrations()` so the upstream catalog filter and
- * {@link shouldRegister} agree by construction rather than by coincidence.
- * Carries the held licence features (#7136); the gate mode is the catalog's
- * `MCP_FEATURE_GATE_MODE` unless a test has overridden it.
- */
-function catalogOptionsForThisBoot(): McpCatalogOptions {
-  const featureGate = mcpFeatureGateOverride();
-  return {
-    addons: { commerce: mcpCommerceClaim() === "claimed" },
-    features: [...mcpHeldFeatures()],
-    ...(featureGate ? { featureGate } : {}),
-  };
-}
-
-/**
- * The one-release warning cycle's boot report (#7136): for every tool this
- * boot serves whose licence `feature` the deployment does not hold, calls
- * `warn` once, naming the tool and the feature, and returns their names.
- *
- * Called ONCE per process from `bootMcp()` (`boot.ts`, which both `index.ts`
- * and the Vercel entry `app.ts` await), after the claim resolves — never
- * from {@link createMcpServer}, which runs once per HTTP session. In refuse
- * mode it finds nothing: the upstream catalog filter has already dropped
- * every such tool, so it needs no mode check of its own. Defaults to
- * `console.warn` — stderr, never stdout, which is the stdio transport's
- * JSON-RPC channel. The message carries two catalog literals and nothing
- * read from the licence.
- */
-export function reportUnlicensedProTools(
-  warn: (message: string) => void = console.warn,
-): string[] {
-  const held = mcpHeldFeatures();
-  const unlicensed = getMcpToolRegistrations(catalogOptionsForThisBoot())
-    .filter(shouldRegister)
-    .filter((reg) => reg.feature !== undefined && !held.has(reg.feature));
-  for (const reg of unlicensed) {
-    warn(
-      `[mcp] licence feature "${reg.feature}" is not held by this deployment — ` +
-        `tool "${reg.name}" is served in this release only; the next release ` +
-        `stops serving it unless the licence includes "${reg.feature}".`,
-    );
-  }
-  return unlicensed.map((reg) => reg.name);
-}
-
-/**
- * Returns the list of tools that {@link createMcpServer} will register, after
- * the OSS catalog filter ({@link OSS_DISABLED_TOOLS}), the module-presence
- * filter and the add-on claim filter are applied. Pure — no server instance
- * is constructed.
- *
- * Consumed by `apps/mcp/__tests__/purchase-disabled.test.ts`, which drives
- * both halves of the claim matrix: `start_purchase` absent on a keyless boot,
- * present on a claimed one.
- */
-export function listRegisteredTools(): RegisteredToolDescriptor[] {
-  return getMcpToolRegistrations(catalogOptionsForThisBoot())
-    .filter(shouldRegister)
-    .map((reg) => ({ name: reg.name, description: reg.description }));
-}
-
-/**
- * Creates a configured McpServer with all AILK tools registered, less any
- * tool this topology does not serve (`UNSERVED_MCP_TOOLS`, #8070 D7), less any
- * tool name in {@link OSS_DISABLED_TOOLS}, less any tool whose `module` is
- * not enabled on this build (S1, #5088), and less any `addon`-tagged tool
- * whose claim this deployment does not hold (#5971) — see
- * {@link shouldRegister}. Every filter is applied defensively here even
- * though the upstream `getMcpToolRegistrations()` already excludes the same
- * entries: a belt-and-braces guard so a regression in the metadata package
- * can't accidentally register something this boot should not serve.
- */
-export function createMcpServer(): McpServer {
-  const server = new McpServer({
-    name: "ailk",
-    version: "0.1.0",
-  });
-
-  for (const reg of getMcpToolRegistrations(catalogOptionsForThisBoot())) {
-    if (!shouldRegister(reg)) {
-      continue;
-    }
-    // Boot-time drift detection is preserved: a registered name must be
-    // resolvable from ONE of the two tables, checked here rather than at first
-    // invocation, so a catalog/handler mismatch still fails at startup.
-    if (!HANDLERS[reg.name] && !MODULE_TOOL_ENTRIES[reg.name]) {
-      throw new Error(`MCP catalog drift: no handler for tool '${reg.name}'`);
-    }
-    server.tool(reg.name, reg.description, reg.inputShape, async (input) => {
-      if (
-        (reg.feature !== undefined || reg.addon !== undefined) &&
-        !isServedNow(reg)
-      ) {
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(notFoundError("Not found")) },
-          ],
-        };
-      }
-      const handler = await resolveHandler(reg.name);
-      const result = await handler(input);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-      };
-    });
-  }
-
-  return server;
-}

package/templates/apps/mcp/src/serverless-app.ts

@@ -1,88 +0,0 @@
-/**
- * The testable part of the Vercel entry (#8070 D2, D5).
- *
- * `src/app.ts` is the thin file Vercel's Node-backend detection finds: it
- * awaits the boot at module level and default-exports the
- * {@link serverlessHandler} for the app. A module-level
- * `await` does not compile under the package's ts-jest CommonJS preset, so
- * everything app.ts does beyond that lives here, where a test can build the
- * same app (`__tests__/app-entry.test.ts`).
- */
-
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import type { FastifyInstance } from "fastify";
-
-import { httpTransportConfigFromEnv, readStatelessEnv } from "./boot.js";
-import { registerHttpTransport } from "./http-transport.js";
-
-/**
- * Trust exactly one proxy hop — the immediate peer — and nothing behind it
- * (D5). Fastify then takes `request.ip` from the LAST `X-Forwarded-For`
- * entry, the address Vercel's edge saw, and a value a caller writes earlier
- * in the header cannot move it.
- *
- * A function, not `trustProxy: 1`: Fastify 5.12 treats a numeric hop count as
- * trust-nothing ("hop-count-only trust cannot validate the immediate peer"),
- * so `1` would silently key every caller on the edge's address. A hop-only
- * function is safe here for the reason Fastify's warning names: a Vercel
- * function cannot be reached except through Vercel's edge, so its immediate
- * peer is always the edge. It would NOT be safe on a host a client can reach
- * directly — which is why the long-running entry (`buildHttpTransportApp`)
- * sets no `trustProxy` at all.
- *
- * Trusting hop 0 also makes `request.host` and `request.protocol` follow
- * `X-Forwarded-Host` / `X-Forwarded-Proto`. Nothing in apps/mcp reads either
- * today; anything that starts to must remember they come from the edge.
- */
-export function trustOneHop(_address: string, hop: number): boolean {
-  return hop === 0;
-}
-
-/**
- * The Fastify options the Vercel entry builds its app with: no logger, and
- * {@link trustOneHop} — so the per-IP rate limit and the daily caps key on
- * the real caller. That holds for the topology the sites deploy: the MCP host
- * name points straight at the Vercel project. A second proxy in front
- * (Cloudflare in proxied mode, a rewrite from another Vercel project) would
- * make every caller that proxy's address.
- */
-export const SERVERLESS_FASTIFY_OPTIONS = {
-  logger: false,
-  trustProxy: trustOneHop,
-} as const;
-
-/**
- * Register the MCP HTTP transport on the Vercel entry's app, from the
- * environment. Stateless unless `MCP_HTTP_STATELESS` says otherwise (D1): a
- * stateful transport keeps its sessions in one instance's memory, which a
- * multi-instance host cannot honour. The port is read and ignored — Vercel
- * calls the exported {@link serverlessHandler} and nothing listens.
- */
-export async function configureServerlessApp(
-  app: FastifyInstance,
-): Promise<void> {
-  const { port: _port, ...config } = httpTransportConfigFromEnv();
-  await registerHttpTransport(app, {
-    ...config,
-    stateless: readStatelessEnv(true),
-  });
-}
-
-/**
- * The `(req, res)` function the Vercel entry default-exports (#8070 D2,
- * amendment 2). Vercel's Node runtime accepts a request function, an object of
- * web handlers, or an `http.Server` the module starts listening — a Fastify
- * instance is none of these, and exporting one answered every request with a
- * 500. `app.server` is the `http.Server` Fastify builds without listening;
- * emitting `request` on it is Fastify's own request path, so routing,
- * `trustProxy` and every hook behave as on a listening server. The app must
- * already be `ready()`.
- */
-export function serverlessHandler(
-  app: FastifyInstance,
-): (req: IncomingMessage, res: ServerResponse) => void {
-  return (req, res) => {
-    app.server.emit("request", req, res);
-  };
-}

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

@@ -1,127 +0,0 @@
-/**
- * audit — runs the AEO Layer 1 scoring engine against a single page.
- *
- * Pure read: imports runAudit from @working-theory/aeo (ADR 0011). No auth required.
- * The adapter (audit-single-page) resolves URL or slug to a filesystem read;
- * no fetch() is called anywhere in this file or the adapter.
- *
- * Input:  { slug, type? } | { url }
- *   slug branch — lowercase [a-z0-9-]+ slug; type optional (defaults BlogPosting)
- *   url branch  — absolute URL on the AILK installation's own domain only
- *                 (same-origin check uses AILK_BASE_URL || NEXT_PUBLIC_BASE_URL)
- *
- * Output: { score, perRule, perPage, meta }
- *   score    — 0–100 overall
- *   perRule  — per-rule breakdown (id, name, weight, status, evidence?, advice?)
- *   perPage  — per-page summary (slug, type, score)
- *   meta     — { auditedAt, ruleSet, locale }
- *
- * Session/scope: none — read-only public content.
- */
-
-import {
-  runAudit,
-  alwaysFails,
-  alwaysPasses,
-  entityMarkup,
-  faqHowtoIncentive,
-  jsonldValidity,
-  offerOnPricedPage,
-  policiesPresent,
-  schemaCoverage,
-  taxCodeWhenStripeTax,
-  type Rule,
-} from "@working-theory/aeo";
-import {
-  auditInputSchema,
-  auditOutputSchema,
-  type AuditInput,
-  type AuditOutput,
-} from "@working-theory/validation";
-
-import {
-  buildSinglePageAuditInput,
-  type SinglePageInput,
-} from "../lib/audit-single-page.js";
-
-export { auditInputSchema, auditOutputSchema };
-export type { AuditInput, AuditOutput };
-
-/**
- * The MCP audit's rule set. Imported from the @working-theory/aeo public API;
- * must not be re-implemented here.
- *
- * It is NOT identical to `packages/aeo/src/cli/index.ts`'s RULES array, and
- * this comment used to claim it was. The two differ by exactly one member:
- * the CLI carries `schemaCorrectness` (10 rules) and this set does not
- * (9 rules). Everything else — including the two `always-*` example rules —
- * is shared.
- *
- * The cause is mechanical, not a choice: `packages/aeo/src/index.ts` — the
- * package's PUBLIC barrel — does not re-export `schemaCorrectness`, while
- * `rules/index.ts` (the internal barrel the CLI imports from) exports all of
- * them. A rule absent from the public barrel is unreachable from any app.
- * Closing that gap would change this tool's `score` on every page, which is
- * why #5949 left it alone; it is recorded as that spec's residual 1.
- */
-const RULES: Rule[] = [
-  alwaysPasses,
-  alwaysFails,
-  schemaCoverage,
-  jsonldValidity,
-  faqHowtoIncentive,
-  entityMarkup,
-  policiesPresent,
-  offerOnPricedPage,
-  taxCodeWhenStripeTax,
-];
-
-/**
- * audit handler.
- *
- * Accepts an optional `contentRoot` override for testing. When omitted,
- * resolves the content root relative to cwd (supports ESM runtime).
- *
- * `projectRoot` is the matching seam for the project.yaml the readiness rules'
- * Stripe-Tax signal is read from (#5949 D9); it likewise defaults to cwd.
- */
-export async function ailkAudit(
-  input: AuditInput,
-  contentRoot?: string,
-  projectRoot?: string,
-): Promise<AuditOutput> {
-  auditInputSchema.parse(input);
-
-  // Cast: AuditInput's Zod-inferred optional fields include `undefined` in
-  // their union, but SinglePageInput uses exactOptionalPropertyTypes where `?`
-  // means "absent." The auditInputSchema.parse above guarantees validity.
-  const auditInput = await buildSinglePageAuditInput(
-    input as unknown as SinglePageInput,
-    contentRoot,
-    projectRoot,
-  );
-  const report = runAudit(auditInput, RULES);
-
-  const result: AuditOutput = {
-    score: report.score,
-    perRule: report.perRule.map((r) => ({
-      ruleId: r.id,
-      name: r.id, // rule description not on PerRuleResult; use id as name
-      weight: r.weight,
-      status: r.pass ? "pass" : "fail",
-      ...(r.evidence !== undefined && { evidence: r.evidence }),
-    })),
-    perPage: report.perPage.map((p) => ({
-      slug: p.slug,
-      type: p.type,
-      score: p.score,
-    })),
-    meta: {
-      auditedAt: report.meta.auditedAt,
-      ruleSet: `${report.meta.schemaVersion}/${report.meta.registryVersion}`,
-      locale: auditInput.locale,
-    },
-  };
-
-  return auditOutputSchema.parse(result);
-}

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

@@ -1,64 +0,0 @@
-/**
- * capture_lead — capture a contact-form lead.
- *
- * 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.
- *
- * Paired with captureLeadAction Server Action per ADR 0013.
- */
-
-import { apiClient } from "@working-theory/api-client";
-import {
-  LEAD_SITE_MARKER_KEY,
-  submitLeadInputSchema,
-  submitLeadOutputSchema,
-  type SubmitLeadInput,
-  type SubmitLeadOutput,
-} from "@working-theory/validation";
-
-import { visitorForwardHeadersForThisCall } from "../request-context.js";
-
-export { submitLeadInputSchema, submitLeadOutputSchema };
-export type { SubmitLeadInput, SubmitLeadOutput };
-
-export async function ailkCaptureLead(
-  input: SubmitLeadInput,
-): Promise<SubmitLeadOutput> {
-  const parsed = submitLeadInputSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      ok: false,
-      error: { kind: "invalid_input", issues: parsed.error.issues },
-    };
-  }
-
-  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.
-  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 }),
-    },
-  };
-
-  // #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
-  // visitor's own rate-limit bucket rather than this MCP host's.
-  const headers = visitorForwardHeadersForThisCall();
-  const res = headers
-    ? await apiClient.leads.submit(body, { headers })
-    : await apiClient.leads.submit(body);
-  if (!res.ok) {
-    return { ok: false, error: { kind: "api_error", status: res.status } };
-  }
-
-  return { ok: true, id: res.body.id, persisted: res.body.persisted };
-}