@teamscala/service-boot 0.23.381 → 0.23.382

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.381",
+  "version": "0.23.382",
   "sideEffects": false,
   "imports": {
     "#service-boot/*": "./src/*",
@@ -490,14 +490,6 @@
       "types": "./src/handlers/upstream-issue-sync.d.ts",
       "default": "./src/handlers/upstream-issue-sync.ts"
     },
-    "./handlers/whatsapp-liveness": {
-      "types": "./src/handlers/whatsapp-liveness.d.ts",
-      "default": "./src/handlers/whatsapp-liveness.ts"
-    },
-    "./handlers/whatsapp-liveness.ts": {
-      "types": "./src/handlers/whatsapp-liveness.d.ts",
-      "default": "./src/handlers/whatsapp-liveness.ts"
-    },
     "./handlers/whatsapp-liveness-logic": {
       "types": "./src/handlers/whatsapp-liveness-logic.d.ts",
       "default": "./src/handlers/whatsapp-liveness-logic.ts"
@@ -650,14 +642,6 @@
       "types": "./src/proposal-authorized-emails.d.ts",
       "default": "./src/proposal-authorized-emails.ts"
     },
-    "./proposal-chat-inject": {
-      "types": "./src/proposal-chat-inject.d.ts",
-      "default": "./src/proposal-chat-inject.ts"
-    },
-    "./proposal-chat-inject.ts": {
-      "types": "./src/proposal-chat-inject.d.ts",
-      "default": "./src/proposal-chat-inject.ts"
-    },
     "./proposal-gate": {
       "types": "./src/proposal-gate.d.ts",
       "default": "./src/proposal-gate.ts"

package/src/content-gate/catalog.test.ts

@@ -0,0 +1,68 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The catalog's invariants — the ones that were unenforceable while the gate
+ * list lived as two hand-written arrays in two files.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	CONTENT_GATES,
+	contentWithholdingGates,
+	withholdsContent,
+} from "./catalog.ts";
+
+describe("content gate catalog", () => {
+	test("registers each gate exactly once", () => {
+		const slugs = CONTENT_GATES.map((entry) => entry.slug);
+		expect(slugs.length).toBe(new Set(slugs).size);
+	});
+
+	test("mints and verifies through the same cookie", () => {
+		// THE INVARIANT THE TWO SEPARATE LISTS COULD NOT ENFORCE. The access
+		// endpoint SETS a cookie and the SSR gate READS one; if a registration
+		// pairs a gate with another gate's access config, the endpoint mints a
+		// token the gate never looks for and the page becomes permanently
+		// unlockable-by-nobody — with no error anywhere, because each half is
+		// individually valid.
+		for (const entry of CONTENT_GATES) {
+			expect(entry.access.cookieName).toBe(entry.gate.cookieName);
+		}
+	});
+
+	test("evaluates proposals before agreements", () => {
+		// Order is behaviour, not presentation: an authorized proposal viewer's
+		// gate block is removed from the resolved graph, and that removal is what
+		// makes the agreement gate no-op on a page carrying both.
+		const order = CONTENT_GATES.map((entry) => entry.slug);
+		expect(order.indexOf("proposal")).toBeLessThan(order.indexOf("agreement"));
+	});
+
+	test("treats an open-capture gate as withholding nothing", () => {
+		// The GPT gate captures a visitor rather than authorizing one, so an
+		// anonymous viewer of a public GPT page is not an unauthorized viewer.
+		// Getting this backwards silently removes the assistant from a page the
+		// visitor is fully entitled to see.
+		const gpt = CONTENT_GATES.find((entry) => entry.slug === "gpt");
+		expect(gpt).toBeDefined();
+		expect(gpt?.access.openCapture).toBe(true);
+		expect(withholdsContent(gpt as NonNullable<typeof gpt>)).toBe(false);
+	});
+
+	test("treats an allow-list gate as withholding content", () => {
+		for (const slug of ["proposal", "agreement"]) {
+			const entry = CONTENT_GATES.find((candidate) => candidate.slug === slug);
+			expect(entry).toBeDefined();
+			expect(withholdsContent(entry as NonNullable<typeof entry>)).toBe(true);
+		}
+	});
+
+	test("exposes only the withholding gates as the assistant's authority", () => {
+		expect(contentWithholdingGates().map((entry) => entry.slug)).toEqual([
+			"proposal",
+			"agreement",
+		]);
+	});
+});

package/src/content-gate/catalog.ts

@@ -0,0 +1,81 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * THE CATALOG OF GATED CONTENT TYPES — the one place a gate is registered.
+ *
+ * The gate ENGINE (gate.ts) and the access MOUNTER (access.ts) were already
+ * generic and config-driven, but the SEQUENCE was not: `register-registry-page-
+ * route.ts` named proposalGateConfig + agreementGateConfig + gptGateConfig in a
+ * hand-written array, and `two-phase-boot.ts` named the same three AccessConfigs
+ * in a second hand-written array. Two lists, one fact, and adding a fourth gated
+ * resource meant editing both — the same drift as the assistant, one layer down
+ * (`information-exists-in-one-location`).
+ *
+ * Now both call sites iterate THIS. A gate is registered once, as a pair, and
+ * the SSR gate and its public access endpoint cannot disagree about which gates
+ * exist — the shape doctrine asks for when behaviour genuinely is code:
+ * `business-logic-is-rows-plus-executors`, "extend the executor catalog".
+ *
+ * WHY A CATALOG AND NOT A REGISTRY ROW. A gate is not data — `verifyToken`,
+ * `resolveAuthorizedEmails` and the withholding rules are executable behaviour,
+ * which the rule places in a typed executor, never in a row. What belongs in a
+ * row is the SELECTION: which gate governs a given page. That is a `page_route`
+ * field, and a row can only select from a catalog, so this file is the thing it
+ * will select from — not a step on the way to it.
+ */
+
+import type { AccessConfig, ContentGateConfig } from "./config-types.ts";
+import { agreementAccessConfig, agreementGateConfig } from "../agreement-gate.ts";
+import { gptAccessConfig, gptGateConfig } from "../gpt-gate.ts";
+import { proposalAccessConfig, proposalGateConfig } from "../proposal-gate.ts";
+
+/** One gated content type: its SSR gate and its public access endpoint. */
+export interface ContentGateEntry {
+	/** Stable identity for this gate — what a `page_route` will name to select it. */
+	slug: string;
+	gate: ContentGateConfig;
+	access: AccessConfig;
+}
+
+/**
+ * Registered gates, in evaluation order.
+ *
+ * ORDER IS LOAD-BEARING AND SO IT IS DECLARED, NOT INCIDENTAL. Proposals run
+ * before agreements: an authorized proposal viewer has their gate block removed
+ * from the resolved graph, after which the agreement gate finds no resource and
+ * no-ops. Reversing these two changes behaviour on a page carrying both.
+ *
+ * Each gate still self-selects — `getResourceId` returns "" when the page is not
+ * its kind — so listing a gate here never makes it apply to a page it does not
+ * govern.
+ */
+export const CONTENT_GATES: readonly ContentGateEntry[] = [
+	{ slug: "proposal", gate: proposalGateConfig, access: proposalAccessConfig },
+	{ slug: "agreement", gate: agreementGateConfig, access: agreementAccessConfig },
+	{ slug: "gpt", gate: gptGateConfig, access: gptAccessConfig },
+];
+
+/**
+ * Does this gate WITHHOLD content, or only identify the visitor?
+ *
+ * DERIVED FROM THE ACCESS CONFIG, NEVER DECLARED TWICE. `openCapture` already
+ * states that any email is a valid visitor, which is precisely the case where
+ * nothing is being withheld — the GPT page body is public and only its identity
+ * is gated (see gptGateConfig.onUnauthorized, a documented no-op). A separate
+ * `withholdsContent` flag would be a second copy of that fact, free to drift
+ * from the one the access endpoint actually enforces (`offered-is-derived`).
+ *
+ * The distinction matters to the assistant: a seed-only gate must not count as
+ * "governing" this page, or an anonymous visitor to a public GPT page would be
+ * read as an unauthorized viewer and lose an assistant they are entitled to.
+ */
+export function withholdsContent(entry: ContentGateEntry): boolean {
+	return entry.access.openCapture !== true;
+}
+
+/** The gates that can withhold content, in order — the assistant's authority. */
+export function contentWithholdingGates(): ContentGateEntry[] {
+	return CONTENT_GATES.filter(withholdsContent);
+}

package/src/content-gate/gate.ts

@@ -13,21 +13,41 @@
 import type { ContentGateConfig } from "./config-types.ts";
 import { parseCookie } from "./parse-cookie.ts";
 
+/**
+ * What a gate decided, so a caller can act on it without re-deriving it.
+ *
+ * THE ASSISTANT MUST NOT OUTRUN THE GATE. Its runtime context is the whole
+ * document serialised, so injecting it for an unauthorized viewer would hand
+ * the gated bytes to the chat -- the exact thing the gate exists to withhold.
+ * The gate already knows the answer; returning it means the page-route
+ * assistant setting reads ONE decision instead of inventing a second notion of
+ * "is this viewer allowed" that could drift from this one.
+ *
+ * `applies: false` means the gate did not govern this page at all (a public
+ * page), which is different from an unauthorized viewer and must not be
+ * confused with one.
+ */
+export interface ContentGateOutcome {
+	applies: boolean;
+	authorized: boolean;
+	email?: string;
+}
+
 export async function runContentGate(
 	resolved: Record<string, unknown>,
 	cookieHeader: string | null,
 	nowMs: number,
 	config: ContentGateConfig,
-): Promise<void> {
+): Promise<ContentGateOutcome> {
 	const resourceId = await config.getResourceId(resolved);
-	if (!resourceId) return; // gate does not apply to this page.
+	if (!resourceId) return { applies: false, authorized: false };
 
 	const token = parseCookie(cookieHeader, config.cookieName);
 	const identity = config.verifyToken(token, resourceId, nowMs);
 
 	if (identity) {
 		await config.onAuthorized(resolved, resourceId, identity);
-		return;
+		return { applies: true, authorized: true, email: identity.email };
 	}
 
 	// No valid access token — BAKED-IN unified auth: release a logged-in viewer
@@ -44,10 +64,11 @@ export async function runContentGate(
 	);
 	if (sessionIdentity) {
 		await config.onAuthorized(resolved, resourceId, sessionIdentity);
-		return;
+		return { applies: true, authorized: true, email: sessionIdentity.email };
 	}
 
 	await config.onUnauthorized(resolved, resourceId);
+	return { applies: true, authorized: false };
 }
 
 /**

package/src/proposal-gate.ts

@@ -17,7 +17,6 @@
 import type { AccessConfig, ContentGateConfig } from "./content-gate/config-types.ts";
 import { signAccessToken, verifyAccessToken } from "./content-gate/token.ts";
 import { resolveProposalAuthorizedEmails } from "./proposal-authorized-emails.ts";
-import { injectProposalChatLauncher } from "./proposal-chat-inject.ts";
 import { propTtlMs } from "./gate-ttls.ts";
 import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
 import * as v from "valibot";
@@ -117,9 +116,11 @@ export const proposalGateConfig: ContentGateConfig = {
 		(resolved as { initialVisitor?: { email: string } }).initialVisitor = {
 			email,
 		};
-		// Inject the floating Proposal Assistant chat bubble — strictly behind the
-		// gate, so only an authorised viewer ever sees it. Content otherwise intact.
-		await injectProposalChatLauncher(resolved, email);
+		// THE ASSISTANT IS NO LONGER INJECTED HERE. It is declared on the
+		// page_route row (`assistant`) and applied once, centrally, after every
+		// gate has run — so the bubble is a setting rather than a line of code
+		// inside one resource type's gate. This call was the reason a third
+		// resource type could not have an assistant without editing service-boot.
 	},
 	async onUnauthorized(resolved, resourceId) {
 		const settings = await loadProposalGateSettings();

package/src/register-registry-page-route.ts

@@ -29,9 +29,9 @@ import { bindPageHandler } from "./bind-page-handler.ts";
 import { getServerClient } from "./page-server-orpc/server-client.ts";
 import { resolveFromLoaderConfig } from "./resolve-from-loader-config.ts";
 import { runContentGate } from "./content-gate/gate.ts";
-import { agreementGateConfig } from "./agreement-gate.ts";
-import { proposalGateConfig } from "./proposal-gate.ts";
-import { gptGateConfig } from "./gpt-gate.ts";
+import type { ContentGateOutcome } from "./content-gate/gate.ts";
+import { CONTENT_GATES, withholdsContent } from "./content-gate/catalog.ts";
+import { injectResourceChatLauncher } from "./resource-chat-inject.ts";
 import { extractOrgIdFromCallbackPath } from "./resolvers/portal-route-paths.ts";
 import { PrimaryResourceMissingError } from "./resource-not-found.ts";
 import { decideContentPageFloor } from "./content-page-floor.ts";
@@ -60,6 +60,13 @@ interface PageRouteConfig {
 	loader_slug: string;
 	meta_context?: Record<string, Record<string, string>>;
 	resource_type?: string;
+	/** The floating AI assistant this page offers (page_route.assistant). */
+	assistant?: {
+		agent_config_slug: string;
+		resource_key: string;
+		launch_label: string;
+		placeholder?: string;
+	};
 	providers?: string[];
 }
 
@@ -409,13 +416,61 @@ export async function registerRegistryPageRoute(
 			} catch {
 				// No auth factory / no session → anonymous; gates fall back to token.
 			}
-			await runContentGate(resolved, gateCookie, gateNow, proposalGateConfig);
-			await runContentGate(resolved, gateCookie, gateNow, agreementGateConfig);
-				// The public GPT identity gate: seeds resolved.initialVisitor from the
-				// signed gpt_token cookie so a returning visitor's conversation renders
-				// at SSR (no capture-gate→chat flash). Open capture, seed-only — it
-				// never withholds page content (gpt-gate.ts).
-				await runContentGate(resolved, gateCookie, gateNow, gptGateConfig);
+			// EVERY REGISTERED GATE, IN CATALOG ORDER (content-gate/catalog.ts).
+			// This used to name proposalGateConfig, agreementGateConfig and
+			// gptGateConfig by hand, so a fourth gated resource type meant editing
+			// this file AND the second hand-written list in two-phase-boot.ts.
+			//
+			// SEQUENTIAL, NEVER PARALLEL. An authorized proposal viewer has their
+			// gate block removed from the resolved graph, and that removal is what
+			// makes the agreement gate find no resource and no-op on a page that
+			// carries both. Awaiting these together would race that dependency.
+			const gateOutcomes: ContentGateOutcome[] = [];
+			for (const entry of CONTENT_GATES) {
+				const outcome = await runContentGate(
+					resolved,
+					gateCookie,
+					gateNow,
+					entry.gate,
+				);
+				// A seed-only gate (open capture — the public GPT identity gate)
+				// withholds nothing, so its verdict is not evidence about whether
+				// this viewer may see the page and must not reach the assistant
+				// decision below. See withholdsContent, which derives that from the
+				// access config rather than restating it here.
+				if (withholdsContent(entry)) gateOutcomes.push(outcome);
+			}
+
+			// THE ASSISTANT IS A ROW, AND THIS IS THE ONE PLACE IT IS APPLIED.
+			// It used to be a call inside each gate's onAuthorized plus an entry
+			// in the hardcoded gate sequence above, so a third resource type
+			// meant editing this file. Now any page declaring `assistant` gets
+			// one and no page without the key does.
+			//
+			// GATED PAGES ONLY WHEN AUTHORIZED. The launcher's runtime context is
+			// the whole document serialised, so injecting past a closed gate
+			// would hand withheld bytes to the chat. A page no gate governs is
+			// public and gets the assistant unconditionally -- that is a
+			// different state from an unauthorized viewer, which is why the gate
+			// reports `applies` separately from `authorized`.
+			const assistant = routeConfig.assistant;
+			if (assistant) {
+				const governing = gateOutcomes.filter((outcome) => outcome.applies);
+				const authorized = governing.find((outcome) => outcome.authorized);
+				if (governing.length === 0 || authorized) {
+					await injectResourceChatLauncher(resolved, authorized?.email ?? "", {
+						resourceKey: assistant.resource_key,
+						agentConfigSlug: assistant.agent_config_slug as never,
+						launchLabel: assistant.launch_label,
+						placeholder: assistant.placeholder,
+						// From the loader row, so the injector never has to guess
+						// which resolved keys hold rendered content.
+						regionSlots: (
+							loaderConfig as { region_slots?: string[] }
+						).region_slots,
+					});
+				}
+			}
 			const meta = buildMetaFromContext(routeConfig.meta_context, resolved);
 		// /sign-in brand override: a shared org-scoped link 302→/sign-in for the
 		// unauthed crawler (WhatsApp), which saw the service's default website

package/src/resource-chat-inject.test.ts

@@ -11,8 +11,9 @@
  * (`components[row.slug] = …`), so a pushed block `type` must EQUAL an active
  * slug. The launcher block was consolidated to the single `ResourceLauncher`
  * row, but the injectors still pushed the pre-consolidation names —
- * `ResourceChatLauncher` here and `ChatLauncherBlock` in proposal-chat-inject.
- * Neither resolves, and because injection is deliberately fail-soft the page
+ * `ResourceChatLauncher` here, and `ChatLauncherBlock` in the bespoke proposal
+ * injector that has since been deleted in favour of this one. Neither name
+ * resolves, and because injection is deliberately fail-soft the page
  * rendered unchanged with no error: the classic shape of
  * `a-deleted-producer-leaves-its-consumers-executing`.
  *
@@ -32,15 +33,9 @@ mock.module("@teamscala/db/registry/load-config", () => ({
 	loadRegistryConfig: async () => ({ agentId: "agent-1" }),
 }));
 mock.module("./page-server-orpc/server-client.ts", () => ({
-	getServerClient: () => ({}),
-}));
-mock.module("@teamscala/logger/app-loggers", () => ({
-	getAppLogger: () => ({ error: () => {} }),
-}));
-mock.module("@teamscala/db/prisma-registry", () => ({
-	getPrisma: () => ({
+	getServerClient: () => ({
 		ai_agents: {
-			findUnique: async () => ({
+			findFirst: async () => ({
 				name: "Agreement Assistant",
 				welcome_message: "Hi! Ask me anything about this agreement.",
 				conversation_starters: ["What are the key terms?", "How do I sign this?"],
@@ -49,9 +44,11 @@ mock.module("@teamscala/db/prisma-registry", () => ({
 		},
 	}),
 }));
+mock.module("@teamscala/logger/app-loggers", () => ({
+	getAppLogger: () => ({ error: () => {} }),
+}));
 
 const { injectResourceChatLauncher } = await import("./resource-chat-inject.ts");
-const { injectProposalChatLauncher } = await import("./proposal-chat-inject.ts");
 
 function makeResolved(resourceKey: string): Record<string, unknown> {
 	return {
@@ -62,7 +59,11 @@ function makeResolved(resourceKey: string): Record<string, unknown> {
 }
 
 function pushedBlocks(resolved: Record<string, unknown>) {
-	const pd = (resolved.page as { puck_data: { content: Array<{ type: string }> } }).puck_data;
+	const pd = (
+		resolved.page as {
+			puck_data: { content: Array<{ type: string; props?: Record<string, unknown> }> };
+		}
+	).puck_data;
 	return pd.content;
 }
 
@@ -79,14 +80,6 @@ describe("chat injectors — pushed block name resolves to a registered block",
 		expect(blocks[0].type).toBe(REGISTERED_LAUNCHER_SLUG);
 	});
 
-	test("the proposal injector pushes the registered launcher slug", async () => {
-		const resolved = makeResolved("proposal");
-		await injectProposalChatLauncher(resolved, "viewer@example.com");
-		const blocks = pushedBlocks(resolved);
-		expect(blocks).toHaveLength(1);
-		expect(blocks[0].type).toBe(REGISTERED_LAUNCHER_SLUG);
-	});
-
 	test("neither injector pushes a pre-consolidation launcher name", async () => {
 		const a = makeResolved("agreement");
 		await injectResourceChatLauncher(a, "viewer@example.com", {
@@ -95,7 +88,11 @@ describe("chat injectors — pushed block name resolves to a registered block",
 			launchLabel: "Ask about this agreement",
 		});
 		const p = makeResolved("proposal");
-		await injectProposalChatLauncher(p, "viewer@example.com");
+		await injectResourceChatLauncher(p, "viewer@example.com", {
+			resourceKey: "proposal",
+			agentConfigSlug: "proposal-assistant-agent",
+			launchLabel: "Ask about this proposal",
+		});
 
 		const dead = ["ResourceChatLauncher", "ChatLauncherBlock"];
 		for (const blocks of [pushedBlocks(a), pushedBlocks(p)]) {
@@ -115,7 +112,7 @@ describe("chat injectors — pushed block name resolves to a registered block",
 			agentConfigSlug: "agreement-assistant-agent",
 			launchLabel: "Ask about this agreement",
 		});
-		const props = (pushedBlocks(resolved)[0] as { props: Record<string, unknown> }).props;
+		const props = pushedBlocks(resolved)[0].props ?? {};
 		expect(props.title).toBe("Agreement Assistant");
 		expect(props.welcomeMessage).toBe("Hi! Ask me anything about this agreement.");
 		expect(props.conversationStarters).toEqual([
@@ -126,3 +123,135 @@ describe("chat injectors — pushed block name resolves to a registered block",
 		expect(props.launchLabel).toBe("Ask about this agreement");
 	});
 });
+
+/** A region-slot page — the shape a quiz report resolves (no `page` source). */
+function makeAssessmentResolved(): Record<string, unknown> {
+	return {
+		response: {
+			organisation_id: "org-1",
+			email: "reader@example.com",
+			total_score: 95,
+			category_scores: { "Be Seen": 100, "Be Chosen": 83 },
+		},
+		quiz: { id: "quiz-1", report_title: "The Launcha Authority Index" },
+		reportData: { narrative: "You are strongest at being seen." },
+		brand: { primaryColor: "#123456" },
+		header: { puck_data: { content: [{ type: "SiteHeader" }] } },
+		body: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+		footer: { puck_data: { content: [{ type: "SiteFooter" }] } },
+	};
+}
+
+/** The launcher's props, wherever in the graph it was attached. */
+function launcherProps(resolved: Record<string, unknown>): Record<string, unknown> {
+	for (const value of Object.values(resolved)) {
+		const content = (value as { puck_data?: { content?: unknown } } | null)?.puck_data
+			?.content;
+		if (!Array.isArray(content)) continue;
+		const launcher = (content as Array<{ type: string; props?: Record<string, unknown> }>).find(
+			(block) => block.type === REGISTERED_LAUNCHER_SLUG,
+		);
+		if (launcher) return launcher.props ?? {};
+	}
+	throw new Error("no launcher block was attached to any region");
+}
+
+function bodyBlocks(resolved: Record<string, unknown>) {
+	return (
+		resolved.body as {
+			puck_data: { content: Array<{ type: string; props?: Record<string, unknown> }> };
+		}
+	).puck_data.content;
+}
+
+/**
+ * REGION SLOTS COME FROM THE LOADER ROW, exactly as the caller reads them —
+ * the injector is never allowed to guess which resolved keys hold content.
+ */
+const assessmentOpts = {
+	resourceKey: "response",
+	agentConfigSlug: "assessment-assistant-agent" as never,
+	launchLabel: "Ask about your results",
+	regionSlots: ["header", "body", "footer"],
+};
+
+describe("region-slot pages (a generated report, not an authored document)", () => {
+	test("attaches to a declared region when there is no `page` source", async () => {
+		// THE DEFECT THIS PINS: the injector read resolved.page.puck_data.content
+		// and returned early when absent. A generated report resolves region
+		// slots instead, so the early return fired and the assistant was
+		// silently missing — fail-soft, so nothing was logged.
+		const resolved = makeAssessmentResolved();
+		await injectResourceChatLauncher(resolved, "reader@example.com", assessmentOpts);
+		// The first declared slot holding a content tree. The launcher is
+		// position:fixed, so any rendered region shows it identically.
+		const header = (
+			resolved.header as { puck_data: { content: Array<{ type: string }> } }
+		).puck_data.content;
+		expect(header.map((block) => block.type)).toContain(REGISTERED_LAUNCHER_SLUG);
+	});
+
+	test("follows the loader's slot order rather than a hardcoded key", async () => {
+		// Reordering the row must move the launcher. If this passes while the
+		// code names "body", the derivation is a literal wearing a costume.
+		const resolved = makeAssessmentResolved();
+		await injectResourceChatLauncher(resolved, "reader@example.com", {
+			...assessmentOpts,
+			regionSlots: ["body", "header", "footer"],
+		});
+		expect(bodyBlocks(resolved).map((block) => block.type)).toContain(
+			REGISTERED_LAUNCHER_SLUG,
+		);
+	});
+
+	test("sends the assessment RESULT, not just the rendered page", async () => {
+		// A report's body page is a shared template — one builda_pages row serves
+		// every respondent — so the content tree holds zero personal facts. An
+		// assistant given only the page would know nothing about this reader.
+		const resolved = makeAssessmentResolved();
+		await injectResourceChatLauncher(resolved, "reader@example.com", assessmentOpts);
+		const context = String(launcherProps(resolved).runtimeContext ?? "");
+		expect(context).toContain("total_score");
+		expect(context).toContain("95");
+		expect(context).toContain("Be Chosen");
+		expect(context).toContain("You are strongest at being seen.");
+		expect(context).toContain("The Launcha Authority Index");
+	});
+
+	test("sends the rendered document too, not just the result", async () => {
+		// The mirror of the test above: the reader is asking about what is on
+		// screen, so the assistant needs the document as well as the data.
+		const resolved = makeAssessmentResolved();
+		(
+			resolved.body as { puck_data: { content: unknown[] } }
+		).puck_data.content.push({ type: "ScoreDial", props: { label: "Authority" } });
+		await injectResourceChatLauncher(resolved, "reader@example.com", assessmentOpts);
+		const context = String(launcherProps(resolved).runtimeContext ?? "");
+		expect(context).toContain("ScoreDial");
+		expect(context).toContain("Authority");
+	});
+
+	test("names no resolved key — it sends whatever the loader produced", async () => {
+		// THE REGRESSION THIS PINS: a draft excluded brand/website/header/footer
+		// by name, which is a loader row copied into TypeScript. Those keys are
+		// database facts, so the serialiser must not have opinions about them —
+		// it walks the graph and a loader edit propagates with no code change.
+		const resolved = makeAssessmentResolved();
+		await injectResourceChatLauncher(resolved, "reader@example.com", assessmentOpts);
+		const context = String(launcherProps(resolved).runtimeContext ?? "");
+		for (const key of Object.keys(resolved)) {
+			expect(context).toContain(key);
+		}
+	});
+
+	test("carries a source a future loader adds, with no edit here", async () => {
+		// The serialiser walks the graph rather than naming keys, so a loader
+		// resolving a new source reaches the assistant for free.
+		const resolved = makeAssessmentResolved();
+		resolved.benchmarks = { industryMedian: 62 };
+		await injectResourceChatLauncher(resolved, "reader@example.com", assessmentOpts);
+		const context = String(launcherProps(resolved).runtimeContext ?? "");
+		expect(context).toContain("industryMedian");
+		expect(context).toContain("62");
+	});
+});

package/src/resource-chat-inject.ts

@@ -22,7 +22,6 @@
 
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
-import { getPrisma } from "@teamscala/db/prisma-registry";
 import { getServerClient } from "./page-server-orpc/server-client.ts";
 import * as v from "valibot";
 import type { BlockSchemaKey } from "@teamscala/db/registry/generated/block-schema";
@@ -54,6 +53,12 @@ export interface ResourceChatOptions {
 	launchLabel: string;
 	/** Input placeholder. */
 	placeholder?: string;
+	/**
+	 * The loader row's `region_slots`, when this page has them — passed in rather
+	 * than guessed, so which keys hold rendered content stays a database fact.
+	 * Absent means a flat page whose content is under the `page` source.
+	 */
+	regionSlots?: readonly string[];
 }
 
 /**
@@ -79,8 +84,30 @@ export interface AgentPresentation {
 }
 
 export async function loadAgentPresentation(agentId: string): Promise<AgentPresentation> {
+	// THROUGH ORPC, NEVER PRISMA DIRECTLY (`no-direct-prisma-outside-orpc`).
+	// This is the same service-scoped client the ProductTiers read above uses;
+	// `ai_agents` is already in the declared models of both services that mount
+	// a launcher, so no schema change is needed to read it here.
+	const client = getServerClient() as {
+		ai_agents?: {
+			findFirst: (args: {
+				where: { id: string };
+				select: {
+					name: true;
+					welcome_message: true;
+					conversation_starters: true;
+					primary_color: true;
+				};
+			}) => Promise<{
+				name: string | null;
+				welcome_message: string | null;
+				conversation_starters: unknown;
+				primary_color: string | null;
+			} | null>;
+		};
+	};
 	try {
-		const agent = await getPrisma().ai_agents.findUnique({
+		const agent = await client.ai_agents?.findFirst({
 			where: { id: agentId },
 			select: {
 				name: true,
@@ -113,10 +140,90 @@ export async function loadAgentPresentation(agentId: string): Promise<AgentPrese
 	}
 }
 
-/** Serialise the resource record + entire page content tree as text for the GPT. */
+/** A resolved source that carries a Puck content tree. */
+function puckContentOf(value: unknown): unknown[] | null {
+	const content = (value as { puck_data?: { content?: unknown } } | null | undefined)
+		?.puck_data?.content;
+	return Array.isArray(content) ? content : null;
+}
+
+/**
+ * The rendered content tree to append the launcher to.
+ *
+ * WHICH KEYS EXIST IS A ROW FACT, SO IT IS NOT SPELLED HERE. A page's resolved
+ * sources and its region slots are declared on the `resource_loader` row, and
+ * the caller has already read that row — so it passes `regionSlots` in. An
+ * earlier draft of this function named "page", "body", "header" and "footer" as
+ * literals, which is a loader row copied into TypeScript, free to drift from it
+ * the moment a loader is edited (`identity-is-imported-never-spelled`).
+ *
+ * A FLAT PAGE KEEPS ITS CONTENT UNDER `page`; A REGION-SLOT PAGE DOES NOT.
+ * Proposals and agreements resolve one `page` source, so the original injector
+ * read `resolved.page.puck_data.content` and returned early when it was absent.
+ * A generated report resolves region slots instead, so that early return fired
+ * and the assistant was silently missing — the same failure shape as the dead
+ * block name, since fail-soft injection logs nothing and the page looks fine.
+ *
+ * ANY RENDERED REGION WILL DO, SO THE FIRST DECLARED ONE IS TAKEN. The launcher
+ * renders `position: fixed` at `zIndex: 50`, anchored to the viewport and not
+ * to its container, so it appears identically whichever region carries it. That
+ * is what makes "first declared region holding a content tree" a derivation
+ * rather than a guess dressed up as one: there is no better region to prefer.
+ *
+ * `PAGE_SOURCE_KEY` is the platform's existing name for a flat page's body
+ * source — the same convention `decideContentPageFloor` already keys on in the
+ * caller. One shared convention, not a per-resource list.
+ */
+const PAGE_SOURCE_KEY = "page";
+
+function findContentHost(
+	resolved: Record<string, unknown>,
+	regionSlots?: readonly string[],
+): unknown[] | null {
+	if (regionSlots?.length) {
+		for (const slot of regionSlots) {
+			const content = puckContentOf(resolved[slot]);
+			if (content) return content;
+		}
+		return null;
+	}
+	return puckContentOf(resolved[PAGE_SOURCE_KEY]);
+}
+
+/**
+ * Serialise EVERYTHING THIS VIEWER MAY SEE as text for the assistant.
+ *
+ * BOTH THE RESULT AND THE RENDERED DOCUMENT, BECAUSE NEITHER IS SUFFICIENT.
+ * The original serialiser sent the resource record plus the page's content
+ * tree, which is exactly right for a proposal — the proposal's substance IS in
+ * its blocks. It is wrong for anything the platform GENERATES a document from.
+ * A report's body page is a shared template (one `builda_pages` row serves
+ * every respondent) so the content tree holds headings and layout and not one
+ * personal fact, while the substance — the answers, the category scores, the
+ * computed narrative and bands — sits in sibling resolved keys the serialiser
+ * never looked at. Sending only the page would give the assistant a form with
+ * no answers; sending only the record would leave it unable to discuss what the
+ * reader is actually looking at. An assessment result GENERATES a report, so
+ * the assistant needs both halves of that.
+ *
+ * NO KEY IS NAMED, INCLUDED OR EXCLUDED. The loader row decides what a page
+ * resolves; this walks whatever that produced. A draft carried a `CHROME_KEYS`
+ * exclusion list dropping brand, website, header and footer — every one of them
+ * a loader source key, which is to say database facts hardcoded here to save a
+ * few hundred tokens of colours and navigation markup. Not a trade worth a
+ * literal that goes stale in silence. A loader resolving a new source reaches
+ * the assistant with no edit here (`offered-is-derived`).
+ *
+ * IT CANNOT OUTRUN THE GATE, BY CONSTRUCTION. This runs AFTER every content
+ * gate, and a gate withholds by REMOVING content from this same graph. So
+ * "everything in the graph" and "everything this viewer may see" are the same
+ * set, and they cannot drift — which is what makes serialising the whole graph
+ * safe rather than reckless.
+ */
 async function buildResourceContext(
 	resolved: Record<string, unknown>,
 	resourceKey: string,
+	regionSlots?: readonly string[],
 ): Promise<string> {
 	const record = resolved[resourceKey] as Record<string, unknown> | undefined;
 	const parts: string[] = [];
@@ -131,11 +238,17 @@ async function buildResourceContext(
 		parts.push(`Description: ${record.description}`);
 	}
 
-	// Dump the entire page content tree — every block, every prop, verbatim.
-	const page = (resolved.page as { puck_data?: { content?: unknown[] } } | undefined)?.puck_data;
-	if (page && Array.isArray(page.content)) {
-		parts.push("\n--- Document content ---");
-		parts.push(JSON.stringify(page.content, null, 2));
+	for (const [key, value] of Object.entries(resolved)) {
+		if (value == null || typeof value === "function") continue;
+		const content = puckContentOf(value);
+		if (content) {
+			// A rendered document: every block, every prop, verbatim.
+			parts.push(`\n--- Document content (${key}) ---`);
+			parts.push(JSON.stringify(content, null, 2));
+			continue;
+		}
+		parts.push(`\n--- ${key} ---`);
+		parts.push(JSON.stringify(value, null, 2));
 	}
 
 	// Resolve DB-backed product tiers when present (proposals) so the GPT sees
@@ -148,7 +261,9 @@ async function buildResourceContext(
 			}) => Promise<{ id: string; billing_type: string; tiers: unknown; components: unknown } | null>;
 		};
 	};
-	for (const block of (page?.content ?? []) as Array<Record<string, unknown>>) {
+	for (const block of (findContentHost(resolved, regionSlots) ?? []) as Array<
+		Record<string, unknown>
+	>) {
 		if (block?.type !== "ProductTiers") continue;
 		const props = block.props as Record<string, unknown> | undefined;
 		if (!props) continue;
@@ -188,8 +303,10 @@ export async function injectResourceChatLauncher(
 	viewerEmail: string,
 	opts: ResourceChatOptions,
 ): Promise<void> {
-	const page = (resolved.page as { puck_data?: { content?: unknown[] } } | undefined)?.puck_data;
-	if (!page || !Array.isArray(page.content)) return;
+	// Whichever region actually renders — `page` on a flat document, `body` on a
+	// region-slot one. No rendered content at all → nothing to attach to.
+	const hostContent = findContentHost(resolved, opts.regionSlots);
+	if (!hostContent) return;
 
 	const record = resolved[opts.resourceKey] as Record<string, unknown> | undefined;
 	const organisationId =
@@ -208,9 +325,13 @@ export async function injectResourceChatLauncher(
 	if (!agentId) return;
 
 	try {
-		const runtimeContext = await buildResourceContext(resolved, opts.resourceKey);
+		const runtimeContext = await buildResourceContext(
+			resolved,
+			opts.resourceKey,
+			opts.regionSlots,
+		);
 		const presentation = await loadAgentPresentation(agentId);
-		(page.content as Array<Record<string, unknown>>).push({
+		(hostContent as Array<Record<string, unknown>>).push({
 			type: LAUNCHER_BLOCK,
 			props: {
 				id: `${opts.resourceKey}-chat-launcher`,

package/src/two-phase-boot.ts

@@ -24,9 +24,7 @@ import { cors } from "hono/cors";
 import { timing } from "hono/timing";
 import { attachContentGateAccess } from "./content-gate/access.ts";
 import { initGateTtls } from "./gate-ttls.ts";
-import { agreementAccessConfig } from "./agreement-gate.ts";
-import { proposalAccessConfig } from "./proposal-gate.ts";
-import { gptAccessConfig } from "./gpt-gate.ts";
+import { CONTENT_GATES } from "./content-gate/catalog.ts";
 import { attachProposalAccept } from "./attach-proposal-accept.ts";
 import { attachAgreementMagic } from "./attach-agreement-magic.ts";
 import { getCookieDomain } from "@teamscala/db/registry/cookie-domain";
@@ -327,9 +325,15 @@ export async function buildMinimalApp(
 	// beyond the Hono app's synchronous route array — so they parallelise.
 	await runStep("public-routes", () =>
 		Promise.all([
-			attachContentGateAccess(app, serviceSlug, agreementAccessConfig),
-			attachContentGateAccess(app, serviceSlug, proposalAccessConfig),
-			attachContentGateAccess(app, serviceSlug, gptAccessConfig),
+			// EVERY REGISTERED GATE'S ACCESS ENDPOINT (content-gate/catalog.ts).
+			// The same catalog the SSR gate sequence iterates, so the endpoint that
+			// MINTS a gate's token and the gate that VERIFIES it cannot disagree
+			// about which gates exist — this list and that one were two copies of
+			// one fact, and a gate added to one and missed in the other is a page
+			// that gates content with no way to unlock it.
+			...CONTENT_GATES.map((entry) =>
+				attachContentGateAccess(app, serviceSlug, entry.access),
+			),
 			attachProposalAccept(app, serviceSlug),
 			attachAgreementMagic(app, serviceSlug),
 			attachProposalMagic(app, serviceSlug),

package/src/proposal-chat-inject.ts

@@ -1,158 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Injects the ProposalChatLauncher block into an AUTHORISED proposal page (called
- * from proposalGateConfig.onAuthorized — so the bubble lives strictly behind the
- * email gate, and every proposal gets it with no per-page Puck edit). It builds
- * the proposal's full page content into a runtime-context string and passes it to
- * the launcher, which forwards it to the chat as <runtime_context> — so ONE shared
- * "Proposal Assistant" agent answers about whichever proposal is being viewed.
- *
- * The agent id is config, not code (registries-are-source-of-truth): the
- * `config / proposal-assistant-agent` row carries { agentId }. No row (or no
- * agent) → no injection, the page renders exactly as before (fail-soft).
- */
-
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
-import { getServerClient } from "./page-server-orpc/server-client.ts";
-import { loadAgentPresentation } from "./resource-chat-inject.ts";
-import * as v from "valibot";
-import type { BlockSchemaKey } from "@teamscala/db/registry/generated/block-schema";
-
-const AgentConfigSchema = v.object({ agentId: v.string() });
-
-// THE PUSHED BLOCK NAME IS AN IMPORTED IDENTITY, NEVER A SPELLED STRING.
-// discover-blocks keys the Puck registry off block_schema.slug alone
-// (`components[row.slug] = …`), so a type that is not a live slug resolves to
-// nothing — and because injection is fail-soft, the page renders unchanged with
-// no error. That is exactly how the bubble went missing from every gated
-// proposal and agreement: the block was consolidated to ResourceLauncher and
-// these injectors kept pushing their pre-consolidation names. BlockSchemaKey is
-// the generated union of live slugs, so annotating it here makes a stale name a
-// COMPILE error instead of a silent absence (identity-is-imported-never-spelled).
-const LAUNCHER_BLOCK: BlockSchemaKey = "ResourceLauncher";
-
-/** Serialise the entire page content tree as text for the GPT context. */
-async function buildProposalContext(resolved: Record<string, unknown>): Promise<string> {
-	const proposal = resolved.proposal as Record<string, unknown> | undefined;
-	const parts: string[] = [];
-
-	if (typeof proposal?.name === "string" && proposal.name) {
-		parts.push(`Proposal title: ${proposal.name}`);
-	}
-	if (typeof proposal?.client_name === "string" && proposal.client_name) {
-		parts.push(`Prepared for: ${proposal.client_name}`);
-	}
-	if (typeof proposal?.description === "string" && proposal.description) {
-		parts.push(`Description: ${proposal.description}`);
-	}
-
-	// Dump the entire page content tree — every block, every prop, verbatim.
-	const page = (resolved.page as { puck_data?: { content?: unknown[] } } | undefined)?.puck_data;
-	if (page && Array.isArray(page.content)) {
-		parts.push("\n--- Page content ---");
-		parts.push(JSON.stringify(page.content, null, 2));
-	}
-
-	// Resolve DB-backed product tiers so the GPT sees actual pricing data.
-	const client = getServerClient() as {
-		products?: {
-			findFirst: (args: {
-				where: { id: string };
-				select: { id: true; billing_type: true; tiers: true; components: true };
-			}) => Promise<{
-				id: string;
-				billing_type: string;
-				tiers: unknown;
-				components: unknown;
-			} | null>;
-		};
-	};
-
-	for (const block of (page?.content ?? []) as Array<Record<string, unknown>>) {
-		if (block?.type !== "ProductTiers") continue;
-		const props = block.props as Record<string, unknown> | undefined;
-		if (!props) continue;
-
-		const productIds = [
-			props.productId,
-			props.productId2,
-			props.productId3,
-		].filter((id): id is string => typeof id === "string" && id.trim().length > 0);
-
-		for (const pid of productIds) {
-			try {
-				const product = await client.products?.findFirst({
-					where: { id: pid },
-					select: { id: true, billing_type: true, tiers: true, components: true },
-				});
-				if (product) {
-					parts.push(`\n--- Product tiers (productId: ${pid}) ---`);
-					parts.push(JSON.stringify(product, null, 2));
-				}
-			} catch {
-				// best-effort
-			}
-		}
-	}
-
-	return parts.join("\n");
-}
-
-function brandPrimaryColor(resolved: Record<string, unknown>): string {
-	const brand = resolved.brand as { primaryColor?: unknown } | undefined;
-	return typeof brand?.primaryColor === "string" ? brand.primaryColor : "";
-}
-
-export async function injectProposalChatLauncher(
-	resolved: Record<string, unknown>,
-	viewerEmail: string,
-): Promise<void> {
-	const page = (resolved.page as { puck_data?: { content?: unknown[] } } | undefined)?.puck_data;
-	if (!page || !Array.isArray(page.content)) return;
-
-	const proposal = resolved.proposal as Record<string, unknown> | undefined;
-	const organisationId =
-		typeof proposal?.organisation_id === "string" ? proposal.organisation_id : "";
-	if (!organisationId) return;
-
-	let agentId = "";
-	try {
-		agentId = (
-			await loadRegistryConfig("config", "proposal-assistant-agent", AgentConfigSchema)
-		).agentId;
-	} catch {
-		return; // no agent configured yet → no bubble (fail-soft, page unchanged)
-	}
-	if (!agentId) return;
-
-	try {
-		const runtimeContext = await buildProposalContext(resolved);
-		const presentation = await loadAgentPresentation(agentId);
-		(page.content as Array<Record<string, unknown>>).push({
-			type: LAUNCHER_BLOCK,
-			props: {
-				id: "proposal-chat-launcher",
-				agentId,
-				organisationId,
-				viewerEmail,
-				runtimeContext,
-				// Copy comes from the agent row (see loadAgentPresentation): these
-				// three were spelled here while ai_agents held blank columns for
-				// each of them.
-				primaryColor: brandPrimaryColor(resolved) || presentation.primaryColor,
-				title: presentation.title,
-				welcomeMessage: presentation.welcomeMessage,
-				conversationStarters: presentation.conversationStarters,
-				launchLabel: "Ask about this proposal",
-			},
-		});
-	} catch (err) {
-		getAppLogger().error(
-			`[proposal-chat] launcher injection failed: ${err instanceof Error ? err.message : String(err)}`,
-		);
-	}
-}