create-ailk 0.19.0 → 0.20.0

package/templates/apps/api/src/services/request-confirm.ts

@@ -57,6 +57,8 @@ import { logger } from "@working-theory/observability";
 import { isModuleEnabled } from "../config/modules.js";
 import { prisma } from "../lib/prisma.js";
 
+import { findOrCreatePerson, normalizeTelephone } from "./person.js";
+
 // ─── The credential (spec D5) ──────────────────────────────────────────────
 
 /**
@@ -580,6 +582,56 @@ export async function recordPaymentLink(
     where: { id },
     data: { stripePaymentLinkId: paymentLinkId },
   });
+  // #8435 D5 — only now, with the Payment Link recorded: the Person step can
+  // never strand a spent token without its link (SEC-8435-G).
+  await linkConfirmedCallbackPerson(id);
+}
+
+/**
+ * Link a confirmed callback to its Person (#8435 D5): when the capture did not
+ * (`personId` null — no `payload.email`) and the tenant typed a buyer email on
+ * the confirm form, find or create that email's Person in the callback's own
+ * workspace and stamp it, guarded on `personId: null` so a link a capture
+ * already made is never replaced. Best-effort like every Person step: it never
+ * throws and never changes `recordPaymentLink`'s outcome. Logs the outcome
+ * kind only.
+ */
+async function linkConfirmedCallbackPerson(id: string): Promise<void> {
+  let outcome: "linked" | "skipped" | "failed";
+  try {
+    // fence: global-key — `Callback.id`, the row `recordPaymentLink` just
+    // wrote. The Person it names is found or created in THIS row's own
+    // `workspaceId`, so the link can only ever name a Person of that workspace.
+    const callback = await prisma.callback.findFirst({
+      where: { id },
+      select: { workspaceId: true, buyerEmail: true, name: true, phone: true, personId: true },
+    });
+    if (!callback || callback.personId !== null || callback.buyerEmail === null) {
+      outcome = "skipped";
+    } else {
+      const telephone = normalizeTelephone(callback.phone);
+      const person = await findOrCreatePerson(callback.workspaceId, {
+        email: callback.buyerEmail,
+        name: callback.name,
+        contact: telephone === null ? {} : { telephone },
+      });
+      if (!person.ok) {
+        outcome = person.error.kind === "invalid_email" ? "skipped" : "failed";
+      } else {
+        // fence: global-key — same `Callback.id`; `workspaceId` is the row's
+        // own, and `personId: null` keeps a capture's link.
+        await prisma.callback.updateMany({
+          where: { id, workspaceId: callback.workspaceId, personId: null },
+          data: { personId: person.value.personId },
+        });
+        outcome = "linked";
+      }
+    }
+  } catch {
+    outcome = "failed";
+  }
+  if (outcome === "failed") logger.error({ event: "callback-person", outcome }, "callback person failed");
+  else logger.info({ event: "callback-person", outcome }, "callback person");
 }
 
 /** What the buyer is told, once the tenant has confirmed. */

package/templates/apps/api/src/services/revalidation.ts

@@ -94,9 +94,18 @@ export interface RevalidateTarget {
 
 export interface RevalidateOptions {
   event: "publish" | "unpublish";
+  /**
+   * Waits out one backoff. A test seam (#8418): the publish routes never pass
+   * it, so production always waits on the real timer. A test passes one that
+   * records the delay and resolves at once, so the retry schedule is asserted
+   * as scheduled rather than measured against a loaded runner's clock.
+   *
+   * @internal
+   */
+  sleep?: (ms: number) => Promise<void>;
 }
 
-function sleep(ms: number): Promise<void> {
+function realSleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -125,6 +134,7 @@ export async function notifyRevalidate(
     locale: target.locale,
   });
 
+  const { sleep = realSleep } = options;
   const url = config.CONTENT_REVALIDATE_URL;
   const secret = config.CONTENT_REVALIDATE_SECRET;
 

package/templates/apps/api/vercel.json

@@ -1,6 +1,6 @@
 {
   "version": 2,
-  "ignoreCommand": "[ -n \"$VERCEL_GIT_PREVIOUS_SHA\" ] && cd ../.. && git diff --quiet \"$VERCEL_GIT_PREVIOUS_SHA\" HEAD -- apps/api packages database pnpm-lock.yaml || exit 1",
+  "ignoreCommand": "[ -n \"$VERCEL_GIT_PREVIOUS_SHA\" ] && cd ../.. && git diff --quiet \"$VERCEL_GIT_PREVIOUS_SHA\" HEAD -- apps/api packages database pnpm-lock.yaml package.json pnpm-workspace.yaml turbo.json 'tsconfig*.json' || exit 1",
   "buildCommand": "cd ../.. && pnpm run --filter @working-theory/api build:vercel",
   "installCommand": "cd ../.. && pnpm install --frozen-lockfile",
   "outputDirectory": "public",

package/templates/apps/mcp/CLAUDE.md

@@ -83,7 +83,7 @@ Every tool maps 1:1 to an `apps/api` endpoint. When you change a tool, change th
 
 - **20 in the `TOOLS` array / parity test**: the `TOOLS` array in
   `packages/metadata/src/mcp-tool-catalog.ts` defines 20 anonymous tools; the
-  parity test counts that full array. It also holds the eleven signed-in
+  parity test counts that full array. It also holds the fifteen signed-in
   workspace tools (#3591), which no anonymous view returns — see § The
   signed-in workspace surface below.
 - **19 registered on a KEYLESS deployment, 20 on a commerce-claimed one**
@@ -126,16 +126,24 @@ here. Spec: `docs/specs/3591-tenant-scoped-agent-auth-secure-spec.md` D13–D16.
 - **apps/mcp checks only the key's shape.** The key is attached as the SDK's `req.auth` for that
   request alone and reaches a tool as `extra.authInfo.token`. apps/api is the one place it is
   checked, and its tenant guard and the caller's clamped role decide every answer.
-- **Eleven tools, each a `twin`.** The catalog rows carry `surface: "workspace"`, `tier: "pro"`
+- **Fifteen tools, each a `twin`.** The catalog rows carry `surface: "workspace"`, `tier: "pro"`
   and `modulesAnyOf` (the modules any one of which registers the tool — its twin route's gate):
-  `get_agent_context`, the four message tools, the three submission tools and the three
-  application tools. Each takes its route's params, query and body and returns the route's
+  `get_agent_context`, the four message tools, the three submission tools, the three
+  application tools and (#8514) the two People notes tools, `get_person_notes` and
+  `set_person_notes` — the team's private note on one client, which an agent reads and writes
+  only with the `member-pieces-manage` grant; `set_person_notes` requires the `ifUpdatedAt` it
+  read and is refused `notes_changed` when someone saved since — and (#8516) the two proposals
+  tools, `list_proposals` and `create_proposal`, twinning `GET`/`POST
+  /v1/workspaces/:workspaceId/people/:personId/proposals` with the same grant: a proposal is
+  private to one client, `payments` says whether approval leads to a Stripe page, and an agent's
+  price is refused `proposal_needs_person` (a person prices). Each takes its route's params, query and body and returns the route's
   `data`. They are in the parity guard like every other tool, and never in
   `/.well-known/mcp.json`.
 - **Handlers forward, nothing else.** `workspace-server.ts` resolves each tool to a paid-slice
   handler file (`tools/agent_context.ts`, `inbox_messages.ts`, `inbox_submissions.ts`,
-  `inbox_applications.ts`, all `// oss: false`) through a specifier table, as `server.ts` does.
-  Each calls `@working-theory/api-client`'s `inbox` surface with the key. A refusal from the
+  `inbox_applications.ts`, `person_notes.ts`, `proposals.ts`, all `// oss: false`) through a
+  specifier table, as `server.ts` does. Each calls `@working-theory/api-client`'s `inbox` surface
+  (the notes and proposals tools, its `people` surface) with the key. A refusal from the
   route is an MCP tool error naming the route's `error.code` and HTTP status only.
 - **Never log or return the key.** Don't log or serialise `extra`, `extra.authInfo` or
   `extra.requestInfo` — the SDK puts the raw `authorization` header there.
@@ -211,7 +219,11 @@ Example (lead routing):
 - Don't add a tool without the matching `apps/api` endpoint.
 - Don't put business logic in tool handlers — they're adapters.
 
-Last updated: 2026-10-10 — #8071: `create_booking` and `submit_flow_step` join the HTTP write branch — § The free anonymous tools names its six members, the Booking and Flow rows record it, and § What a spoke's MCP host on Vercel enforces lists the two new daily caps — verified against `apps/mcp/src/http-transport.ts` and `apps/mcp/src/abuse/index.ts`.
+Last updated: 2026-10-14 — #8516: the signed-in workspace surface is fifteen tools — `list_proposals` and `create_proposal` (`tools/proposals.ts`) twin `GET`/`POST /v1/workspaces/:workspaceId/people/:personId/proposals` — verified against `packages/metadata/src/mcp-tool-catalog.ts`, `apps/mcp/src/workspace-server.ts` and `tests/parity/api-parity/kinds/site.ts`.
+
+Prior: 2026-10-13 — #8514: the signed-in workspace surface is thirteen tools — `get_person_notes` and `set_person_notes` (`tools/person_notes.ts`) twin `GET`/`PUT /v1/workspaces/:workspaceId/people/:personId/notes` — verified against `packages/metadata/src/mcp-tool-catalog.ts`, `apps/mcp/src/workspace-server.ts` and `tests/parity/api-parity/kinds/site.ts`.
+
+Prior: 2026-10-10 — #8071: `create_booking` and `submit_flow_step` join the HTTP write branch — § The free anonymous tools names its six members, the Booking and Flow rows record it, and § What a spoke's MCP host on Vercel enforces lists the two new daily caps — verified against `apps/mcp/src/http-transport.ts` and `apps/mcp/src/abuse/index.ts`.
 
 Prior: 2026-10-10 — #8070 (amendment 2): the Vercel entry exports a handler, no `vercel.json`; § Two entrypoints, one boot — the Vercel entry `src/app.ts`, the shared `src/boot.ts`, `MCP_HTTP_STATELESS`, `mcpContentRoot()`, `create_project` withheld on a spoke, and what a spoke's MCP host enforces — verified against `apps/mcp/src/{app,boot,serverless-app,index,http-transport,server}.ts` and `lib/content-adapter.ts`.
 

package/templates/apps/mcp/__tests__/catalog-drift.test.ts

@@ -41,8 +41,29 @@ import {
   startMcpClaimRefresh,
   type McpCommerceClaim,
 } from "../src/lib/commerce-claim.js";
+import { UNSERVED_MCP_TOOLS } from "../src/lib/topology.generated.js";
 import { createMcpServer, listRegisteredTools } from "../src/server.js";
 
+// The topology seam's UNSERVED_MCP_TOOLS (#8070 D7), made switchable the way
+// server.test.ts's AC-8b suite does: a getter returning an override when one
+// is set, else the real module's value, so the 16-state loop below reads
+// this scaffold's own seam ([] in the monorepo and a hub, ["create_project"]
+// in a spoke) and the #8513 D2 describe can force either state regardless.
+const mockSeam: { unserved: readonly string[] | undefined } = {
+  unserved: undefined,
+};
+// eslint-disable-next-line no-restricted-syntax -- the generated topology seam IS the boundary under test (#8513 D2); every other export passes through from the real module
+jest.mock("../src/lib/topology.generated.js", () => {
+  const actual: { UNSERVED_MCP_TOOLS: readonly string[] } =
+    jest.requireActual("../src/lib/topology.generated.js");
+  const mocked = { ...actual };
+  Object.defineProperty(mocked, "UNSERVED_MCP_TOOLS", {
+    enumerable: true,
+    get: () => mockSeam.unserved ?? actual.UNSERVED_MCP_TOOLS,
+  });
+  return mocked;
+});
+
 /** The injected licence reader — same seam `commerce-claim.test.ts` types. */
 type CheckLicenseSeam = NonNullable<
   NonNullable<Parameters<typeof initMcpCommerceClaim>[0]>["checkLicense"]
@@ -125,6 +146,17 @@ function catalogOptionsFor(
   };
 }
 
+/**
+ * The catalog this topology actually serves — the full catalog minus the
+ * seam's own UNSERVED_MCP_TOOLS, read at use (never destructured at module
+ * load) so a mocked override above is seen (#8513 D2, C3).
+ */
+function servedCatalog(options: McpCatalogOptions): McpToolCatalogEntry[] {
+  return getMcpToolCatalog(options).filter(
+    (t) => !UNSERVED_MCP_TOOLS.includes(t.name),
+  );
+}
+
 describe.each(CLAIM_STATES)(
   "MCP catalog ↔ server drift — commerce %s, mode %s, held %j",
   (claim, mode, held) => {
@@ -150,18 +182,18 @@ describe.each(CLAIM_STATES)(
       }
     });
 
-    it("registered tool names equal catalog tool names", () => {
+    it("registered tool names equal the catalog minus this topology's unserved tools", () => {
       const registered = registeredToolsOf(createMcpServer());
       const registeredNames = Object.keys(registered).sort();
-      const catalogNames = getMcpToolCatalog(options)
+      const catalogNames = servedCatalog(options)
         .map((t) => t.name)
         .sort();
       expect(registeredNames).toEqual(catalogNames);
     });
 
-    it("registered tool descriptions equal catalog descriptions", () => {
+    it("registered tool descriptions equal the served catalog's descriptions", () => {
       const registered = registeredToolsOf(createMcpServer());
-      for (const entry of getMcpToolCatalog(options)) {
+      for (const entry of servedCatalog(options)) {
         expect(registered[entry.name]).toBeDefined();
         expect(registered[entry.name]!.description).toBe(entry.description);
       }
@@ -193,6 +225,57 @@ describe.each(CLAIM_STATES)(
   },
 );
 
+describe("MCP catalog ↔ server drift — UNSERVED_MCP_TOOLS subtracts from the served catalog (#8513 D2, AC-2)", () => {
+  const priorEnabledModules = process.env.AILK_ENABLED_MODULES;
+
+  beforeEach(() => {
+    process.env.AILK_ENABLED_MODULES = PAID_MODULES;
+  });
+
+  afterEach(() => {
+    mockSeam.unserved = undefined;
+  });
+
+  afterAll(() => {
+    if (priorEnabledModules === undefined) {
+      delete process.env.AILK_ENABLED_MODULES;
+    } else {
+      process.env.AILK_ENABLED_MODULES = priorEnabledModules;
+    }
+  });
+
+  it("a spoke's seam (['create_project']) withholds it from registration and the served catalog", () => {
+    mockSeam.unserved = ["create_project"];
+    const options = catalogOptionsFor("unclaimed", "warn", []);
+
+    const registeredNames = Object.keys(
+      registeredToolsOf(createMcpServer()),
+    ).sort();
+    const servedNames = servedCatalog(options)
+      .map((t) => t.name)
+      .sort();
+
+    expect(registeredNames).toEqual(servedNames);
+    expect(registeredNames).not.toContain("create_project");
+    expect(servedNames).not.toContain("create_project");
+  });
+
+  it("a hub's seam ([]) registers the full catalog, create_project included", () => {
+    mockSeam.unserved = [];
+    const options = catalogOptionsFor("unclaimed", "warn", []);
+
+    const registeredNames = Object.keys(
+      registeredToolsOf(createMcpServer()),
+    ).sort();
+    const fullCatalogNames = getMcpToolCatalog(options)
+      .map((t) => t.name)
+      .sort();
+
+    expect(registeredNames).toEqual(fullCatalogNames);
+    expect(registeredNames).toContain("create_project");
+  });
+});
+
 describe("MCP catalog ↔ server agreement after a bounded re-read (#7156 AC-1)", () => {
   const priorEnabledModules = process.env.AILK_ENABLED_MODULES;
 
@@ -227,11 +310,11 @@ describe("MCP catalog ↔ server agreement after a bounded re-read (#7156 AC-1)"
     };
     const bootNames = Object.keys(registeredToolsOf(createMcpServer())).sort();
     expect(bootNames).toEqual(
-      getMcpToolCatalog(bootOptions)
+      servedCatalog(bootOptions)
         .map((t) => t.name)
         .sort(),
     );
-    expect(bootNames).toHaveLength(20);
+    expect(bootNames).toHaveLength(20 - UNSERVED_MCP_TOOLS.length);
 
     startMcpClaimRefresh({ checkLicense: resolving({ features: [] }) });
     await jest.advanceTimersByTimeAsync(MCP_CLAIM_REFRESH_MS);
@@ -246,14 +329,18 @@ describe("MCP catalog ↔ server agreement after a bounded re-read (#7156 AC-1)"
       .sort();
     expect(catalogNames).toHaveLength(14);
 
+    const servedNames = servedCatalog(refreshedOptions)
+      .map((t) => t.name)
+      .sort();
+
     const serverNames = Object.keys(
       registeredToolsOf(createMcpServer()),
     ).sort();
-    expect(serverNames).toEqual(catalogNames);
+    expect(serverNames).toEqual(servedNames);
 
     const listedNames = listRegisteredTools()
       .map((t) => t.name)
       .sort();
-    expect(listedNames).toEqual(catalogNames);
+    expect(listedNames).toEqual(servedNames);
   });
 });

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

@@ -0,0 +1,25 @@
+// oss: false
+/**
+ * The signed-in workspace surface's People notes tools (#8514 D8) — the twins
+ * of `apps/api/src/routes/workspaces/people.ts`'s notes pair:
+ *
+ *   get_person_notes  GET /v1/workspaces/:workspaceId/people/:personId/notes
+ *   set_person_notes  PUT /v1/workspaces/:workspaceId/people/:personId/notes
+ *
+ * Each takes the route's params and body (the SDK has already parsed them
+ * against the catalog's input shape, which is the route's own schemas),
+ * forwards the caller's agent key through `@working-theory/api-client`, and
+ * returns the route's answer untouched. apps/api checks the key, the grant and
+ * the workspace; this file only carries the key, and never logs or returns it.
+ */
+
+import { people, type PersonRef } from "@working-theory/api-client";
+import type { PersonNotesPutInput } from "@working-theory/validation";
+
+export function ailkGetPersonNotes(key: string, input: PersonRef) {
+  return people.notes(key, input);
+}
+
+export function ailkSetPersonNotes(key: string, input: PersonRef & PersonNotesPutInput) {
+  return people.setNotes(key, input);
+}

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

@@ -0,0 +1,27 @@
+// oss: false
+/**
+ * The signed-in workspace surface's proposals tools (#8516 D7) — the twins of
+ * `apps/api/src/routes/workspaces/pieces.ts`'s proposals pair:
+ *
+ *   list_proposals   GET  /v1/workspaces/:workspaceId/people/:personId/proposals
+ *   create_proposal  POST /v1/workspaces/:workspaceId/people/:personId/proposals
+ *
+ * Each takes the route's params and body (the SDK has already parsed them
+ * against the catalog's input shape, which is the route's own schemas),
+ * forwards the caller's agent key through `@working-theory/api-client`, and
+ * returns the route's answer untouched. apps/api checks the key, the grant,
+ * the workspace and the money gate (an agent's price is `403
+ * proposal_needs_person`); this file only carries the key, and never logs or
+ * returns it.
+ */
+
+import { people, type PersonRef } from "@working-theory/api-client";
+import type { ProposalCreateBody } from "@working-theory/validation";
+
+export function ailkListProposals(key: string, input: PersonRef) {
+  return people.proposals(key, input);
+}
+
+export function ailkCreateProposal(key: string, input: PersonRef & ProposalCreateBody) {
+  return people.createProposal(key, input);
+}

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

@@ -95,6 +95,22 @@ const WORKSPACE_TOOL_ENTRIES: Record<
     specifier: "./tools/inbox_applications.js",
     exportName: "ailkDecideInboxApplication",
   },
+  get_person_notes: {
+    specifier: "./tools/person_notes.js",
+    exportName: "ailkGetPersonNotes",
+  },
+  set_person_notes: {
+    specifier: "./tools/person_notes.js",
+    exportName: "ailkSetPersonNotes",
+  },
+  list_proposals: {
+    specifier: "./tools/proposals.js",
+    exportName: "ailkListProposals",
+  },
+  create_proposal: {
+    specifier: "./tools/proposals.js",
+    exportName: "ailkCreateProposal",
+  },
 };
 
 async function resolveWorkspaceHandler(

package/templates/apps/web/_gitignore

@@ -0,0 +1,6 @@
+# Next.js build output
+.next/
+next-env.d.ts
+
+# Test coverage
+coverage/

package/templates/apps/web/app/[locale]/(auth)/sign-up/__tests__/sign-up-card.test.tsx

@@ -0,0 +1,165 @@
+/**
+ * Tests for SignUpCard's sign-up agreements (#8438 D13, AC-3).
+ *
+ * Every submit — the password form and each OAuth provider — is gated by
+ * the site's `signUp` agreements, rendered as a `ConsentGroup` below
+ * `AuthCard`. Nothing happens on any entry point until every required
+ * agreement is ticked. The password path also mints the carried-agreement
+ * cookie (`rememberSignUpAgreementsAction`) before calling Better Auth.
+ */
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+
+const mockSignUpEmail = jest.fn();
+const mockSignInSocial = jest.fn();
+jest.mock("better-auth/react", () => ({
+  __esModule: true,
+  createAuthClient: () => ({
+    signUp: { email: (...args: unknown[]) => mockSignUpEmail(...args) },
+    signIn: { social: (...args: unknown[]) => mockSignInSocial(...args) },
+  }),
+}));
+
+const mockRememberAgreements = jest.fn();
+// eslint-disable-next-line no-restricted-syntax -- test-seam mock: the Server Action module is a "use server" boundary; the card only passes it through.
+jest.mock("../sign-up.actions", () => ({
+  __esModule: true,
+  rememberSignUpAgreementsAction: (...args: unknown[]) => mockRememberAgreements(...args),
+}));
+
+import { SignUpCard, type SignUpCardProps } from "../sign-up-card";
+
+const AGREEMENT = {
+  id: "account_terms",
+  required: true,
+  statement: "You agree to our Terms and Privacy Policy.",
+};
+
+function props(overrides: Partial<SignUpCardProps> = {}): SignUpCardProps {
+  return {
+    providers: ["google"],
+    method: "password",
+    next: "/account",
+    signInHref: "/sign-in",
+    labels: {
+      signUpHeading: "Create your account",
+      signUpSubhead: "",
+      signUpSubmit: "Sign up",
+      signUpFooterPrompt: "Already have an account?",
+      signUpFooterLink: "Sign in",
+      ssoPrefix: "Continue with",
+      google: "Google",
+      github: "GitHub",
+      email: "Email",
+      password: "Password",
+      orContinue: "or continue with",
+    },
+    notConfiguredSubhead: "Sign-up is not configured.",
+    errorLabels: { signUpFailed: "Sign-up failed.", providerFailed: "Provider failed." },
+    agreements: [AGREEMENT],
+    agreementPolicies: { terms: "/terms", privacy: "/privacy" },
+    agreementsLegend: "Agreements",
+    ...overrides,
+  };
+}
+
+async function fillAndSubmit(): Promise<void> {
+  const user = userEvent.setup();
+  await user.type(screen.getByTestId("auth-email"), "ada@example.com");
+  await user.type(screen.getByTestId("auth-password"), "correct horse battery staple");
+  await user.click(screen.getByTestId("auth-submit"));
+}
+
+async function tick(purposeId: string): Promise<void> {
+  const user = userEvent.setup();
+  await user.click(screen.getByTestId(`consent-${purposeId}`));
+}
+
+beforeEach(() => {
+  mockSignUpEmail.mockReset().mockResolvedValue({ data: { status: true }, error: null });
+  mockSignInSocial.mockReset().mockResolvedValue({ data: { status: true }, error: null });
+  mockRememberAgreements.mockReset().mockResolvedValue(undefined);
+});
+
+describe("the password submit is gated (AC-3)", () => {
+  it("renders the agreement, unticked, and the card marked disabled", () => {
+    render(<SignUpCard {...props()} />);
+    expect(screen.getByTestId("consent-account_terms")).toHaveAttribute("aria-checked", "false");
+    expect(screen.getByTestId("sign-up-card-gate")).toHaveAttribute("aria-disabled", "true");
+  });
+
+  it("does nothing on submit while the agreement is unticked", async () => {
+    render(<SignUpCard {...props()} />);
+    await fillAndSubmit();
+    expect(mockSignUpEmail).not.toHaveBeenCalled();
+    expect(mockRememberAgreements).not.toHaveBeenCalled();
+  });
+
+  it("mints the carried-agreement cookie, then signs up, once every required agreement is ticked", async () => {
+    render(<SignUpCard {...props()} />);
+    await tick("account_terms");
+    expect(screen.getByTestId("sign-up-card-gate")).toHaveAttribute("aria-disabled", "false");
+    await fillAndSubmit();
+    expect(mockRememberAgreements).toHaveBeenCalledWith("ada@example.com", ["account_terms"]);
+    expect(mockSignUpEmail).toHaveBeenCalledWith({
+      email: "ada@example.com",
+      password: "correct horse battery staple",
+      name: "ada@example.com",
+      callbackURL: "/account",
+    });
+  });
+
+  it("re-disables after unticking", async () => {
+    render(<SignUpCard {...props()} />);
+    await tick("account_terms");
+    await tick("account_terms");
+    expect(screen.getByTestId("sign-up-card-gate")).toHaveAttribute("aria-disabled", "true");
+    await fillAndSubmit();
+    expect(mockSignUpEmail).not.toHaveBeenCalled();
+  });
+
+  it("with two required agreements, both must be ticked", async () => {
+    render(
+      <SignUpCard
+        {...props({
+          agreements: [
+            AGREEMENT,
+            { id: "service_terms", required: true, statement: "You agree to being contacted." },
+          ],
+        })}
+      />,
+    );
+    await tick("account_terms");
+    await fillAndSubmit();
+    expect(mockSignUpEmail).not.toHaveBeenCalled();
+    await tick("service_terms");
+    await fillAndSubmit();
+    expect(mockSignUpEmail).toHaveBeenCalledTimes(1);
+  });
+
+  it("a failed cookie mint still submits — convenience only", async () => {
+    mockRememberAgreements.mockRejectedValue(new Error("no secret"));
+    render(<SignUpCard {...props()} />);
+    await tick("account_terms");
+    await fillAndSubmit();
+    expect(mockSignUpEmail).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("provider buttons are gated too (AC-3)", () => {
+  it("a click on Google does nothing while unticked", async () => {
+    render(<SignUpCard {...props({ method: "sso", providers: ["google"] })} />);
+    const user = userEvent.setup();
+    await user.click(screen.getByTestId("auth-sso-google"));
+    expect(mockSignInSocial).not.toHaveBeenCalled();
+  });
+
+  it("launches the provider once ticked, with no cookie mint", async () => {
+    render(<SignUpCard {...props({ method: "sso", providers: ["google"] })} />);
+    await tick("account_terms");
+    const user = userEvent.setup();
+    await user.click(screen.getByTestId("auth-sso-google"));
+    expect(mockSignInSocial).toHaveBeenCalledWith({ provider: "google", callbackURL: "/account" });
+    expect(mockRememberAgreements).not.toHaveBeenCalled();
+  });
+});

package/templates/apps/web/app/[locale]/(auth)/sign-up/page.tsx

@@ -15,6 +15,11 @@
 
 import { localeHref } from "@working-theory/ui";
 import { AuthCard, type AuthCardLabels } from "@working-theory/ui/blocks";
+import {
+  resolveConsentStatement,
+  SITE_CONSENT_CONFIG_DEFAULTS,
+  signUpAgreements,
+} from "@working-theory/validation";
 import type { Metadata } from "next";
 import { getTranslations } from "next-intl/server";
 import type { ReactElement } from "react";
@@ -79,6 +84,17 @@ export default async function SignUpPage({
     orContinue: t("orContinue"),
   };
 
+  // #8438 D13 — the site's sign-up agreements, resolved to this locale. No
+  // per-site registry row is wired yet (C1), so this always reads the
+  // platform default — the same registry the member Privacy tab and the
+  // account-settings write both read from.
+  const config = SITE_CONSENT_CONFIG_DEFAULTS;
+  const agreements = signUpAgreements(config).map((purpose) => ({
+    id: purpose.id,
+    required: purpose.required,
+    statement: resolveConsentStatement(purpose, locale).statement,
+  }));
+
   return (
     <SignUpCard
       providers={providers}
@@ -91,6 +107,9 @@ export default async function SignUpPage({
         signUpFailed: t("signUpFailed"),
         providerFailed: t("providerFailed"),
       }}
+      agreements={agreements}
+      agreementPolicies={config.policies}
+      agreementsLegend={t("signUpAgreementsLegend")}
     />
   );
 }