create-ailk 0.6.0 → 0.7.0

package/templates/apps/web/app/error-fallback.tsx

@@ -2,9 +2,17 @@
 "use client";
 // Shared base for all per-segment error boundaries in apps/web.
 // Each boundary supplies flow-specific heading and body copy; this component
-// owns the token-sourced styling and the reset button.
+// owns the layout and the reset button, composed from @working-theory/ui
+// primitives (#6514).
+//
+// app/error.tsx renders under the pass-through root layout, outside
+// app/[locale]/layout.tsx — the only other importer of globals.css — so this
+// module imports the stylesheet itself; without it the primitives' token
+// classes would render unstyled at the root boundary.
+import "./globals.css";
+
 import { clientError } from "@working-theory/page-renderer/edge";
-import { tokens } from "@working-theory/theme";
+import { Button, Heading, Text } from "@working-theory/ui/primitives";
 import type { ReactElement } from "react";
 import { useEffect } from "react";
 
@@ -15,44 +23,6 @@ export interface ErrorFallbackProps {
   body: string;
 }
 
-const styles = {
-  main: {
-    background: tokens.colors.light.bg,
-    color: tokens.colors.light.fg,
-    minHeight: "100vh",
-    display: "flex",
-    flexDirection: "column" as const,
-    alignItems: "center",
-    justifyContent: "center",
-    padding: tokens.radius.lg,
-    gap: tokens.radius.md,
-  },
-  heading: {
-    fontSize: "1.5rem",
-    lineHeight: tokens.lineHeight.md,
-    color: tokens.colors.light.errorFg,
-    background: tokens.colors.light.errorBg,
-    padding: `${tokens.radius.sm} ${tokens.radius.md}`,
-    borderRadius: tokens.radius.sm,
-    margin: 0,
-  },
-  body: {
-    fontSize: "1rem",
-    lineHeight: tokens.lineHeight.md,
-    margin: 0,
-  },
-  button: {
-    fontSize: "1rem",
-    lineHeight: tokens.lineHeight.md,
-    background: tokens.colors.light.brand,
-    color: tokens.colors.light.bg,
-    border: "none",
-    borderRadius: tokens.radius.sm,
-    padding: `${tokens.radius.sm} ${tokens.radius.md}`,
-    cursor: "pointer",
-  },
-} as const;
-
 export function ErrorFallback({
   error,
   reset,
@@ -64,12 +34,14 @@ export function ErrorFallback({
   }, [error]);
 
   return (
-    <main style={styles.main}>
-      <h1 style={styles.heading}>{heading}</h1>
-      <p style={styles.body}>{body}</p>
-      <button type="button" onClick={reset} style={styles.button}>
+    <main className="flex min-h-screen flex-col items-center justify-center gap-4 bg-(--color-bg) p-card text-(--color-fg)">
+      <Heading level={1} visual={3}>
+        {heading}
+      </Heading>
+      <Text>{body}</Text>
+      <Button type="button" onClick={reset}>
         Try again
-      </button>
+      </Button>
     </main>
   );
 }

package/templates/apps/web/app/not-found.tsx

@@ -1,48 +1,24 @@
 /* eslint-disable no-restricted-syntax -- i18n-allow: not-found boundary renders outside the [locale] intl provider; translations unavailable at this segment (ADR 0019) */
 // Next.js App Router not-found boundary. Renders for any route that calls
 // notFound() or when no route matches. Server Component by default.
-import { tokens } from "@working-theory/theme";
-import type { ReactElement } from "react";
+//
+// This boundary renders under the pass-through root layout, outside
+// app/[locale]/layout.tsx — the only other importer of globals.css — so it
+// imports the stylesheet itself; without it the primitives' token classes
+// would render unstyled here (#6514).
+import "./globals.css";
 
-const styles = {
-  main: {
-    background: tokens.colors.light.bg,
-    color: tokens.colors.light.fg,
-    minHeight: "100vh",
-    display: "flex",
-    flexDirection: "column" as const,
-    alignItems: "center",
-    justifyContent: "center",
-    padding: tokens.radius.lg,
-    gap: tokens.radius.md,
-  },
-  heading: {
-    fontSize: "1.5rem",
-    lineHeight: tokens.lineHeight.md,
-    margin: 0,
-  },
-  body: {
-    fontSize: "1rem",
-    lineHeight: tokens.lineHeight.md,
-    margin: 0,
-  },
-  link: {
-    color: tokens.colors.light.brand,
-    fontSize: "1rem",
-    lineHeight: tokens.lineHeight.md,
-  },
-} as const;
+import { Heading, Link, Text } from "@working-theory/ui/primitives";
+import type { ReactElement } from "react";
 
 export default function NotFound(): ReactElement {
   return (
-    <main style={styles.main}>
-      <h1 style={styles.heading}>We couldn&apos;t find that page</h1>
-      <p style={styles.body}>
-        The page you are looking for does not exist or may have moved.
-      </p>
-      <a href="/" style={styles.link}>
-        Return home
-      </a>
+    <main className="flex min-h-screen flex-col items-center justify-center gap-4 bg-(--color-bg) p-card text-(--color-fg)">
+      <Heading level={1} visual={3}>
+        We couldn&apos;t find that page
+      </Heading>
+      <Text>The page you are looking for does not exist or may have moved.</Text>
+      <Link href="/">Return home</Link>
     </main>
   );
 }

package/templates/apps/web/app/og/route.tsx

@@ -15,6 +15,12 @@
  *  - Strip control characters \x00–\x1F and \x7F from title and schemaType
  *  - Cap title at 200 chars, schemaType at 50 chars
  *  - If sanitization yields an empty title, fall back to static PNG redirect
+ *
+ * Composition exception (#6514): this route renders raw elements with inline
+ * `style` objects, and is deliberately left out of the page-surface
+ * `no-raw-html-elements` scope in eslint.config.ts. Satori (next/og) rasterises
+ * a JSX tree to PNG — it reads only inline styles, supports no stylesheet or
+ * Tailwind classes, and cannot render @working-theory/ui components.
  */
 import { clientError } from "@working-theory/page-renderer/edge";
 import { tokens } from "@working-theory/theme";

package/templates/apps/web/eslint.config.mjs

@@ -28,6 +28,9 @@ export default tseslint.config(
       "**/dist/**",
       "**/generated/**",
       "**/node_modules/**",
+      // fumadocs-mdx's generated collection code (#6680) — present only with
+      // the docs-blog module, and never hand-edited.
+      "**/.source/**",
     ],
   },
   js.configs.recommended,

package/templates/apps/web/instrumentation.ts

@@ -0,0 +1,14 @@
+/**
+ * Next.js instrumentation hook — runs once per server instance at boot.
+ *
+ * Registers the durable home of a renewed licence key (#6677 DD-6) before any
+ * request resolves the licence. Node runtime only: the store reaches the
+ * database through Prisma, which the Edge runtime cannot load.
+ */
+
+export async function register(): Promise<void> {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    const { registerLicenseKeyStore } = await import("./lib/license-key-store");
+    await registerLicenseKeyStore();
+  }
+}

package/templates/apps/web/lib/__tests__/site-theme.test.ts

@@ -4,11 +4,28 @@
  * This is the end-to-end claim the wiring makes — a site declares a theme and
  * the built page renders in those colours — asserted on the actual repo file
  * rather than a fixture, so deleting the `theme:` block would fail here.
+ *
+ * Every expectation is DERIVED from whichever `_site.mdx` the test reads, never
+ * hard-coded (#6460). This file is snapshotted into `create-ailk`'s
+ * `templates/`, so it runs against TWO different `_site.mdx` files: this
+ * monorepo's, and the scaffold's own. Hard-coded values made it a snapshot of
+ * one tree's palette masquerading as a round-trip test — green here, red in a
+ * scaffold whose theme differs, which is exactly what happened when the base
+ * scaffold moved to the black-on-white foundation. It also meant a CUSTOMER who
+ * took the file's own invitation to "declare only what you change" got a red
+ * suite for editing their own colours.
+ *
+ * Deriving keeps every claim the hard-coded form made — the mapping is applied,
+ * the values reach the CSS, and nothing else moves — while making all three
+ * true of any declared palette. Deleting the `theme:` block still fails, on the
+ * `toBeDefined()` below.
  */
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdtempSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+import { parse as parseYaml } from "yaml";
+
 import { PartialColorPaletteSchema } from "@working-theory/site-config/schema";
 import { siteColorTokenMap, themeToCssVarsBothModes } from "@working-theory/theme";
 
@@ -26,6 +43,46 @@ function darkBlock(css: string): string {
   return css.slice(css.indexOf(':root[data-theme="dark"]'));
 }
 
+/** The two modes, as the palette and the emitted CSS both name them. */
+const MODES = ["light", "dark"] as const;
+
+/**
+ * The `theme.colors` block exactly as the `_site.mdx` under test declares it —
+ * raw SLOT names (`text`, `primary`), not token keys. Read with the same
+ * frontmatter parse `site-theme.ts` uses, so the test cannot pass against a
+ * file the implementation reads differently.
+ */
+function declaredColors(): Partial<Record<(typeof MODES)[number], Record<string, string>>> {
+  const raw = readFileSync(join(REPO_CONTENT_ROOT, "_site.mdx"), "utf8");
+  const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw);
+  const parsed = parseYaml(frontmatter?.[1] ?? "") as
+    | { theme?: { colors?: Record<string, Record<string, string>> } }
+    | null;
+  return parsed?.theme?.colors ?? {};
+}
+
+/**
+ * The CSS custom property a token key is emitted as — `fgOnBrand` →
+ * `--color-fg-on-brand`. The colon in every call site anchors the match, so
+ * `--color-surface` never collides with `--color-surface-secondary`.
+ */
+function cssVar(tokenKey: string): string {
+  return `--color-${tokenKey.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}`;
+}
+
+/** `{ [tokenKey]: value }` for one mode's declared slots, mapping applied. */
+function declaredTokens(mode: (typeof MODES)[number]): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [slot, value] of Object.entries(declaredColors()[mode] ?? {})) {
+    const tokenKey = siteColorTokenMap[slot as keyof typeof siteColorTokenMap];
+    // A slot with no token counterpart cannot reach the CSS at all —
+    // `siteThemeToBrandTokens` throws on it, which the schema's own tests
+    // cover. Nothing to assert about it here.
+    if (typeof tokenKey === "string") out[tokenKey] = value;
+  }
+  return out;
+}
+
 describe("loadSiteBrandTokens — the real content/_site.mdx", () => {
   const originalRoot = process.env.AILK_CONTENT_ROOT;
 
@@ -38,35 +95,93 @@ describe("loadSiteBrandTokens — the real content/_site.mdx", () => {
     else process.env.AILK_CONTENT_ROOT = originalRoot;
   });
 
-  it("translates the declared theme into the token overlay", () => {
-    expect(loadSiteBrandTokens()).toEqual({
-      colors: {
-        light: { bg: "#fdfcfa", fg: "#1c1917" },
-        dark: { bg: "#0c0a09" },
-      },
-    });
+  it("translates every colour the file declares into its mapped token", () => {
+    const overlay = loadSiteBrandTokens();
+    // The `theme:` block exists and produced an overlay — the claim the
+    // hard-coded form made by naming values, kept without naming them.
+    expect(overlay).toBeDefined();
+
+    // `BrandTokenOverrides` is deliberately `Readonly<Record<string, unknown>>`
+    // — `@working-theory/theme` cannot name the overlay's shape without
+    // pinning it to one token set — so the test states the shape it asserts
+    // about. The hard-coded form sidestepped this by comparing whole objects.
+    const colors = (overlay?.["colors"] ?? {}) as Partial<
+      Record<(typeof MODES)[number], Record<string, string>>
+    >;
+
+    let asserted = 0;
+    for (const mode of MODES) {
+      const expectedTokens = declaredTokens(mode);
+      // Exactly the declared slots, nothing invented and nothing dropped.
+      expect(colors[mode] ?? {}).toEqual(expectedTokens);
+      asserted += Object.keys(expectedTokens).length;
+    }
+    // Non-vacuity: a file that declared nothing would satisfy the loop above.
+    expect(asserted).toBeGreaterThan(0);
   });
 
   it("reaches the emitted CSS custom properties", () => {
     const brand = loadSiteBrandTokens();
     const css = themeToCssVarsBothModes(brand ? { brand } : {});
-
-    expect(lightBlock(css)).toContain("--color-bg: #fdfcfa;");
-    expect(lightBlock(css)).toContain("--color-fg: #1c1917;");
-    expect(darkBlock(css)).toContain("--color-bg: #0c0a09;");
+    const blockFor = { light: lightBlock(css), dark: darkBlock(css) };
+
+    let asserted = 0;
+    for (const mode of MODES) {
+      for (const [tokenKey, value] of Object.entries(declaredTokens(mode))) {
+        expect(blockFor[mode]).toContain(`${cssVar(tokenKey)}: ${value};`);
+        asserted += 1;
+      }
+    }
+    expect(asserted).toBeGreaterThan(0);
   });
 
   it("changes exactly the declared variables and nothing else", () => {
     const brand = loadSiteBrandTokens();
     const themed = themeToCssVarsBothModes(brand ? { brand } : {});
-    const expected = themeToCssVarsBothModes()
-      // light block — the two declared light colours
-      .replace("--color-bg: #ffffff;", "--color-bg: #fdfcfa;")
-      .replace("--color-fg: #030712;", "--color-fg: #1c1917;")
-      // dark block — the one declared dark colour
-      .replace("--color-bg: #0a0a0a;", "--color-bg: #0c0a09;");
-
-    expect(themed).toBe(expected);
+
+    // Rebuild the expectation from the DEFAULT CSS by overwriting, per mode
+    // block, only the variables this site declares. Anything the overlay
+    // touched beyond them makes the final equality fail — which is the whole
+    // point of this case.
+    const base = themeToCssVarsBothModes();
+    const rewritten = { light: lightBlock(base), dark: darkBlock(base) };
+    for (const mode of MODES) {
+      for (const [tokenKey, value] of Object.entries(declaredTokens(mode))) {
+        const pattern = new RegExp(`(${cssVar(tokenKey)}: )[^;]+;`);
+        // The variable must exist in the default block for the overwrite to
+        // mean anything — a replace with no target would weaken the equality
+        // below into a tautology. Presence is the right check rather than
+        // "the text changed": a site may legitimately declare a value that
+        // already MATCHES the default (the black-on-white base declares
+        // `bg: #ffffff`, which light mode already is), and that no-op is
+        // correct, not vacuous.
+        expect(rewritten[mode]).toMatch(pattern);
+        rewritten[mode] = rewritten[mode].replace(pattern, `$1${value};`);
+      }
+
+      // `--color-surface-raised` is DERIVED, not independent: the emitter
+      // resolves it from `surfaceSecondary` in light mode and from `surface`
+      // in dark (`packages/theme/src/theme-to-css.ts`, and the rule is
+      // documented at `site-theme.ts`'s header). So a site that declares
+      // either of those moves it too, and the equality below has to account
+      // for it — re-derived here from whatever the block now carries rather
+      // than restated as a value, so the two cannot drift.
+      //
+      // Kept inside the total equality instead of excluded from it: this
+      // variable is SUPPOSED to move, and excluding it would stop the test
+      // noticing if it ever stopped moving.
+      const derivedFrom = mode === "light" ? "surfaceSecondary" : "surface";
+      const sourceValue = new RegExp(`${cssVar(derivedFrom)}: ([^;]+);`).exec(
+        rewritten[mode],
+      )?.[1];
+      expect(sourceValue).toBeDefined();
+      rewritten[mode] = rewritten[mode].replace(
+        /(--color-surface-raised: )[^;]+;/,
+        `$1${sourceValue};`,
+      );
+    }
+
+    expect(themed).toBe(rewritten.light + rewritten.dark);
   });
 
   it("treats a bare `theme:` key as no theme, rather than throwing", () => {

package/templates/apps/web/lib/__tests__/structured-data.test.tsx

@@ -56,6 +56,10 @@ import {
 import type { ReactElement } from "react";
 import { parse as parseYaml } from "yaml";
 
+// Registers the site's `_site.mdx` identity at module load, as the `[locale]`
+// layout does in production (#6597).
+import { readSiteIdentity } from "../site-identity";
+
 // Detail routes call notFound() on a missing page; a thrown error is how the
 // test sees it (the same shape the per-surface suites use).
 jest.mock("next/navigation", () => ({
@@ -187,6 +191,38 @@ function extractJsonLdBlocks(container: HTMLElement): JsonLdObject[] {
   return blocks;
 }
 
+const SITE_IDENTITY = readSiteIdentity(CONTENT_ROOT);
+const SITE_ORIGIN = (
+  process.env.NEXT_PUBLIC_SITE_URL ??
+  process.env.MARKETING_WEB_BASE_URL ??
+  "http://localhost:3000"
+).replace(/\/+$/, "");
+
+/**
+ * The sitewide identity trio every rendered page carries when the site's own
+ * `_site.mdx` reads (#6597): exactly one identity node at its `@id`, exactly
+ * one `WebSite` published by it, and the page's primary linked `isPartOf`.
+ * `null` when the page carries all three.
+ */
+function identityFailure(blocks: JsonLdObject[], label: string): string | null {
+  if (SITE_IDENTITY === undefined) return null;
+  const identityId = `${SITE_ORIGIN}/#${SITE_IDENTITY.identity.kind === "Person" ? "person" : "organization"}`;
+  const webSiteId = `${SITE_ORIGIN}/#website`;
+  const identity = blocks.filter((b) => b["@id"] === identityId);
+  const webSite = blocks.filter((b) => b["@id"] === webSiteId);
+  const problems: string[] = [];
+  if (identity.length !== 1 || identity[0]?.["@type"] !== SITE_IDENTITY.identity.kind)
+    problems.push(`expected one ${SITE_IDENTITY.identity.kind} at ${identityId}, got ${identity.length}`);
+  if (webSite.length !== 1 || webSite[0]?.["@type"] !== "WebSite")
+    problems.push(`expected one WebSite at ${webSiteId}, got ${webSite.length}`);
+  else if ((webSite[0]["publisher"] as { "@id"?: unknown } | undefined)?.["@id"] !== identityId)
+    problems.push(`WebSite publisher is not {"@id": "${identityId}"}`);
+  // A page's own `isPartOf` wins over the sitewide link (composeGraph), so the
+  // check is that the primary is linked, not what to.
+  if (blocks[0]?.["isPartOf"] === undefined) problems.push("the primary carries no isPartOf");
+  return problems.length === 0 ? null : `${label}: sitewide identity — ${problems.join("; ")}`;
+}
+
 // ── 1. Content-driven: every content page builds valid JSON-LD ──────────────
 
 describe("structured data — every content page builds valid JSON-LD", () => {
@@ -510,6 +546,8 @@ describe("structured data — every route emits a valid JSON-LD script", () => {
       }
       const failure = validateFor(blocks, type, pageLabel);
       if (failure !== null) failures.push(failure);
+      const missingIdentity = identityFailure(blocks, pageLabel);
+      if (missingIdentity !== null) failures.push(missingIdentity);
     }
     expect(failures).toEqual([]);
   });

package/templates/apps/web/lib/license-key-store.ts

@@ -0,0 +1,52 @@
+/**
+ * Registers the durable home of a renewed licence key (#6677 DD-6).
+ *
+ * `@working-theory/license` renews the deployment's key before it lapses and
+ * keeps the renewed key in a `LicenseKeyStore`. Its default store is a file,
+ * which a redeploy wipes — and this app's one real `checkLicense()` caller
+ * (`src/lib/commerce-claim.ts`, gating /purchase/* and /.well-known/mcp.json)
+ * would then run on the older `AILK_LICENSE_KEY` alone. With a database
+ * configured, this registers the store backed by ONE deployment-wide
+ * `SiteSetting` row, `(DEFAULT_WORKSPACE_ID, "license.renewed_key")`, shared
+ * with apps/api and apps/mcp.
+ *
+ * NARROW, NAMED EXCEPTION to "apps/web never touches the database directly"
+ * (spec 6677 DD-6 and § 7; architecture.yaml `web.description`; the
+ * `prisma-for-auth.ts` header): this file, and only this file, hands
+ * `prismaForAuth.siteSetting` to `createSiteSettingLicenseKeyStore`, which
+ * reads and writes the one `license.renewed_key` row and nothing else. The
+ * alternative — an apps/api route serving the key over HTTP — is a hard floor
+ * and a wider exposure of a bearer credential.
+ *
+ * Imported from `instrumentation.ts` `register()` on the Node runtime only.
+ * Both imports are dynamic and reached only when `DATABASE_URL` is set.
+ */
+
+/**
+ * Register the SiteSetting-backed store when `DATABASE_URL` is set. An
+ * explicitly set `AILK_LICENSE_STORAGE_PATH` is the operator choosing the
+ * file store, and is honoured. Never throws: a failure logs and leaves the
+ * file store in place.
+ */
+export async function registerLicenseKeyStore(): Promise<void> {
+  if (!process.env.DATABASE_URL || process.env.AILK_LICENSE_STORAGE_PATH) return;
+  try {
+    const [{ prismaForAuth: prisma }, { DEFAULT_WORKSPACE_ID }, license] =
+      await Promise.all([
+        import("./prisma-for-auth"),
+        import("@working-theory/database/tenancy"),
+        import("@working-theory/license"),
+      ]);
+    license.setLicenseKeyStore(
+      license.createSiteSettingLicenseKeyStore(
+        prisma.siteSetting,
+        DEFAULT_WORKSPACE_ID,
+      ),
+    );
+  } catch (err) {
+    console.error(
+      "[web] could not register the SiteSetting licence-key store — the file store stays in place:",
+      err instanceof Error ? err.name : "non-Error thrown",
+    );
+  }
+}

package/templates/apps/web/lib/nav-config.ts

@@ -1,33 +1,85 @@
-// nav-config.ts — Nav item registry for apps/web (#1451, re-shaped by #5469).
+// nav-config.ts — Nav item registry for apps/web (#1451, re-shaped by #5469,
+// #6508).
 //
-// The Free marketing-site template's nav (the approved chrome, #5469 D5):
-// a Product flyout (How it works · Features · FAQ), then How it works,
-// Pricing and About as top-level items. Paths are locale-agnostic; Nav
-// prefixes them with the active locale at render.
+// The Free marketing-site template's nav (the approved chrome, #5469 D5,
+// #6508 D5): a Product flyout (How it works · Features · FAQ) rendered as a
+// fixed-640px two-column panel (the Standard Issue direction — #6508), then
+// How it works, Pricing and About as top-level items. Paths are
+// locale-agnostic; Nav prefixes them with the active locale at render.
+// `footerColumns` carries the footer's column groups (#6468), keys only — the
+// layout resolves the labels.
 //
 // In a SCAFFOLD this file is regenerated by create-ailk from the declared
 // route surfaces (`renderNavConfig` in packages/create-ailk/src/surfaces.ts)
 // so the nav never links a page the scaffold does not carry — keep the two in
 // step when the base item set changes.
+//
+// SOFT_LOCK_OK: #6508 — Product's flyout is `width: "panel"` (D4/D5): a fixed
+// 640px, two-column grid, replacing the prior "list"/"trigger" one-column
+// menu. `presentation` is omitted — it defaults to "grid" (D5). The `docs`
+// action is dropped (it duplicated the first feature's /how-it-works
+// destination, § 1.4). This note lives here, not inside the `navItems` array
+// below, so this file's `navItems`/`footerColumns` blocks stay byte-identical
+// to `renderNavConfig`'s generated output — the mirror test (#6468) diffs the
+// arrays verbatim.
 
 import type { NavItem } from "@working-theory/ui";
-import { BookOpen, HelpCircle, Layers, Sparkles } from "lucide-react";
+import { HelpCircle, Layers, Sparkles } from "lucide-react";
 
 export const navItems: NavItem[] = [
   {
     labelKey: "product",
     flyout: {
-      presentation: "list",
-      width: "trigger",
+      width: "panel",
       features: [
-        { labelKey: "howItWorks", descKey: "howItWorksDesc", icon: Layers, path: "/how-it-works" },
-        { labelKey: "features", descKey: "featuresDesc", icon: Sparkles, path: "/features" },
+        { labelKey: "useCases", descKey: "useCasesDesc", icon: Layers, path: "/use-cases" },
+        { labelKey: "features", descKey: "featuresDesc", icon: Sparkles, path: "/software/product" },
         { labelKey: "faq", descKey: "faqDesc", icon: HelpCircle, path: "/faq" },
       ],
-      actions: [{ labelKey: "docs", icon: BookOpen, path: "/how-it-works" }],
+      actions: [],
     },
   },
-  { labelKey: "howItWorks", path: "/how-it-works" },
+  { labelKey: "useCases", path: "/use-cases" },
+  { labelKey: "blog", path: "/blog" },
   { labelKey: "pricing", path: "/pricing" },
   { labelKey: "about", path: "/about" },
 ];
+
+export interface FooterColumnConfig {
+  headingKey: string;
+  items: { labelKey: string; path: string }[];
+}
+
+export const footerColumns: FooterColumnConfig[] = [
+  {
+    headingKey: "footerSitePagesHeading",
+    items: [
+      { labelKey: "features", path: "/software/product" },
+      { labelKey: "pricing", path: "/pricing" },
+      { labelKey: "useCases", path: "/use-cases" },
+      { labelKey: "about", path: "/about" },
+      { labelKey: "contact", path: "/contact" },
+      { labelKey: "bookACall", path: "/book-a-call" },
+    ],
+  },
+  {
+    headingKey: "footerFeaturesHeading",
+    items: [
+      { labelKey: "feature1", path: "/software/product" },
+      { labelKey: "feature2", path: "/software/product" },
+      { labelKey: "feature3", path: "/software/product" },
+      { labelKey: "feature4", path: "/software/product" },
+      { labelKey: "feature5", path: "/software/product" },
+      { labelKey: "allFeatures", path: "/software/product" },
+    ],
+  },
+  {
+    headingKey: "footerResourcesHeading",
+    items: [
+      { labelKey: "blog", path: "/blog" },
+      { labelKey: "glossary", path: "/glossary" },
+      { labelKey: "newsletter", path: "/newsletter" },
+      { labelKey: "faq", path: "/faq" },
+    ],
+  },
+];

package/templates/apps/web/lib/prisma-for-auth.ts

@@ -5,16 +5,19 @@
  * Better Auth migration (#587). Driver adapter wrapping landed in Phase B
  * of the Prisma 7 migration (#661) ahead of the v7 bump in Phase C.
  *
- * Only `apps/web/auth.ts` should import this — business-logic callers go
- * through apps/api, never the database directly (architecture.yaml
- * `apps/web` may_not_import_from `database`; the single-file singleton
- * here is the documented exception, matching the pre-migration carve-out
- * for NextAuth's adapter).
+ * Two files import this: `apps/web/auth.ts`, for Better Auth, and
+ * `lib/license-key-store.ts`, which hands `prismaForAuth.siteSetting` to the
+ * licence client's SiteSetting store for the ONE deployment-wide
+ * `license.renewed_key` row (#6677 DD-6 — a narrow, named exception).
+ * Every other business-logic caller goes through apps/api, never the
+ * database directly (architecture.yaml `apps/web` may_not_import_from
+ * `database`; the single-file singleton here is the documented exception,
+ * matching the pre-migration carve-out for NextAuth's adapter).
  */
 
  
-import { PrismaClient } from "@working-theory/database";
 import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "@working-theory/database";
 
 declare global {
   var __ailk_prisma: PrismaClient | undefined;

package/templates/apps/web/lib/site-brand.tsx

@@ -108,14 +108,10 @@ export const SITE_BASE_URL =
   process.env.NEXT_PUBLIC_BASE_URL ?? siteFrontmatter?.baseUrl ?? FALLBACK_BASE_URL;
 
 /**
- * Shared brand mark — the light/dark logo pair, mode-switched via the theme
- * `dark:` utility. RSC-safe (no hooks, no client state).
+ * Shared brand mark — the square logomark (the central brand library's
+ * `logomark/loop/tile-black.svg`). The Nav pairs it with `/wordmark.svg`.
+ * RSC-safe (no hooks, no client state).
  */
 export function siteLogo(): ReactElement {
-  return (
-    <>
-      <img src="/logo-light.svg" alt={SITE_NAME} height={28} className="block dark:hidden" />
-      <img src="/logo-dark.svg" alt={SITE_NAME} height={28} className="hidden dark:block" />
-    </>
-  );
+  return <img src="/logomark.svg" alt={SITE_NAME} width={28} height={28} className="block" />;
 }

package/templates/apps/web/lib/site-chrome.ts

@@ -2,8 +2,8 @@
 //
 // GENERATED by create-ailk from the declared template's `layout` block
 // (#5612). A scaffold with no template, or a template with no `layout`
-// block, gets these defaults — byte-identical to every scaffold before this
-// file existed. `apps/web/app/[locale]/layout.tsx` reads this to decide:
+// block, gets the defaults below (the announcement banner is off unless a
+// template turns it on, #6469). `apps/web/app/[locale]/layout.tsx` reads this to decide:
 //   - nav: "mark-only" → Nav renders the brand mark + right-hand controls
 //     only (no nav links).
 //   - footer: "centered" → Footer renders its existing centered variant.
@@ -24,6 +24,6 @@ export interface SiteChrome {
 export const siteChrome: SiteChrome = {
   nav: "full",
   footer: "columns",
-  announcementBanner: true,
+  announcementBanner: false,
   home: "default",
 };