create-ailk 0.20.0 → 0.22.0

package/templates/database/__tests__/consent-source-checkout-migration.test.ts

@@ -0,0 +1,79 @@
+/**
+ * @file consent-source-checkout-migration.test.ts
+ *
+ * DB-free proof of the consent_source_checkout migration's shape (#8765, spec
+ * docs/specs/8765-sign-up-refuses-without-the-spec.md D13, AC-8). Reads the
+ * migration's own text: it drops `consent_grants_source_known` and re-adds it
+ * `NOT VALID` with exactly the values of `CONSENT_SOURCES`, then `VALIDATE`s
+ * it — with no `UPDATE`, `INSERT` or `DELETE`, so the append-only ledger is
+ * never written.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { CONSENT_SOURCES } from "@working-theory/validation";
+
+const MIGRATION = join(
+  __dirname,
+  "..",
+  "migrations",
+  "20261019120000_consent_source_checkout",
+  "migration.sql",
+);
+
+/** The migration's statements, comments stripped, whitespace collapsed. */
+function statements(): string[] {
+  const text = readFileSync(MIGRATION, "utf8")
+    .split("\n")
+    .filter((line) => !line.trimStart().startsWith("--"))
+    .join("\n");
+  return text
+    .split(";")
+    .map((s) => s.replace(/\s+/g, " ").trim())
+    .filter((s) => s.length > 0);
+}
+
+describe("the consent_source_checkout migration (#8765 D13, AC-8)", () => {
+  it("drops the source CHECK, re-adds it NOT VALID, then VALIDATEs it — nothing else", () => {
+    const shapes = statements().map((s) => {
+      if (
+        s ===
+        'ALTER TABLE "consent_grants" DROP CONSTRAINT "consent_grants_source_known"'
+      ) {
+        return "drop";
+      }
+      if (
+        /^ALTER TABLE "consent_grants" ADD CONSTRAINT "consent_grants_source_known" CHECK \(.*\) NOT VALID$/.test(
+          s,
+        )
+      ) {
+        return "add";
+      }
+      if (
+        s ===
+        'ALTER TABLE "consent_grants" VALIDATE CONSTRAINT "consent_grants_source_known"'
+      ) {
+        return "validate";
+      }
+      return `unexpected: ${s}`;
+    });
+    expect(shapes).toEqual(["drop", "add", "validate"]);
+  });
+
+  it("names exactly the eight values of CONSENT_SOURCES, checkout among them", () => {
+    const add = statements().find((s) => s.includes("ADD CONSTRAINT"));
+    const list = add?.match(/CHECK \("source" IN \(([^)]*)\)\)/)?.[1];
+    expect(list).toBeDefined();
+    const values = (list ?? "")
+      .split(",")
+      .map((v) => v.trim().replace(/^'|'$/g, ""));
+    expect(values).toHaveLength(8);
+    expect([...values].sort()).toEqual([...CONSENT_SOURCES].sort());
+    expect(values).toContain("checkout");
+  });
+
+  it("writes no row: no UPDATE, INSERT or DELETE", () => {
+    for (const s of statements())
+      expect(s).not.toMatch(/\b(UPDATE|INSERT|DELETE)\b/i);
+  });
+});

package/templates/database/__tests__/flow-completion-migration.test.ts

@@ -0,0 +1,115 @@
+/**
+ * @file flow-completion-migration.test.ts
+ *
+ * DB-free proof of the flow_completion migration's shape (#8757, spec
+ * docs/specs/8757-a-per-magnet-completion-setting-spec.md D2, AC-2). Reads
+ * the migration's own text: it adds exactly the two columns and three named
+ * CHECKs, each added `NOT VALID` then `VALIDATE`d, and its one `UPDATE` is the
+ * slug backfill between its markers — naming exactly the standard magnets
+ * whose default is `invite` (`STANDARD_MAGNET_COMPLETIONS`). It inserts and
+ * deletes nothing. The live-database half is `flow-completion.db.test.ts`.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { STANDARD_MAGNET_COMPLETIONS } from "@working-theory/validation";
+
+const MIGRATION = join(
+  __dirname,
+  "..",
+  "migrations",
+  "20261018120000_flow_completion",
+  "migration.sql",
+);
+
+const CHECKS = [
+  "flow_definitions_completion_domain",
+  "flow_definitions_checkout_offering_pair",
+  "flow_definitions_checkout_offering_format",
+];
+
+/** The migration's statements, comments stripped, whitespace collapsed. */
+function statements(): string[] {
+  const text = readFileSync(MIGRATION, "utf8")
+    .split("\n")
+    .filter((line) => !line.trimStart().startsWith("--"))
+    .join("\n");
+  return text
+    .split(";")
+    .map((s) => s.replace(/\s+/g, " ").trim())
+    .filter((s) => s.length > 0);
+}
+
+/** The text between the `-- BEGIN completion backfill` / `-- END …` markers. */
+function backfillBlock(): string {
+  const match = /-- BEGIN completion backfill\n([\s\S]*?)-- END completion backfill/.exec(
+    readFileSync(MIGRATION, "utf8"),
+  );
+  if (!match) throw new Error("completion backfill markers not found");
+  return match[1]!;
+}
+
+describe("the flow_completion migration (#8757 D2, AC-2)", () => {
+  it("adds exactly the two columns, the completion default lead", () => {
+    const adds = statements().filter((s) => /^ALTER TABLE "flow_definitions" ADD COLUMN /.test(s));
+    expect(adds).toHaveLength(1);
+    const columns = adds[0]!.split(/ADD COLUMN /).slice(1).map((c) => c.trim().replace(/,$/, ""));
+    expect(columns).toEqual([
+      `"completion" VARCHAR(16) NOT NULL DEFAULT 'lead'`,
+      `"checkout_offering" VARCHAR(40)`,
+    ]);
+  });
+
+  it("adds the three named CHECKs NOT VALID, then VALIDATEs each", () => {
+    const all = statements();
+    const added = all
+      .map((s) => /^ALTER TABLE "flow_definitions" ADD CONSTRAINT "([a-z_]+)" CHECK \(.*\) NOT VALID$/.exec(s)?.[1])
+      .filter((name): name is string => name !== undefined);
+    const validated = all
+      .map((s) => /^ALTER TABLE "flow_definitions" VALIDATE CONSTRAINT "([a-z_]+)"$/.exec(s)?.[1])
+      .filter((name): name is string => name !== undefined);
+    expect(added).toEqual(CHECKS);
+    expect(validated).toEqual(CHECKS);
+    for (const name of CHECKS) {
+      expect(all.findIndex((s) => s.includes(`VALIDATE CONSTRAINT "${name}"`))).toBeGreaterThan(
+        all.findIndex((s) => s.includes(`ADD CONSTRAINT "${name}"`)),
+      );
+    }
+  });
+
+  it("holds exactly one UPDATE, inside the backfill markers, naming the invite defaults", () => {
+    const updates = statements().filter((s) => /\bUPDATE\b/i.test(s));
+    expect(updates).toHaveLength(1);
+    const block = backfillBlock().replace(/\s+/g, " ").trim();
+    expect(block).toBe(updates[0] + ";");
+    const list = /WHERE "slug" IN \(([^)]*)\)/.exec(block)?.[1];
+    const slugs = (list ?? "").split(",").map((s) => s.trim().replace(/^'|'$/g, ""));
+    const invite = Object.entries(STANDARD_MAGNET_COMPLETIONS)
+      .filter(([, completion]) => completion === "invite")
+      .map(([slug]) => slug);
+    expect([...slugs].sort()).toEqual([...invite].sort());
+    expect(block).toContain(`SET "completion" = 'invite'`);
+  });
+
+  it("inserts and deletes nothing", () => {
+    for (const s of statements()) expect(s).not.toMatch(/\b(INSERT|DELETE)\b/i);
+  });
+
+  it("every statement is one of the expected shapes", () => {
+    const unexpected = statements().filter(
+      (s) =>
+        !/^ALTER TABLE "flow_definitions" (ADD COLUMN|ADD CONSTRAINT|VALIDATE CONSTRAINT) /.test(s) &&
+        !/^UPDATE "flow_definitions" SET "completion" = 'invite' WHERE "slug" IN \(/.test(s),
+    );
+    expect(unexpected).toEqual([]);
+  });
+
+  it("schema.prisma declares both fields on FlowDefinition", () => {
+    const prisma = readFileSync(join(__dirname, "..", "inbox", "schema.prisma"), "utf8");
+    const model = /model FlowDefinition \{([\s\S]*?)\n\}/.exec(prisma)?.[1] ?? "";
+    expect(model).toMatch(/\n\s*completion String @default\("lead"\) @db\.VarChar\(16\)\n/);
+    expect(model).toMatch(
+      /\n\s*checkoutOffering String\? @map\("checkout_offering"\) @db\.VarChar\(40\)\n/,
+    );
+  });
+});

package/templates/database/__tests__/flow-completion.db.test.ts

@@ -0,0 +1,136 @@
+/**
+ * @file flow-completion.db.test.ts
+ *
+ * LIVE-DATABASE proof of a magnet's completion columns (#8757, spec
+ * docs/specs/8757-a-per-magnet-completion-setting-spec.md D2, AC-2). Requires
+ * DATABASE_URL pointing at a Postgres with the migrations applied — SKIPS
+ * when DATABASE_URL is unset (the repo convention; the `apps/api Route Tests
+ * (Postgres)` workflow exercises it).
+ *
+ * Uses the `pg` driver directly, in ONE transaction that is rolled back. What
+ * it proves that a mock cannot:
+ *   1. The migration's backfill block, run over magnets at the five slugs,
+ *      leaves `contact` and `form` at `lead` and sets the three process
+ *      magnets to `invite`; a second run changes nothing.
+ *   2. Each CHECK refuses what it names.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { Client } from "pg";
+
+const describeDb = process.env.DATABASE_URL ? describe : describe.skip;
+
+const MIGRATION_SQL = readFileSync(
+  join(__dirname, "..", "migrations", "20261018120000_flow_completion", "migration.sql"),
+  "utf8",
+);
+
+/** The text between the `-- BEGIN completion backfill` / `-- END …` markers. */
+function backfillBlock(sql: string): string {
+  const match = /-- BEGIN completion backfill\n([\s\S]*?)-- END completion backfill/.exec(sql);
+  if (!match?.[1]) throw new Error("completion backfill markers not found");
+  return match[1];
+}
+
+const WS = "wksp_01920000-8757-7000-8000-0000000000c1";
+const SLUGS = ["contact", "onboarding", "request-quote", "job-application", "form"] as const;
+
+describeDb("the magnet completion columns (#8757 D2, AC-2, live DB)", () => {
+  let db: Client;
+
+  beforeAll(async () => {
+    db = new Client({ connectionString: process.env.DATABASE_URL });
+    await db.connect();
+    await db.query("BEGIN");
+  });
+
+  afterAll(async () => {
+    await db.query("ROLLBACK");
+    await db.end();
+  });
+
+  /** Insert one magnet at `slug`, with any of the completion columns. */
+  const insertMagnet = (slug: string, cols: Record<string, unknown> = {}) => {
+    const all: Record<string, unknown> = {
+      site_id: WS,
+      workspace_id: WS,
+      slug,
+      config: JSON.stringify({ steps: [] }),
+      title: `Magnet ${slug}`,
+      status: "draft",
+      updated_at: new Date("2026-10-01T09:00:00.000Z"),
+      ...cols,
+    };
+    const names = Object.keys(all);
+    return db.query<{ id: string }>(
+      `INSERT INTO "flow_definitions" (${names.map((n) => `"${n}"`).join(", ")})
+       VALUES (${names.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING "id"`,
+      names.map((n) => all[n]),
+    );
+  };
+
+  /** Run `run` inside a savepoint; resolve to the violated constraint's name, or null. */
+  const violation = async (run: () => Promise<unknown>): Promise<string | null> => {
+    await db.query("SAVEPOINT attempt");
+    try {
+      await run();
+      await db.query("RELEASE SAVEPOINT attempt");
+      return null;
+    } catch (err) {
+      await db.query("ROLLBACK TO SAVEPOINT attempt");
+      return (err as { constraint?: string }).constraint ?? String(err);
+    }
+  };
+
+  const completions = async () =>
+    Object.fromEntries(
+      (
+        await db.query<{ slug: string; completion: string; checkout_offering: string | null }>(
+          `SELECT "slug", "completion", "checkout_offering" FROM "flow_definitions" WHERE "workspace_id" = $1`,
+          [WS],
+        )
+      ).rows.map((r) => [r.slug, [r.completion, r.checkout_offering]]),
+    );
+
+  it("the backfill sets the three process magnets to invite and leaves contact and form at lead, idempotently", async () => {
+    for (const slug of SLUGS) await insertMagnet(slug);
+    const before = await completions();
+    for (const slug of SLUGS) expect(before[slug]).toEqual(["lead", null]);
+
+    await db.query(backfillBlock(MIGRATION_SQL));
+    const after = await completions();
+    expect(after).toEqual({
+      contact: ["lead", null],
+      form: ["lead", null],
+      onboarding: ["invite", null],
+      "request-quote": ["invite", null],
+      "job-application": ["invite", null],
+    });
+
+    const rerun = await db.query(backfillBlock(MIGRATION_SQL));
+    expect(await completions()).toEqual(after);
+    // The re-run matches the same rows but stores the same values.
+    expect(rerun.rowCount).toBeGreaterThanOrEqual(3);
+  });
+
+  it.each([
+    ["checkout with no offering", { completion: "checkout", checkout_offering: null }, "flow_definitions_checkout_offering_pair"],
+    ["an offering beside lead", { completion: "lead", checkout_offering: "retainer" }, "flow_definitions_checkout_offering_pair"],
+    ["a capitalised key", { completion: "checkout", checkout_offering: "Bad" }, "flow_definitions_checkout_offering_format"],
+    ["an underscored key", { completion: "checkout", checkout_offering: "a_b" }, "flow_definitions_checkout_offering_format"],
+    ["a fourth value", { completion: "other", checkout_offering: null }, "flow_definitions_completion_domain"],
+  ])("refuses %s", async (_label, cols, constraint) => {
+    expect(await violation(() => insertMagnet(`refused-${constraint.length}-${String(cols.completion)}`, cols))).toBe(
+      constraint,
+    );
+  });
+
+  it("accepts checkout with a listed-shape offering", async () => {
+    expect(
+      await violation(() =>
+        insertMagnet("paid-waitlist", { completion: "checkout", checkout_offering: "retainer" }),
+      ),
+    ).toBeNull();
+  });
+});

package/templates/database/__tests__/seed.test.ts

@@ -11,9 +11,14 @@
  */
 
 import {
+  CONTACT_FORM_FLOW_SLUG,
+  contactFormFlowConfig,
+  JOB_APPLICATION_FLOW_SLUG,
+  jobApplicationFlowConfig,
   REQUEST_QUOTE_FLOW_SLUG,
   REQUEST_QUOTE_FLOW_TITLE,
   requestQuoteFlowConfig,
+  STANDARD_MAGNET_COMPLETIONS,
 } from "@working-theory/validation";
 
 import {
@@ -107,8 +112,8 @@ describe("provisionDefaultWorkspace — the request-quote magnet (#8168 D8, C4,
 
     await provisionDefaultWorkspace(prisma);
 
-    expect(flowDefinitionUpsert).toHaveBeenCalledTimes(1);
-    expect(flowDefinitionUpsert).toHaveBeenCalledWith({
+    expect(flowDefinitionUpsert).toHaveBeenCalledTimes(3);
+    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(1, {
       where: {
         siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: REQUEST_QUOTE_FLOW_SLUG },
       },
@@ -121,6 +126,7 @@ describe("provisionDefaultWorkspace — the request-quote magnet (#8168 D8, C4,
         title: REQUEST_QUOTE_FLOW_TITLE,
         status: "draft",
         customersEnabled: true,
+        completion: STANDARD_MAGNET_COMPLETIONS[REQUEST_QUOTE_FLOW_SLUG],
       },
       // Empty: an existing (site_id, slug) row is never overwritten (D8, C6).
       update: {},
@@ -138,3 +144,67 @@ describe("provisionDefaultWorkspace — the request-quote magnet (#8168 D8, C4,
     expect(flowDefinitionUpsert).not.toHaveBeenCalled();
   });
 });
+
+describe("provisionDefaultWorkspace — the Contact form magnet (#8661 D3, AC-1)", () => {
+  it("upserts the default workspace's live Contact form, insert-if-absent", async () => {
+    const { prisma, flowDefinitionUpsert } = makeStubPrisma(0);
+
+    await provisionDefaultWorkspace(prisma);
+
+    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(2, {
+      where: {
+        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: CONTACT_FORM_FLOW_SLUG },
+      },
+      create: {
+        siteId: DEFAULT_WORKSPACE_ID,
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        slug: "contact",
+        config: contactFormFlowConfig,
+        kind: "contact",
+        title: "Contact form",
+        status: "live",
+        customersEnabled: false,
+        completion: STANDARD_MAGNET_COMPLETIONS[CONTACT_FORM_FLOW_SLUG],
+        landingPage: "/contact",
+      },
+      // Empty: a re-run never overwrites the owner's edits.
+      update: {},
+    });
+  });
+
+  it("makes no flowDefinition call when a workspace already exists", async () => {
+    const { prisma, flowDefinitionUpsert } = makeStubPrisma(1);
+
+    await provisionDefaultWorkspace(prisma);
+
+    expect(flowDefinitionUpsert).not.toHaveBeenCalled();
+  });
+});
+
+describe("provisionDefaultWorkspace — the Job application magnet (#8746 D3, AC-2)", () => {
+  it("upserts the default workspace's live Job application, insert-if-absent", async () => {
+    const { prisma, flowDefinitionUpsert } = makeStubPrisma(0);
+
+    await provisionDefaultWorkspace(prisma);
+
+    expect(flowDefinitionUpsert).toHaveBeenNthCalledWith(3, {
+      where: {
+        siteId_slug: { siteId: DEFAULT_WORKSPACE_ID, slug: JOB_APPLICATION_FLOW_SLUG },
+      },
+      create: {
+        siteId: DEFAULT_WORKSPACE_ID,
+        workspaceId: DEFAULT_WORKSPACE_ID,
+        slug: "job-application",
+        config: jobApplicationFlowConfig,
+        kind: "diagnostic",
+        title: "Job application",
+        status: "live",
+        customersEnabled: false,
+        completion: STANDARD_MAGNET_COMPLETIONS[JOB_APPLICATION_FLOW_SLUG],
+        landingPage: "/careers",
+      },
+      // Empty: a re-run never overwrites the owner's edits.
+      update: {},
+    });
+  });
+});

package/templates/database/inbox/schema.prisma

@@ -473,6 +473,18 @@ model FlowDefinition {
   /// `request-quote` magnet is `draft` (never served anonymously) with
   /// `customersEnabled = true`.
   customersEnabled Boolean @default(false) @map("customers_enabled")
+  /// #8757 D1/D2 — what happens after someone submits the magnet: `lead`
+  /// (the thank-you only), `invite` (an account link with the email
+  /// prefilled) or `checkout` (continue to `checkoutOffering`). A column, on
+  /// the `customersEnabled` footing: no seed or config names it. Closed by
+  /// the `flow_definitions_completion_domain` CHECK; the standard defaults are
+  /// the migration's backfill by slug (`STANDARD_MAGNET_COMPLETIONS`).
+  completion String @default("lead") @db.VarChar(16)
+  /// #8757 D1/D2 — the offering key a `checkout` magnet continues to; NULL
+  /// exactly when `completion` is not `checkout`
+  /// (`flow_definitions_checkout_offering_pair`), in the spoke checkout slug
+  /// format (`flow_definitions_checkout_offering_format`).
+  checkoutOffering String? @map("checkout_offering") @db.VarChar(40)
   createdAt DateTime @default(now()) @map("created_at")
   updatedAt DateTime @updatedAt @map("updated_at")
 
@@ -1283,8 +1295,11 @@ model ProjectListing {
 /// would prove nothing once that row is edited, and `statementHash` groups
 /// identical wordings. `locale` is the locale the statement was actually
 /// served in, not the one requested. `purposeId` is the site-config registry
-/// id — the join key across surfaces. Written only by
-/// apps/api/src/services/consent.ts.
+/// id — the join key across surfaces. Two writers: apps/api/src/services/consent.ts
+/// (every source), and the web sign-up hook apps/web/lib/sign-up-agreements.ts
+/// (#8765 D4), which writes only `sign_up` rows (subject `user`) of a user it
+/// creates in the same Better Auth transaction, from evidence the API built
+/// with consent.ts's own functions.
 model ConsentGrant {
   id            String   @id @default(dbgenerated("('cnsnt_'::text || (uuidv7())::text)")) @db.Text
   siteId        String   @map("site_id")

package/templates/database/jest.config.cjs

@@ -1,5 +1,6 @@
 module.exports = {
   preset: "ts-jest",
+  globalSetup: require.resolve("../tools/jest/pin-timezone.cjs"),
   testEnvironment: "node",
   roots: ["<rootDir>"],
   testMatch: ["**/__tests__/**/*.test.ts"],

package/templates/database/migrations/20261018120000_flow_completion/migration.sql

@@ -0,0 +1,52 @@
+-- #8757 — a per-magnet completion setting (spec
+-- docs/specs/8757-a-per-magnet-completion-setting-spec.md D1, D2).
+--
+--   flow_definitions (2 columns) — what happens after someone submits the
+--                    magnet (`completion`: `lead`, `invite` or `checkout`),
+--                    and, for `checkout` only, the offering key it continues
+--                    to. The vocabulary is `FLOW_COMPLETIONS` and
+--                    `flowCheckoutOfferingSchema` in
+--                    packages/validation/src/schemas/flow-completion.ts.
+--
+-- Every existing row reads `completion = 'lead'` from the constant default —
+-- Postgres stores the default in the catalog and rewrites no row for it, so
+-- `contact` and every waitlist get `lead` with no statement. Each CHECK below
+-- is added NOT VALID and then VALIDATEd; every existing row passes each one
+-- (`lead` with a NULL offering).
+--
+-- The one UPDATE is the standard-defaults backfill BY SLUG (the issue's D2,
+-- D7): `onboarding`, `request-quote` and `job-application` → `invite`
+-- (`STANDARD_MAGNET_COMPLETIONS`). A test re-reads the block between the
+-- markers. `updated_at` is Prisma-managed, so the backfill leaves it alone.
+-- A magnet created after this migration takes the column default until the
+-- seed constants carry `completion` (#8759).
+--
+-- Rollout: deploy this migration BEFORE the API code that reads and writes the
+-- columns; code without them fails every magnet read.
+--
+-- Rollback: ALTER TABLE "flow_definitions" DROP COLUMN "completion", DROP
+-- COLUMN "checkout_offering"; (the CHECKs go with them).
+
+-- AlterTable
+ALTER TABLE "flow_definitions" ADD COLUMN     "completion" VARCHAR(16) NOT NULL DEFAULT 'lead',
+ADD COLUMN     "checkout_offering" VARCHAR(40);
+
+-- A magnet completes as a lead, an invite or a checkout, nothing else.
+ALTER TABLE "flow_definitions" ADD CONSTRAINT "flow_definitions_completion_domain"
+  CHECK ("completion" IN ('lead', 'invite', 'checkout')) NOT VALID;
+ALTER TABLE "flow_definitions" VALIDATE CONSTRAINT "flow_definitions_completion_domain";
+
+-- An offering is named exactly when the magnet continues to checkout.
+ALTER TABLE "flow_definitions" ADD CONSTRAINT "flow_definitions_checkout_offering_pair"
+  CHECK (("completion" = 'checkout') = ("checkout_offering" IS NOT NULL)) NOT VALID;
+ALTER TABLE "flow_definitions" VALIDATE CONSTRAINT "flow_definitions_checkout_offering_pair";
+
+-- An offering key the spoke checkout route can serve.
+ALTER TABLE "flow_definitions" ADD CONSTRAINT "flow_definitions_checkout_offering_format"
+  CHECK ("checkout_offering" IS NULL OR "checkout_offering" ~ '^[a-z0-9][a-z0-9-]{0,39}$') NOT VALID;
+ALTER TABLE "flow_definitions" VALIDATE CONSTRAINT "flow_definitions_checkout_offering_format";
+
+-- BEGIN completion backfill
+UPDATE "flow_definitions" SET "completion" = 'invite'
+  WHERE "slug" IN ('onboarding', 'request-quote', 'job-application');
+-- END completion backfill

package/templates/database/migrations/20261019120000_consent_source_checkout/migration.sql

@@ -0,0 +1,27 @@
+-- #8765 — a `checkout` consent source (spec
+-- docs/specs/8765-sign-up-refuses-without-the-spec.md D13).
+--
+--   consent_grants — the source vocabulary gains `checkout`: the buyer's
+--                    terms box on a Stripe Checkout session, recorded by the
+--                    hub webhook against the buyer's Person (D14).
+--
+-- DDL only. The CHECK is replaced, never relaxed: the old one is dropped and
+-- the new one, the seven existing values plus `checkout`, is added NOT VALID
+-- and then VALIDATEd, so every existing row is checked against it. No row is
+-- written, and the append-only triggers do not fire on DDL.
+--
+-- The source vocabulary is packages/validation CONSENT_SOURCES.
+--
+-- Rollout: deploy this migration BEFORE the API code that writes a
+-- `checkout` row; the webhook's insert otherwise fails the CHECK (it never
+-- throws, so the order still completes, but no grant is recorded).
+--
+-- Rollback: ALTER TABLE "consent_grants" DROP CONSTRAINT
+-- "consent_grants_source_known"; then re-add it with the seven values of
+-- 20261014120000_consent_ledger — which fails while any `checkout` row
+-- exists, and the ledger is append-only.
+
+ALTER TABLE "consent_grants" DROP CONSTRAINT "consent_grants_source_known";
+ALTER TABLE "consent_grants" ADD CONSTRAINT "consent_grants_source_known"
+  CHECK ("source" IN ('cookie_banner', 'sign_up', 'magnet', 'account_settings', 'email_unsubscribe', 'api', 'legacy', 'checkout')) NOT VALID;
+ALTER TABLE "consent_grants" VALIDATE CONSTRAINT "consent_grants_source_known";

package/templates/database/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@working-theory/database",
-  "version": "0.41.0",
+  "version": "0.43.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"

package/templates/database/seed.ts

@@ -26,6 +26,14 @@ import "dotenv/config";
 import { basename } from "node:path";
 
 import {
+  CONTACT_FORM_FLOW_SLUG,
+  CONTACT_FORM_FLOW_TITLE,
+  CONTACT_FORM_LANDING_PAGE,
+  contactFormFlowConfig,
+  JOB_APPLICATION_FLOW_SLUG,
+  JOB_APPLICATION_FLOW_TITLE,
+  JOB_APPLICATION_LANDING_PAGE,
+  jobApplicationFlowConfig,
   REQUEST_QUOTE_FLOW_SLUG,
   REQUEST_QUOTE_FLOW_TITLE,
   requestQuoteFlowConfig,
@@ -74,6 +82,13 @@ export type DefaultWorkspacePrismaClient = Pick<
  * backfill finds no workspace and seeds nothing; this is where the default
  * workspace's magnet comes from. Insert-if-absent: an `upsert` with an empty
  * `update`, so an existing `(site_id, slug)` row is never overwritten.
+ *
+ * #8661 D3 — and its live Contact form magnet, the same way, and (#8746 D3)
+ * its live Job application magnet. An existing deployment (a workspace
+ * already present) gets its rows from the seed-presets CLI instead.
+ *
+ * #8759 — each names its #8757 D2 completion: the migration's backfill ran
+ * before this seed and found no rows, so the seed writes the value itself.
  */
 export async function provisionDefaultWorkspace(
   prisma: DefaultWorkspacePrismaClient,
@@ -125,6 +140,51 @@ export async function provisionDefaultWorkspace(
       title: REQUEST_QUOTE_FLOW_TITLE,
       status: "draft",
       customersEnabled: true,
+      completion: "invite",
+    },
+    update: {},
+  });
+
+  await prisma.flowDefinition.upsert({
+    where: {
+      siteId_slug: {
+        siteId: DEFAULT_WORKSPACE_ID,
+        slug: CONTACT_FORM_FLOW_SLUG,
+      },
+    },
+    create: {
+      siteId: DEFAULT_WORKSPACE_ID,
+      workspaceId: DEFAULT_WORKSPACE_ID,
+      slug: CONTACT_FORM_FLOW_SLUG,
+      config: contactFormFlowConfig,
+      kind: "contact",
+      title: CONTACT_FORM_FLOW_TITLE,
+      status: "live",
+      customersEnabled: false,
+      completion: "lead",
+      landingPage: CONTACT_FORM_LANDING_PAGE,
+    },
+    update: {},
+  });
+
+  await prisma.flowDefinition.upsert({
+    where: {
+      siteId_slug: {
+        siteId: DEFAULT_WORKSPACE_ID,
+        slug: JOB_APPLICATION_FLOW_SLUG,
+      },
+    },
+    create: {
+      siteId: DEFAULT_WORKSPACE_ID,
+      workspaceId: DEFAULT_WORKSPACE_ID,
+      slug: JOB_APPLICATION_FLOW_SLUG,
+      config: jobApplicationFlowConfig,
+      kind: "diagnostic",
+      title: JOB_APPLICATION_FLOW_TITLE,
+      status: "live",
+      customersEnabled: false,
+      completion: "invite",
+      landingPage: JOB_APPLICATION_LANDING_PAGE,
     },
     update: {},
   });