create-ailk 0.19.1 → 0.21.0

package/templates/apps/web/app/[locale]/contact/__tests__/contact-magnet-page.test.tsx

@@ -0,0 +1,347 @@
+/**
+ * contact/page.tsx over the Contact form magnet (#8661 D6) — AC-3 and AC-5.
+ *
+ * Unlike `page-renderer-migration.test.tsx`, this suite renders the REAL
+ * `LeadCaptureForm` and binds the REAL `captureLeadAction`, so the hidden
+ * `source` input, the fields and a submit are all visible. Mocked
+ * boundaries: `@working-theory/api-client` (`flows.get`, `leads.captureStatus`,
+ * `leads.submit`), `next/headers`, `next-intl/server` (over the real English
+ * catalog), the `_site.mdx` contact-email read, and the page-renderer's
+ * content loaders (injected).
+ */
+import React from "react";
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import {
+  CONTACT_FORM_TERMS_STATEMENT,
+  contactFormFlowConfig,
+  type FlowConfig,
+} from "@working-theory/validation";
+
+jest.mock("next/navigation", () => ({
+  __esModule: true,
+  notFound: jest.fn(() => {
+    throw new Error("NEXT_NOT_FOUND");
+  }),
+}));
+
+jest.mock("next-mdx-remote/rsc", () => ({
+  __esModule: true,
+  MDXRemote: ({ source }: { source: string }) =>
+    React.createElement("div", { "data-testid": "mdx-rendered" }, source),
+}));
+
+jest.mock("@working-theory/api-client", () => ({
+  flows: { get: jest.fn() },
+  leads: { captureStatus: jest.fn(), submit: jest.fn() },
+  visitorForwardHeaders: () => undefined,
+}));
+
+jest.mock("next/headers", () => ({
+  __esModule: true,
+  headers: jest.fn().mockResolvedValue({ get: () => null }),
+  cookies: jest.fn().mockResolvedValue({ get: () => undefined }),
+}));
+
+// The real English catalog, so the page's own strings render as they ship.
+jest.mock("next-intl/server", () => {
+  const messages = jest.requireActual("../../../../messages/en.json") as Record<
+    string,
+    Record<string, unknown>
+  >;
+  return {
+    getTranslations: async (arg: string | { namespace: string }) => {
+      const ns = messages[typeof arg === "string" ? arg : arg.namespace] ?? {};
+      return (key: string, values?: Record<string, string>) =>
+        String(ns[key] ?? key).replace(/\{(\w+)\}/g, (m, name: string) => values?.[name] ?? m);
+    },
+  };
+});
+
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock: the real read is a node:fs frontmatter parse of content/_site.mdx; narrowest possible scope
+jest.mock("../site-contact-email", () => ({
+  readSiteContactEmail: jest.fn().mockReturnValue(undefined),
+}));
+
+import { flows, leads } from "@working-theory/api-client";
+import { localeHref } from "@working-theory/ui";
+
+import { contactFormFromConfig } from "../contact-form-magnet";
+import * as pageModule from "../page";
+import ContactPage from "../page";
+
+const mockFlowsGet = flows.get as jest.Mock;
+const mockCaptureStatus = leads.captureStatus as jest.Mock;
+const mockSubmit = leads.submit as jest.Mock;
+
+type FieldStep = Extract<FlowConfig["steps"][number], { type: "field" }>;
+
+const source = {
+  frontmatter: {
+    type: "ContactPage" as const,
+    slug: "contact",
+    title: "Contact Us",
+    description: "Get in touch.",
+  },
+  body: "",
+};
+
+/** The seeded config with its subject relabelled. */
+function configWithSubjectLabel(label: string): FlowConfig {
+  const config = JSON.parse(JSON.stringify(contactFormFlowConfig)) as FlowConfig;
+  const subject = (config.steps[0] as FieldStep).fields.find((f) => f.name === "subject")!;
+  subject.copy.label = { en: label };
+  return config;
+}
+
+const served = (config: FlowConfig) => ({ ok: true, status: 200, body: config });
+
+async function renderPage(sections: unknown[] = []) {
+  const element = await ContactPage({
+    params: Promise.resolve({ locale: "en" }),
+    getMdxSource: jest.fn().mockResolvedValue(source),
+    getPageSections: jest.fn().mockResolvedValue(sections),
+  });
+  return render(element);
+}
+
+function sourceInput(): HTMLInputElement | null {
+  return document.querySelector<HTMLInputElement>("input[name='source']");
+}
+
+function fieldNames(): string[] {
+  return Array.from(
+    screen.getByTestId("lead-capture-form").querySelectorAll<HTMLElement>("[data-testid^='field-']"),
+  ).map((el) => el.dataset.testid!.slice("field-".length));
+}
+
+async function tickAndSubmit(values: Record<string, string>) {
+  for (const [name, value] of Object.entries(values)) {
+    fireEvent.change(screen.getByTestId(`field-${name}`), { target: { value } });
+  }
+  fireEvent.click(screen.getByTestId("contact-consent"));
+  await act(async () => {
+    fireEvent.submit(screen.getByTestId("lead-capture-form"));
+  });
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  mockCaptureStatus.mockResolvedValue({
+    ok: true,
+    status: 200,
+    body: { ok: true, data: { contact: true, newsletter: false } },
+  });
+  mockSubmit.mockResolvedValue({ ok: true, body: { id: "lead_1", persisted: "db" } });
+});
+
+describe("contact/page — rendering (AC-3)", () => {
+  it("is rendered on every request, never ISR", () => {
+    expect(pageModule.dynamic).toBe("force-dynamic");
+    expect("revalidate" in pageModule).toBe(false);
+  });
+
+  it("renders the served magnet's fields, and stamps the post flow:contact", async () => {
+    mockFlowsGet.mockResolvedValue(served(configWithSubjectLabel("Topic")));
+
+    await renderPage();
+
+    expect(mockFlowsGet).toHaveBeenCalledWith("contact");
+    expect(fieldNames()).toEqual(["name", "email", "subject", "message"]);
+    expect(screen.getByTestId("lead-capture-form")).toHaveTextContent("Topic");
+    expect(sourceInput()).toHaveAttribute("type", "hidden");
+    expect(sourceInput()!.value).toBe("flow:contact");
+  });
+
+  it("the magnet wins over a content section's declared fields", async () => {
+    mockFlowsGet.mockResolvedValue(served(configWithSubjectLabel("Topic")));
+
+    await renderPage([
+      {
+        id: "contact-form",
+        type: "contact-form",
+        data: { fields: [{ name: "company", label: "Company", type: "text" }] },
+      },
+    ]);
+
+    expect(fieldNames()).toEqual(["name", "email", "subject", "message"]);
+    expect(screen.queryByTestId("field-company")).toBeNull();
+  });
+
+  it("two requests with two configs render two labels (no caching)", async () => {
+    mockFlowsGet.mockResolvedValueOnce(served(configWithSubjectLabel("Topic")));
+    const first = await renderPage();
+    expect(screen.getByTestId("lead-capture-form")).toHaveTextContent("Topic");
+    first.unmount();
+
+    mockFlowsGet.mockResolvedValueOnce(served(configWithSubjectLabel("Reason")));
+    await renderPage();
+    const form = screen.getByTestId("lead-capture-form");
+    expect(form).toHaveTextContent("Reason");
+    expect(form).not.toHaveTextContent("Topic");
+  });
+
+  it("links Terms, Privacy Policy and Working Agreement in the statement", async () => {
+    mockFlowsGet.mockResolvedValue(served(contactFormFlowConfig));
+
+    await renderPage();
+
+    expect(screen.getByTestId("consent-policy-link-terms")).toHaveAttribute(
+      "href",
+      localeHref("en", "/terms"),
+    );
+    expect(screen.getByTestId("consent-policy-link-privacy")).toHaveAttribute(
+      "href",
+      localeHref("en", "/privacy"),
+    );
+    expect(screen.getByTestId("consent-policy-link-working_agreement")).toHaveAttribute(
+      "href",
+      localeHref("en", "/working-agreement"),
+    );
+  });
+
+  it("a magnet-driven post reaches leads.submit as flow:contact with its subject", async () => {
+    mockFlowsGet.mockResolvedValue(served(contactFormFlowConfig));
+
+    await renderPage();
+    await tickAndSubmit({ name: "Ada", email: "ada@example.com" });
+
+    await waitFor(() => expect(mockSubmit).toHaveBeenCalledTimes(1));
+    expect(mockSubmit.mock.calls[0][0]).toMatchObject({ source: "flow:contact" });
+  });
+});
+
+describe("contact/page — fallback (AC-5)", () => {
+  const builtIn = contactFormFromConfig(contactFormFlowConfig, "en")!;
+
+  it.each([
+    ["answers 404", () => mockFlowsGet.mockResolvedValue({ ok: false, status: 404, body: {} })],
+    ["rejects", () => mockFlowsGet.mockRejectedValue(new Error("ECONNREFUSED"))],
+    [
+      "serves a config the form cannot use",
+      () => {
+        const config = JSON.parse(JSON.stringify(contactFormFlowConfig)) as FlowConfig;
+        const step = config.steps[0] as FieldStep;
+        step.fields = step.fields.filter((f) => f.name !== "name");
+        mockFlowsGet.mockResolvedValue(served(config));
+      },
+    ],
+  ])("flows.get %s → the built-in form, posted as web", async (_label, arrange) => {
+    arrange();
+
+    await renderPage();
+
+    const form = screen.getByTestId("lead-capture-form");
+    expect(fieldNames()).toEqual(builtIn.fields.map((f) => f.name));
+    for (const field of builtIn.fields) expect(form).toHaveTextContent(field.label);
+    const subject = builtIn.fields.find((f) => f.name === "subject")!;
+    const native = form.querySelector("select");
+    if (native) {
+      const values = Array.from(native.querySelectorAll("option"))
+        .map((o) => o.value)
+        .filter(Boolean);
+      expect(values).toEqual(
+        subject.options!.map((o) => (typeof o === "string" ? o : o.value)),
+      );
+    }
+    expect(
+      document.getElementById("lead-capture-consent-statement")!.textContent,
+    ).toBe(CONTACT_FORM_TERMS_STATEMENT.replace(/\[([^\]]+)\]\([a-z_]+\)/g, "$1"));
+    expect(sourceInput()).toBeNull();
+
+    await tickAndSubmit({ name: "Ada", email: "ada@example.com" });
+
+    await waitFor(() => expect(mockSubmit).toHaveBeenCalledTimes(1));
+    expect(mockSubmit.mock.calls[0][0]).toMatchObject({ source: "web" });
+  });
+
+  it("with no magnet, a section's declared fields still apply", async () => {
+    mockFlowsGet.mockResolvedValue({ ok: false, status: 404, body: {} });
+
+    await renderPage([
+      {
+        id: "contact-form",
+        type: "contact-form",
+        data: {
+          fields: [
+            { name: "name", label: "Name", type: "text" },
+            { name: "email", label: "Email", type: "email" },
+            { name: "company", label: "Company", type: "text" },
+          ],
+          submitLabel: "Request a demo",
+        },
+      },
+    ]);
+
+    expect(fieldNames()).toEqual(["name", "email", "company"]);
+    expect(screen.getByTestId("contact-submit")).toHaveTextContent("Request a demo");
+  });
+
+  it("the built-in form takes its labels from the contact catalog and the section's copy", async () => {
+    mockFlowsGet.mockResolvedValue({ ok: false, status: 404, body: {} });
+    const messages = jest.requireActual("../../../../messages/en.json") as {
+      contact: Record<string, string>;
+    };
+
+    await renderPage([
+      {
+        id: "contact-form",
+        type: "contact-form",
+        data: { fields: [], submitLabel: "Say hello", successMessage: "Got it, thanks." },
+      },
+    ]);
+
+    const form = screen.getByTestId("lead-capture-form");
+    expect(form).toHaveTextContent(messages.contact.nameLabel!);
+    expect(form).toHaveTextContent(messages.contact.messageLabel!);
+    expect(screen.getByTestId("contact-submit")).toHaveTextContent("Say hello");
+
+    await tickAndSubmit({ name: "Ada", email: "ada@example.com" });
+    await waitFor(() => expect(document.body).toHaveTextContent("Got it, thanks."));
+  });
+
+  it("a magnet's submit label wins, and the section's success message still applies", async () => {
+    mockFlowsGet.mockResolvedValue(served(contactFormFlowConfig));
+
+    await renderPage([
+      {
+        id: "contact-form",
+        type: "contact-form",
+        data: { fields: [], submitLabel: "Say hello", successMessage: "Got it, thanks." },
+      },
+    ]);
+
+    const form = screen.getByTestId("lead-capture-form");
+    expect(screen.getByTestId("contact-submit")).toHaveTextContent(
+      contactFormFromConfig(contactFormFlowConfig, "en")!.submitLabel!,
+    );
+
+    await tickAndSubmit({ name: "Ada", email: "ada@example.com" });
+    await waitFor(() => expect(document.body).toHaveTextContent("Got it, thanks."));
+  });
+});
+
+describe("contact/page — the column look (#8661 D12)", () => {
+  it("a column section gets the stacked look and an enabled Send", async () => {
+    mockFlowsGet.mockResolvedValue(served(contactFormFlowConfig));
+
+    await renderPage([
+      {
+        id: "contact",
+        type: "contact-form",
+        data: { variant: "column", headline: "Contact Us", description: "Say hello.", fields: [] },
+      },
+    ]);
+
+    expect(screen.getByTestId("lead-capture-form")).toHaveAttribute("data-look", "column");
+    expect(screen.getByTestId("contact-submit")).toBeEnabled();
+  });
+
+  it("a standard page keeps Send disabled until ticked", async () => {
+    mockFlowsGet.mockResolvedValue(served(contactFormFlowConfig));
+
+    await renderPage();
+
+    expect(screen.getByTestId("lead-capture-form")).not.toHaveAttribute("data-look");
+    expect(screen.getByTestId("contact-submit")).toBeDisabled();
+  });
+});

package/templates/apps/web/app/[locale]/contact/__tests__/contact.actions.test.ts

@@ -51,6 +51,8 @@ const VALID_FIELDS = {
   name: "Jane Smith",
   email: "jane@example.com",
   message: "I am interested in your services.",
+  // #8661 D8 — the terms box is checked on the server too.
+  consent: "true",
 };
 
 const INITIAL_STATE = null;
@@ -369,3 +371,74 @@ describe("captureLeadAction — visitor forwarding (#7394)", () => {
     expect(mockSubmit.mock.calls[0]).toHaveLength(1);
   });
 });
+
+// ─── #8661 D8 — the terms box and the source stamp ──────────────────────────
+
+describe("captureLeadAction — consent and source (#8661 D8)", () => {
+  const { consent: _consent, ...UNTICKED } = VALID_FIELDS;
+
+  it("no consent → a consent field error, and nothing is sent", async () => {
+    const result = await captureLeadAction(INITIAL_STATE, makeFormData(UNTICKED));
+
+    expect(result).toEqual({
+      kind: "error",
+      fieldErrors: { consent: expect.any(String) },
+    });
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("no consent and no name → both errors", async () => {
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...UNTICKED, name: "" }),
+    );
+
+    expect(result).toMatchObject({ kind: "error" });
+    const fieldErrors = (result as { fieldErrors: Record<string, string> }).fieldErrors;
+    expect(Object.keys(fieldErrors).sort()).toEqual(["consent", "name"]);
+    expect(mockSubmit).not.toHaveBeenCalled();
+  });
+
+  it("a ticked flow:contact post carries the source and the subject", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...VALID_FIELDS, source: "flow:contact", subject: "Support" }),
+    );
+
+    expect(result).toEqual({ kind: "success" });
+    expect(mockSubmit).toHaveBeenCalledTimes(1);
+    const body = mockSubmit.mock.calls[0][0] as {
+      source: string;
+      payload: Record<string, unknown>;
+    };
+    expect(body.source).toBe("flow:contact");
+    expect(body.payload.subject).toBe("Support");
+  });
+
+  it.each(["flow:other", "flow:onboarding", "admin", "WEB"])(
+    "an unknown source (%s) is sent as web",
+    async (source) => {
+      mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+      await captureLeadAction(INITIAL_STATE, makeFormData({ ...VALID_FIELDS, source }));
+
+      expect((mockSubmit.mock.calls[0][0] as { source: string }).source).toBe("web");
+    },
+  );
+
+  it("the conversational intake submits with no consent field", async () => {
+    mockSubmit.mockResolvedValueOnce({ ok: true, body: { id: "lead_1", persisted: "db" } });
+
+    const result = await captureLeadAction(
+      INITIAL_STATE,
+      makeFormData({ ...UNTICKED, source: "conversational-intake" }),
+    );
+
+    expect(result).toEqual({ kind: "success" });
+    expect((mockSubmit.mock.calls[0][0] as { source: string }).source).toBe(
+      "conversational-intake",
+    );
+  });
+});

package/templates/apps/web/app/[locale]/contact/__tests__/page-renderer-migration.test.tsx

@@ -55,6 +55,7 @@ jest.mock("@working-theory/ui", () => ({
   LeadCaptureForm: (props: {
     fields?: Array<{ name: string }>;
     submitLabel?: string;
+    text?: { submit?: string };
     fallbackEmail?: string;
     termsHref: string;
   }) =>
@@ -69,7 +70,8 @@ jest.mock("@working-theory/ui", () => ({
       React.createElement(
         "button",
         { "data-testid": "contact-submit" },
-        props.submitLabel ?? "Send",
+        // The real block falls back to its copy's submit label.
+        props.submitLabel ?? props.text?.submit ?? "Send",
       ),
     ),
   ContactFallback: (props: { email?: string; text?: { noEmail?: string } }) =>
@@ -181,14 +183,14 @@ describe("ContactPage — snapshot regression", () => {
   it("empty state renders deterministic HTML (renderPage empty-state + the form after it)", async () => {
     const { container } = await renderWith(null);
     expect(container.innerHTML).toMatchInlineSnapshot(
-      `"<main id="main"><h1>Contact</h1><p data-testid="section-empty-state">Contact page content coming soon.</p></main><div data-testid="lead-capture-form" data-fields="" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send</button></div>"`,
+      `"<main id="main"><h1>Contact</h1><p data-testid="section-empty-state">Contact page content coming soon.</p></main><div data-testid="lead-capture-form" data-fields="name,email,subject,message" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send message</button></div>"`,
     );
   });
 
   it("populated state renders deterministic HTML (renderPage sections + the form after it)", async () => {
     const { container } = await renderWith([]);
     expect(container.innerHTML).toMatchInlineSnapshot(
-      `"<script type="application/ld+json" data-testid="json-ld">{"@context":"https://schema.org","@type":"ContactPage","inLanguage":"en","name":"Contact Us","description":"Get in touch.","mainEntity":{"@type":"ContactPoint","contactType":"customer support"}}</script><main id="main"><div><h1>Contact Us</h1><p data-testid="contact-description" class="mt-block-tight text-lead">Get in touch.</p></div><div data-testid="section-renderer" data-section-count="0"></div></main><div data-testid="lead-capture-form" data-fields="" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send</button></div>"`,
+      `"<script type="application/ld+json" data-testid="json-ld">{"@context":"https://schema.org","@type":"ContactPage","inLanguage":"en","name":"Contact Us","description":"Get in touch.","mainEntity":{"@type":"ContactPoint","contactType":"customer support"}}</script><main id="main"><div><h1>Contact Us</h1><p data-testid="contact-description" class="mt-block-tight text-lead">Get in touch.</p></div><div data-testid="section-renderer" data-section-count="0"></div></main><div data-testid="lead-capture-form" data-fields="name,email,subject,message" data-fallback-email="" data-terms-href="/en/terms"><button data-testid="contact-submit">Send message</button></div>"`,
     );
   });
 });

package/templates/apps/web/app/[locale]/contact/contact-form-magnet.ts

@@ -0,0 +1,77 @@
+/**
+ * contactFormFromConfig — a Contact form magnet's config, as the shared
+ * `LeadCaptureForm` block renders it (#8661 D6).
+ *
+ * Reads the config's first step, which must be a `field` step (a config that
+ * opens with any other step is not a contact form). Answers `null` unless that
+ * step holds fields named `name` and `email`, because `captureLeadAction` needs both;
+ * the page then falls back (section fields, else the built-in config).
+ *
+ * Each `text`, `email`, `tel`, `url`, `textarea` or `select` field is mapped,
+ * in order. `name` and `email` sit side by side (`colSpan: 1`, the built-in
+ * pairing); every other field runs full width. The step's first `consent`
+ * field is the terms statement (its label), and its `copy.cta` the submit
+ * label. Other `consent` fields and `address` fields are not rendered.
+ *
+ * Copy resolves with the one LocalizedString rule every flow surface shares
+ * (`resolveLocalizedString`). Pure: no fetch, no React.
+ */
+import type { ContactFormField } from "@working-theory/ui";
+import { resolveLocalizedString, type FlowConfig } from "@working-theory/validation";
+
+export interface ContactFormView {
+  fields: ContactFormField[];
+  /** The step's first consent field's label — `[Label](key)` tokens intact. */
+  consentStatement?: string;
+  /** The step's `copy.cta`. */
+  submitLabel?: string;
+}
+
+type FieldStep = Extract<FlowConfig["steps"][number], { type: "field" }>;
+type FieldDef = FieldStep["fields"][number];
+
+const RENDERED_TYPES = ["text", "email", "tel", "url", "textarea", "select"] as const;
+type RenderedType = (typeof RENDERED_TYPES)[number];
+
+function isRendered(type: FieldDef["inputType"]): type is RenderedType {
+  return (RENDERED_TYPES as readonly string[]).includes(type);
+}
+
+export function contactFormFromConfig(
+  config: FlowConfig,
+  locale: string,
+): ContactFormView | null {
+  const step = config.steps[0];
+  if (step?.type !== "field") return null;
+  const names = new Set(step.fields.map((f) => f.name));
+  if (!names.has("name") || !names.has("email")) return null;
+
+  const resolve = (value: Record<string, string>): string =>
+    resolveLocalizedString(value, locale, config.defaultLocale);
+
+  const fields: ContactFormField[] = [];
+  for (const field of step.fields) {
+    if (!isRendered(field.inputType)) continue;
+    fields.push({
+      name: field.name,
+      type: field.inputType,
+      label: resolve(field.copy.label),
+      required: field.required ?? false,
+      ...(field.copy.placeholder !== undefined && {
+        placeholder: resolve(field.copy.placeholder),
+      }),
+      ...(field.copy.help !== undefined && { helpText: resolve(field.copy.help) }),
+      ...(field.options !== undefined && {
+        options: field.options.map((o) => ({ value: o.value, label: resolve(o.label) })),
+      }),
+      colSpan: field.name === "name" || field.name === "email" ? 1 : 2,
+    });
+  }
+
+  const consent = step.fields.find((f) => f.inputType === "consent");
+  return {
+    fields,
+    ...(consent !== undefined && { consentStatement: resolve(consent.copy.label) }),
+    ...(step.copy.cta !== undefined && { submitLabel: resolve(step.copy.cta) }),
+  };
+}

package/templates/apps/web/app/[locale]/contact/contact-form-text.ts

@@ -20,6 +20,7 @@ type ContactTextKey =
   | "successMessage"
   | "genericError"
   | "consentStatement"
+  | "consentRequired"
   | "unavailableHeading"
   | "unavailableBody"
   | "unavailableNoEmail";
@@ -43,6 +44,7 @@ export function contactFormText(t: ContactTranslator): LeadCaptureFormText {
     success: t("successMessage"),
     genericError: t("genericError"),
     consentStatement: t("consentStatement"),
+    consentRequired: t("consentRequired"),
     unavailableHeading: t("unavailableHeading"),
     unavailableBody: t("unavailableBody", KEEP_EMAIL_PLACEHOLDER),
     unavailableNoEmail: t("unavailableNoEmail"),

package/templates/apps/web/app/[locale]/contact/contact.actions.ts

@@ -36,6 +36,15 @@
  * (`ailkCaptureLead`). Absent (the real `<form>` never sets it) → defaults
  * to `"web"`, unchanged from before.
  *
+ * Source allow-list and terms (#8661 D8): `/contact` stamps a submission it
+ * drew from the Contact form magnet with a hidden `source` of
+ * `"flow:contact"`, so it lands as an Inbox submission of that magnet. The
+ * field is visitor-controlled, so only `"web"`, `"conversational-intake"` and
+ * `"flow:contact"` are kept; anything else is sent as `"web"`. And the terms
+ * box is checked here, not only by the client: unless the source is the
+ * intake (which renders no box), a post without `consent=true` answers a
+ * `consent` field error, merged with the schema's, and nothing is sent.
+ *
  * Visitor forwarding (#7394): on a spoke whose API is a hub, the call
  * carries the visitor's IP and the spoke's `AILK_VISITOR_FORWARD_KEY`
  * (server-only, never `NEXT_PUBLIC_`) via `visitorForwardHeaders`, so the
@@ -47,8 +56,14 @@
 
 import { leads, visitorForwardHeaders } from "@working-theory/api-client";
 import { LEAD_CAPTURE_HONEYPOT, type LeadCaptureFormState } from "@working-theory/ui";
-import { submitLeadInputSchema } from "@working-theory/validation";
-import { headers } from "next/headers";
+import {
+  CONTACT_FORM_FLOW_SLUG,
+  flowLeadSource,
+  submitLeadInputSchema,
+} from "@working-theory/validation";
+import { cookies, headers } from "next/headers";
+
+import { consentVisitorHeader, readConsentVisitor } from "../../../lib/consent-visitor";
 
 const GENERIC_ERROR = "Something went wrong, please try again.";
 
@@ -63,6 +78,16 @@ const RESERVED_FIELDS = new Set([
   "source",
 ]);
 const MAX_EXTRA_FIELDS = 20;
+
+/** The only sources a form post may stamp (#8661 D8); anything else is `"web"`. */
+const ALLOWED_SOURCES = new Set([
+  "web",
+  "conversational-intake",
+  flowLeadSource(CONTACT_FORM_FLOW_SLUG),
+]);
+const INTAKE_SOURCE = "conversational-intake";
+/** The server's terms-error text. The form block shows its own copy for this key. */
+const CONSENT_REQUIRED = "Please accept the terms to send your message.";
 const MAX_EXTRA_FIELD_LENGTH = 2000;
 
 /**
@@ -110,15 +135,25 @@ export async function captureLeadAction(
     phone: formData.get("phone") ?? undefined,
   };
 
+  const posted = formData.get("source");
+  const source =
+    typeof posted === "string" && ALLOWED_SOURCES.has(posted) ? posted : "web";
+
+  const fieldErrors: Record<string, string> = {};
+  if (source !== INTAKE_SOURCE && formData.get("consent") !== "true") {
+    fieldErrors.consent = CONSENT_REQUIRED;
+  }
+
   const parsed = submitLeadInputSchema.safeParse(raw);
   if (!parsed.success) {
-    const fieldErrors: Record<string, string> = {};
     for (const issue of parsed.error.issues) {
       const field = String(issue.path[0] ?? "form");
       if (!fieldErrors[field]) {
         fieldErrors[field] = issue.message;
       }
     }
+  }
+  if (!parsed.success || Object.keys(fieldErrors).length > 0) {
     return { kind: "error", fieldErrors };
   }
 
@@ -127,7 +162,6 @@ export async function captureLeadAction(
 
   const { name, email, message, phone } = parsed.data;
   const siteId = process.env.AILK_SITE_ID ?? "default";
-  const source = (formData.get("source") as string | null) || "web";
   const body = {
     siteId,
     source,
@@ -151,6 +185,16 @@ export async function captureLeadAction(
     // No request scope to read — submit without forwarding.
   }
 
+  // #8438 D12 — the banner's visitor id, so a later form submit links its
+  // cookie choices to the client record this submit creates or resolves
+  // (D11). Absent or invalid → no header, exactly as before this unit.
+  try {
+    const visitorId = readConsentVisitor(await cookies());
+    if (visitorId) init = { headers: { ...(init?.headers ?? {}), ...consentVisitorHeader(visitorId) } };
+  } catch {
+    // No request scope to read — submit with no visitor-link header.
+  }
+
   try {
     const res = init ? await leads.submit(body, init) : await leads.submit(body);
     if (!res.ok) {