create-ailk 0.6.0 → 0.7.0

package/templates/apps/api/src/middleware/__tests__/auth.database-not-configured.test.ts

@@ -0,0 +1,97 @@
+/**
+ * @file auth.database-not-configured.test.ts
+ *
+ * DATABASE_URL unset → 503 database_not_configured (#6482).
+ *
+ * Outside production apps/api boots database-less. The preHandler must say
+ * so before it reads any credential: placed after the lookups, the existing
+ * `.catch(() => undefined)` would turn the connection failure into a
+ * misleading 401.
+ */
+
+import Fastify from "fastify";
+import type { FastifyInstance } from "fastify";
+
+// eslint-disable-next-line no-restricted-syntax -- jest mock factory must be hoisted
+jest.mock("../../lib/prisma.js", () => ({
+  prisma: {
+    session: { findUnique: jest.fn() },
+    apiToken: {
+      findUnique: jest.fn(),
+      update: jest.fn().mockResolvedValue(undefined),
+    },
+  },
+}));
+
+import { prisma } from "../../lib/prisma.js";
+import { authPreHandlerPlugin } from "../auth.js";
+
+const echoHandler = jest.fn(async () => ({ ok: true }));
+
+function buildApp(): FastifyInstance {
+  const app = Fastify();
+  app.register(authPreHandlerPlugin, {
+    frontendOrigin: "https://app.example.com",
+  });
+  app.get("/echo", echoHandler);
+  app.post("/echo", echoHandler);
+  return app;
+}
+
+describe("auth preHandler — DATABASE_URL not configured", () => {
+  const originalDatabaseUrl = process.env.DATABASE_URL;
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    delete process.env.DATABASE_URL;
+    app = buildApp();
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+    if (originalDatabaseUrl === undefined) {
+      delete process.env.DATABASE_URL;
+    } else {
+      process.env.DATABASE_URL = originalDatabaseUrl;
+    }
+  });
+
+  it.each([
+    ["no credentials", "GET", {}],
+    ["a bearer token", "GET", { authorization: "Bearer ailk_abc123" }],
+    ["a session cookie", "GET", { cookie: "better-auth.session_token=tok" }],
+    [
+      "a non-GET with a session cookie",
+      "POST",
+      {
+        cookie: "better-auth.session_token=tok",
+        origin: "https://app.example.com",
+      },
+    ],
+  ] as const)(
+    'returns 503 { error: "database_not_configured" } for %s without any lookup',
+    async (_label, method, headers) => {
+      const res = await app.inject({ method, url: "/echo", headers });
+
+      expect(res.statusCode).toBe(503);
+      expect(JSON.parse(res.body)).toEqual({
+        error: "database_not_configured",
+      });
+      expect(prisma.session.findUnique).not.toHaveBeenCalled();
+      expect(prisma.apiToken.findUnique).not.toHaveBeenCalled();
+      expect(echoHandler).not.toHaveBeenCalled();
+    },
+  );
+
+  it("control: with DATABASE_URL set and no credentials, answers 401 unauthorized", async () => {
+    process.env.DATABASE_URL = "postgresql://test:test@localhost/test";
+
+    const res = await app.inject({ method: "GET", url: "/echo" });
+
+    expect(res.statusCode).toBe(401);
+    expect(JSON.parse(res.body)).toEqual({ error: "unauthorized" });
+    expect(echoHandler).not.toHaveBeenCalled();
+  });
+});

package/templates/apps/api/src/middleware/auth.ts

@@ -22,6 +22,7 @@
  *   - Both modes invalid              → 401 unauthorized.
  *   - Cookie expired + bearer valid   → 401 (no silent fallback).
  *   - Cookie absent, bearer malformed → 401 (no silent fallback).
+ *   - DATABASE_URL unset              → 503 database_not_configured (#6482).
  *
  * Public routes (health, content, leads, webhooks, openapi) are NOT registered
  * with this preHandler — server.ts narrows scope via a sub-plugin.
@@ -48,6 +49,7 @@ const COOKIE_NAMES = [
 ] as const;
 
 const UNAUTHORIZED = { error: "unauthorized" } as const;
+const DATABASE_NOT_CONFIGURED = { error: "database_not_configured" } as const;
 
 declare module "fastify" {
   interface FastifyRequest {
@@ -201,6 +203,13 @@ export function makeAuthPreHandler(opts: AuthPreHandlerOptions = {}) {
     request: FastifyRequest,
     reply: FastifyReply,
   ): Promise<void> {
+    // A database-less dev boot (#6482). First, and read per request: after
+    // the lookups below, their `.catch` would already have answered 401.
+    if (!process.env.DATABASE_URL) {
+      reply.code(503).send(DATABASE_NOT_CONFIGURED);
+      return;
+    }
+
     const now = getClock().now();
     const cookieToken = readSessionCookie(request);
 

package/templates/apps/api/src/routes/content/__tests__/get-page.test.ts

@@ -6,6 +6,9 @@
  * No internal module mocks — the route exercises the real adapter stack.
  */
 
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+
 import type { FastifyInstance } from "fastify";
 
 import { setupContentFixture } from "../../../__tests__/factories/content-fixture";
@@ -17,6 +20,30 @@ import { contentRoutes } from "../index";
 
 const fixture = setupContentFixture();
 
+/**
+ * A `_site.mdx` in the fixture's content root — an Organization identity at
+ * `https://example.com` (#6597). `logo` adds an identity-declared logo.
+ */
+function writeSiteMdx(root: string, opts: { logo?: string } = {}): void {
+  writeFileSync(
+    join(root, "_site.mdx"),
+    [
+      "---",
+      'version: "1"',
+      "siteName: Fixture Site",
+      "baseUrl: https://example.com",
+      "defaultLocale: en",
+      "siteIdentity:",
+      "  kind: Organization",
+      "  name: Fixture Co",
+      "  url: https://example.com",
+      ...(opts.logo !== undefined ? [`  logo: ${opts.logo}`] : []),
+      "---",
+      "",
+    ].join("\n"),
+  );
+}
+
 describe("GET /api/content/:type/:slug", () => {
   let app: FastifyInstance;
 
@@ -31,6 +58,7 @@ describe("GET /api/content/:type/:slug", () => {
 
   it("returns the page with resolved JSON-LD at the document root", async () => {
     // The fixture writes "home" HomePage in beforeEach by default.
+    writeSiteMdx(fixture.getContentRoot());
     const res = await app.inject({
       method: "GET",
       url: "/v1/content/HomePage/home",
@@ -39,8 +67,8 @@ describe("GET /api/content/:type/:slug", () => {
     expect(res.statusCode).toBe(200);
     const body = JSON.parse(res.body);
     expect(body["@context"]).toBe("https://schema.org");
-    // HomePage composes a Home/Landing @graph (WebPage spine + Organization +
-    // WebSite siblings) — #2618. The page-level fields live on the spine.
+    // A HomePage body keeps its @graph envelope: the WebPage spine plus the
+    // sitewide identity from _site.mdx (#6597). Page fields live on the spine.
     const graph = body["@graph"] as Array<Record<string, unknown>>;
     expect(graph.map((n) => n["@type"])).toEqual([
       "WebPage",
@@ -405,9 +433,8 @@ describe("GET /v1/content/:type/:slug under CONTENT_ADAPTER=database (#5852)", (
 // route's capability branch is exercised through the real resolver — the file
 // header's "no internal module mocks" (#507) holds for these cases too.
 
-import { mkdtempSync, writeFileSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
 
 import * as contentAdapterModule from "../../../lib/content-adapter.js";
 import { resetContentAdapter } from "../../../lib/content-adapter.js";
@@ -453,7 +480,12 @@ describe("GET /v1/content/:type/:slug?include=body (#5890)", () => {
   });
 
   // AC-1, the floor half — the unparameterised read is unchanged to the byte.
+  // #6597 rewrote this pin by hand: the HomePage @graph is now composed from
+  // the fixture's _site.mdx rather than the page title (AC-9 checks every
+  // field of the pre-#6597 body is still present). The #5890 claim it guards
+  // — no `body` key without the parameter — is unchanged.
   it("serves a response byte-identical to the pre-change handler when the parameter is absent", async () => {
+    writeSiteMdx(fixture.getContentRoot());
     const res = await app.inject({
       method: "GET",
       url: "/v1/content/HomePage/home",
@@ -461,7 +493,7 @@ describe("GET /v1/content/:type/:slug?include=body (#5890)", () => {
 
     expect(res.statusCode).toBe(200);
     expect(res.body).toMatchInlineSnapshot(
-      `"{"@context":"https://schema.org","@graph":[{"@context":"https://schema.org","@type":"WebPage","inLanguage":"en","name":"HomePage home title","description":"HomePage home description"},{"@context":"https://schema.org","@type":"Organization","name":"HomePage home title"},{"@context":"https://schema.org","@type":"WebSite","name":"HomePage home title","inLanguage":"en"}],"page":{"type":"HomePage","slug":"home","title":"HomePage home title","description":"HomePage home description"}}"`,
+      `"{"@context":"https://schema.org","@graph":[{"@context":"https://schema.org","@type":"WebPage","inLanguage":"en","name":"HomePage home title","description":"HomePage home description","mainEntity":{"@id":"https://example.com/#organization"},"isPartOf":{"@id":"https://example.com/#website"}},{"@context":"https://schema.org","@type":"Organization","@id":"https://example.com/#organization","name":"Fixture Co","url":"https://example.com"},{"@context":"https://schema.org","@type":"WebSite","@id":"https://example.com/#website","name":"Fixture Site","url":"https://example.com","inLanguage":"en","publisher":{"@id":"https://example.com/#organization"}}],"page":{"type":"HomePage","slug":"home","title":"HomePage home title","description":"HomePage home description"}}"`,
     );
     expect(JSON.parse(res.body)).not.toHaveProperty("body");
   });
@@ -693,3 +725,93 @@ describe("GET /v1/content/:type/:slug?include=body under CONTENT_ADAPTER=databas
     expect(prisma.artifactVersion.findFirst).not.toHaveBeenCalled();
   });
 });
+
+// ─── #6597 AC-9 — the /v1 HomePage response keeps its @graph envelope ─────────
+
+describe("GET /v1/content/HomePage/home — sitewide identity envelope (#6597)", () => {
+  let app: FastifyInstance;
+
+  beforeEach(async () => {
+    app = require("fastify")();
+    await app.register(contentRoutes);
+    await fixture.writeFixturePage("HomePage", "home", {
+      type: "HomePage",
+      slug: "home",
+      title: "HomePage home title",
+      description: "HomePage home description",
+      image: "https://example.com/home.png",
+    });
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  async function homeBody(query = ""): Promise<{
+    body: Record<string, unknown>;
+    graph: Array<Record<string, unknown>>;
+  }> {
+    const res = await app.inject({ method: "GET", url: `/v1/content/HomePage/home${query}` });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body) as Record<string, unknown>;
+    return { body, graph: body["@graph"] as Array<Record<string, unknown>> };
+  }
+  const byType = (graph: Array<Record<string, unknown>>, type: string) =>
+    graph.find((n) => n["@type"] === type)!;
+
+  it("composes WebPage + Organization + WebSite from _site.mdx, keeping every pre-#6597 field", async () => {
+    writeSiteMdx(fixture.getContentRoot());
+    const { body, graph } = await homeBody();
+    expect(body["@context"]).toBe("https://schema.org");
+    expect(graph.map((n) => n["@type"])).toEqual(["WebPage", "Organization", "WebSite"]);
+
+    const org = byType(graph, "Organization");
+    expect(org["@id"]).toBe("https://example.com/#organization");
+    expect(org["name"]).toBe("Fixture Co");
+    // The pre-#6597 Organization took `logo` from the page image; kept as the
+    // fallback when the identity declares none.
+    expect(org["logo"]).toBe("https://example.com/home.png");
+
+    // Every key of every node of the pre-#6597 pinned body survives.
+    const pinned: Record<string, string[]> = {
+      WebPage: ["@context", "@type", "inLanguage", "name", "description"],
+      Organization: ["@context", "@type", "name"],
+      WebSite: ["@context", "@type", "name", "inLanguage"],
+    };
+    for (const [type, keys] of Object.entries(pinned)) {
+      for (const key of keys) expect(byType(graph, type)).toHaveProperty([key]);
+    }
+
+    const webPage = byType(graph, "WebPage");
+    expect(byType(graph, "WebSite")["inLanguage"]).toBe(webPage["inLanguage"]);
+    expect(webPage["inLanguage"]).toBe("en");
+    expect(graph.filter((n) => n["name"] === "HomePage home title")).toEqual([webPage]);
+  });
+
+  it("the WebSite and WebPage inLanguage stay one value under ?locale=<second locale>", async () => {
+    writeSiteMdx(fixture.getContentRoot());
+    const { graph } = await homeBody("?locale=pt-BR");
+    expect(byType(graph, "WebSite")["inLanguage"]).toBe(byType(graph, "WebPage")["inLanguage"]);
+  });
+
+  it("an identity-declared logo wins over the page image", async () => {
+    writeSiteMdx(fixture.getContentRoot(), { logo: "https://example.com/logo.png" });
+    const { graph } = await homeBody();
+    expect(byType(graph, "Organization")["logo"]).toBe("https://example.com/logo.png");
+  });
+
+  it("with no _site.mdx the body still has @context and a one-node @graph", async () => {
+    const { body, graph } = await homeBody();
+    expect(body["@context"]).toBe("https://schema.org");
+    expect(graph.map((n) => n["@type"])).toEqual(["WebPage"]);
+  });
+
+  it("other types keep their bare JSON-LD — no @graph key", async () => {
+    writeSiteMdx(fixture.getContentRoot());
+    const res = await app.inject({ method: "GET", url: "/v1/content/AboutPage/about" });
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body) as Record<string, unknown>;
+    expect(body).not.toHaveProperty("@graph");
+    expect(body["@type"]).toBe("AboutPage");
+  });
+});

package/templates/apps/api/src/routes/content/get-page.ts

@@ -23,7 +23,15 @@
  * independent `getPageSource` call. Two independent adapter reads can
  * straddle a publish that lands between them (frontmatter from revision N,
  * body from revision N+1); one read cannot.
+ *
+ * #6597: a `HomePage` body keeps its `@context` + `@graph` envelope, now
+ * composed from the deployment's `_site.mdx` identity (identity node, optional
+ * secondary, WebSite) rather than the page title. Every other type's body is
+ * the page's own JSON-LD, spread at the root, as before.
  */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
 import {
   SCHEMA_ORG_TYPES,
   type ContentAdapter,
@@ -32,10 +40,23 @@ import {
   type MdxPageSource,
   type SchemaOrgType,
 } from "@working-theory/content-adapters";
-import { buildJsonLd, type ContentPageInput } from "@working-theory/schema";
+import {
+  buildJsonLd,
+  composeGraph,
+  graphNodes,
+  type ContentPageInput,
+  type JsonLdObject,
+  type SitewideIdentityInput,
+} from "@working-theory/schema";
+import {
+  SiteConfigSchema,
+  type SiteConfig,
+} from "@working-theory/site-config/schema";
 import type { FastifyPluginAsync } from "fastify";
+import { parse as parseYaml } from "yaml";
 import { z } from "zod";
 
+import { getContentRoot } from "../../lib/content-adapter.js";
 import { resolveLocale } from "../../lib/locales.js";
 import { resolvePublicContentAdapter } from "../../services/public-site-resolver.js";
 
@@ -64,6 +85,67 @@ function hasPageSource(
   );
 }
 
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+
+/** `_site.mdx` per content root, read once; `null` when it does not load. */
+const siteConfigByRoot = new Map<string, SiteConfig | null>();
+
+/**
+ * The deployment's `_site.mdx`, validated against `SiteConfigSchema`, or
+ * `undefined` on any failure (absent, unreadable, invalid). A local read with
+ * the client-safe `/schema` entry: `@working-theory/site-config/server` imports
+ * `server-only`, which throws outside a React Server Components runtime.
+ */
+function readSiteConfig(contentRoot: string): SiteConfig | undefined {
+  if (!siteConfigByRoot.has(contentRoot)) {
+    let config: SiteConfig | null = null;
+    try {
+      const raw = readFileSync(join(contentRoot, "_site.mdx"), "utf8");
+      const match = FRONTMATTER_RE.exec(raw);
+      if (match) {
+        const parsed = SiteConfigSchema.safeParse(parseYaml(match[1] ?? ""));
+        if (parsed.success) config = parsed.data;
+      }
+    } catch {
+      // Absent or unreadable — no site.
+    }
+    siteConfigByRoot.set(contentRoot, config);
+  }
+  return siteConfigByRoot.get(contentRoot) ?? undefined;
+}
+
+/**
+ * The `HomePage` body's `@graph` (#6597, spec D11): the spine plus the site's
+ * sitewide identity nodes. The WebSite's `inLanguage` is the spine's own, so
+ * both carry one value; the Organization falls back to the page's `image` as
+ * its `logo` when the identity declares none, as the title-derived node did.
+ */
+function homePageGraph(
+  primary: JsonLdObject,
+  image: string | undefined,
+): { "@context": "https://schema.org"; "@graph": JsonLdObject[] } {
+  const config = readSiteConfig(getContentRoot());
+  let site: SitewideIdentityInput | undefined;
+  if (config !== undefined) {
+    const identity = config.siteIdentity;
+    site = {
+      origin: config.baseUrl.replace(/\/+$/, ""),
+      siteName: config.siteName,
+      baseUrl: config.baseUrl,
+      inLanguage:
+        typeof primary["inLanguage"] === "string" ? primary["inLanguage"] : undefined,
+      identity:
+        identity.kind !== "Person" && identity.logo === undefined && image !== undefined
+          ? { ...identity, logo: image }
+          : identity,
+    };
+  }
+  return {
+    "@context": "https://schema.org",
+    "@graph": graphNodes(composeGraph({ primary, site, isHomePage: true })),
+  };
+}
+
 export const getPageRoute: FastifyPluginAsync = async (fastify) => {
   fastify.get<{
     Params: { type: string; slug: string };
@@ -165,7 +247,9 @@ export const getPageRoute: FastifyPluginAsync = async (fastify) => {
           // now preserves `sections`; before, it was stripped at validation.
           ...(page.sections !== undefined && { sections: page.sections }),
         };
-        const jsonLd = buildJsonLd(input);
+        const primary = buildJsonLd(input);
+        const jsonLd =
+          page.type === "HomePage" ? homePageGraph(primary, page.image) : primary;
         return reply.send({
           ...jsonLd,
           page,

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

@@ -23,6 +23,7 @@ import { config } from "./config/index.js";
 import { isModuleEnabled } from "./config/modules.js";
 import { registerErrorSerializer } from "./lib/error-serializer.js";
 import { validateLeadCaptureDir } from "./lib/lead-capture-store.js";
+import { registerLicenseKeyStore } from "./lib/license-key-store.js";
 import { requireCommerceClaim } from "./lib/require-commerce-claim.js";
 import { assertSiteAliasResolves } from "./lib/site.js";
 import { loadSlice } from "./lib/slice-load.js";
@@ -522,6 +523,11 @@ export async function build() {
   // database-less dev boot).
   await assertSiteAliasResolves();
 
+  // #6677 DD-6 — the renewed licence key's durable home: with a database,
+  // one deployment-wide SiteSetting row, so a redeploy keeps the key this
+  // site renewed. Never throws; without DATABASE_URL the file store stays.
+  await registerLicenseKeyStore();
+
   // Runtime sandbox-mode guard: reject live-mode Stripe keys before any
   // webhook or checkout call can exercise them. Idempotent — safe even if
   // assertSandboxKey is called again inside a route handler. UNCONDITIONAL

package/templates/apps/mcp/__tests__/audit-single-page.test.ts

@@ -15,9 +15,17 @@
  * - No fetch() call (structural test)
  */
 
-import { readFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { resolve, join } from "node:path";
 
+import {
+  entityMarkup,
+  runAudit,
+  schemaCoverage,
+  type AuditReport,
+} from "@working-theory/aeo";
+
 import { buildSinglePageAuditInput } from "../src/lib/audit-single-page.js";
 
 const REPO_ROOT = resolve(__dirname, "../../..");
@@ -211,3 +219,69 @@ describe("structural guard — no fetch()", () => {
     expect(codeOnly).not.toMatch(/\bfetch\s*\(/);
   });
 });
+
+describe("buildSinglePageAuditInput — sitewide identity (#6597 AC-7)", () => {
+  const evidenceOf = (report: AuditReport, id: string) =>
+    report.perRule.find((r) => r.id === id);
+  const auditOf = async (input: { slug: string; type?: "AboutPage" }, root: string) =>
+    runAudit(await buildSinglePageAuditInput(input, root), [schemaCoverage, entityMarkup]);
+
+  it("schema-coverage passes for the monorepo's AboutPage/about", async () => {
+    const report = await auditOf({ slug: "about", type: "AboutPage" }, CONTENT_ROOT);
+    expect(evidenceOf(report, "schema-coverage")?.pass).toBe(true);
+  });
+
+  it("the monorepo home finds the identity: Identity (organization) ✓", async () => {
+    const report = await auditOf({ slug: "home" }, CONTENT_ROOT);
+    expect(evidenceOf(report, "entity-markup")?.evidence).toContain(
+      "Identity (organization) ✓",
+    );
+  });
+
+  it("stores the flat node array, the page's own primary first", async () => {
+    const input = await buildSinglePageAuditInput({ slug: "about", type: "AboutPage" }, CONTENT_ROOT);
+    const nodes = input.jsonLdByPage["AboutPage/about"] as Array<Record<string, unknown>>;
+    expect(nodes[0]!["@type"]).toBe("AboutPage");
+    expect(nodes.map((n) => n["@type"])).toEqual(
+      expect.arrayContaining(["Organization", "WebSite"]),
+    );
+  });
+
+  describe("a Person site", () => {
+    let root: string;
+    beforeAll(() => {
+      root = mkdtempSync(join(tmpdir(), "mcp-6597-"));
+      writeFileSync(
+        join(root, "_site.mdx"),
+        [
+          "---",
+          'version: "1"',
+          "siteName: Ada",
+          "baseUrl: https://example.com",
+          "defaultLocale: en",
+          "siteIdentity:",
+          "  kind: Person",
+          "  name: Ada Lovelace",
+          "  url: https://example.com",
+          "---",
+          "",
+        ].join("\n"),
+      );
+      mkdirSync(join(root, "en", "HomePage"), { recursive: true });
+      writeFileSync(
+        join(root, "en", "HomePage", "home.mdx"),
+        ["---", "type: HomePage", "slug: home", "title: Ada", "description: Ada's site.", "---", ""].join("\n"),
+      );
+    });
+    afterAll(() => {
+      rmSync(root, { recursive: true, force: true });
+    });
+
+    it("derives person mode from the kind: Identity (person) ✓", async () => {
+      const input = await buildSinglePageAuditInput({ slug: "home" }, root);
+      expect(input.identityMode).toBe("person");
+      const report = runAudit(input, [entityMarkup]);
+      expect(evidenceOf(report, "entity-markup")?.evidence).toContain("Identity (person) ✓");
+    });
+  });
+});

package/templates/apps/mcp/__tests__/lib/audit-single-page-readiness-scan.test.ts

@@ -10,18 +10,18 @@
  *     error, never logged. This is the ordinary "site has nothing of this
  *     type" case every real adapter (MDX, database) takes today.
  *   - a type whose adapter call THROWS is a genuine failure. It must not take
- *     down the audit (the other four reads still complete and their pages
+ *     down the audit (the other two reads still complete and their pages
  *     still count), but it must be visible — logged via `console.error`
  *     (stderr, NOT stdout — the default stdio MCP transport's JSON-RPC
  *     framing channel, #6012 round 2) — rather than silently collapsing into
  *     the same vacuous "nothing found" result.
  *
- * The call-count assertions below prove that all five reads still ran despite
+ * The call-count assertions below prove that all three reads still ran despite
  * the throw — the read AFTER the failing one is not skipped, which a
  * sequential loop that ABORTED on the first throw would fail to show. They
  * are NOT, on their own, proof of CONCURRENCY: the prior sequential `for`
  * loop this replaced used `continue` (not a re-throw), so it too issued all
- * five calls. The `Promise.all` in the source is what delivers the
+ * three calls. The `Promise.all` in the source is what delivers the
  * concurrency AC; these assertions cover the narrower, still load-bearing
  * property that a throw part-way through never truncates the scan.
  */
@@ -93,10 +93,10 @@ describe("scanSitePages — type-not-registered vs adapter-threw (#6012)", () =>
 
     expect(result.readiness!.sitePages).toEqual([]);
     expect(errorSpy).not.toHaveBeenCalled();
-    // All five reads still ran — two listDetail (Product, Service), three
-    // listPages (the three policy types).
+    // All three reads still ran — two listDetail (Product, Service), one
+    // listPages (PurchasePolicyPage, #6646).
     expect(listDetail).toHaveBeenCalledTimes(2);
-    expect(listPages).toHaveBeenCalledTimes(3);
+    expect(listPages).toHaveBeenCalledTimes(1);
   });
 
   it("a type whose adapter call throws is logged to stderr and does not fail the audit", async () => {
@@ -135,9 +135,57 @@ describe("scanSitePages — type-not-registered vs adapter-threw (#6012)", () =>
     // the stdio transport's JSON-RPC channel).
     expect(errorSpy).toHaveBeenCalledTimes(1);
     expect(errorSpy.mock.calls[0]![0]).toMatch(/Service/);
-    // All five reads still ran despite the throw — the read AFTER the
-    // throwing one (ReturnsPolicyPage, et al.) was not skipped.
+    // All three reads still ran despite the throw — the read AFTER the
+    // throwing one (PurchasePolicyPage) was not skipped.
     expect(listDetail).toHaveBeenCalledTimes(2);
-    expect(listPages).toHaveBeenCalledTimes(3);
+    expect(listPages).toHaveBeenCalledTimes(1);
+  });
+
+  it("a PurchasePolicyPage contributes its document-chassis section ids (#6646)", async () => {
+    const purchasePolicy: ContentPage = {
+      type: "PurchasePolicyPage",
+      slug: "purchase-policy",
+      title: "Purchase Policy",
+      description: "Returns, shipping and refunds.",
+      sections: [
+        {
+          id: "purchase-policy-document",
+          type: "document-chassis",
+          data: {
+            headline: "Purchase Policy",
+            sections: [
+              { id: "returns", heading: "Returns", blocks: [] },
+              { id: "shipping", heading: "Shipping", blocks: [] },
+              { id: "refunds", heading: "Refunds", blocks: [] },
+            ],
+          },
+        },
+      ] as ContentPage["sections"],
+    };
+    mockResolveContentAdapter.mockReturnValue({
+      getPageBySlug: jest.fn().mockResolvedValue(HOME_PAGE),
+      listPages: jest.fn().mockResolvedValue([purchasePolicy]),
+      listDetail: jest.fn().mockResolvedValue([]),
+      getDetailBySlug: jest.fn(),
+      searchPages: jest.fn(),
+      extractStructuredData: jest.fn(),
+      createPage: jest.fn(),
+      updatePage: jest.fn(),
+      deletePage: jest.fn(),
+      getPageVersion: jest.fn(),
+    });
+
+    const result = await buildSinglePageAuditInput({
+      slug: "home",
+      type: "HomePage",
+    });
+
+    expect(result.readiness!.sitePages).toEqual([
+      {
+        slug: "purchase-policy",
+        type: "PurchasePolicyPage",
+        chassisSectionIds: ["returns", "shipping", "refunds"],
+      },
+    ]);
   });
 });

package/templates/apps/mcp/package.json

@@ -9,7 +9,8 @@
     "lint": "eslint .",
     "build": "tsc -b",
     "type-check": "tsc --noEmit",
-    "dev": "node --experimental-vm-modules dist/index.js",
+    "dev": "tsx watch src/index.ts",
+    "start": "node --experimental-vm-modules dist/index.js",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"

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

@@ -22,6 +22,7 @@
  */
 
 import { initMcpCommerceClaim } from "./lib/commerce-claim.js";
+import { registerLicenseKeyStore } from "./lib/license-key-store.js";
 import { initMcpPublicWorkspace } from "./lib/public-workspace.js";
 
 // Resolves the MCP server's own workspace ONCE, before either transport
@@ -48,6 +49,12 @@ try {
   );
 }
 
+// Registers the renewed licence key's durable home (#6677 DD-6) BEFORE the
+// commerce claim below memoises the licence: with a database, the key a
+// sibling app renewed lives in one SiteSetting row, and the claim must read
+// it. Never throws; without DATABASE_URL the file store stays in place.
+await registerLicenseKeyStore();
+
 // Resolves the deployment's `commerce` add-on claim ONCE, before either
 // transport branch — the sibling of the workspace resolution above and the
 // same #5876 idiom (#5971 spec D2). Without this await the memoised claim is