@teamscala/service-boot 0.23.495 → 0.23.497

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.495",
+  "version": "0.23.497",
   "sideEffects": false,
   "imports": {
     "#service-boot/*": "./src/*",

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

@@ -0,0 +1,165 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * resource-chat-inject.page-assistant.test.ts — the page assistant must be
+ * PRESENT IN RENDERED OUTPUT on every link shape a page resolves.
+ *
+ * THE DEFECT THIS PINS (found 2026-09-08, quiz report page): the page_route's
+ * assistant named resource_key "response" — the loader's RAW response hit.
+ * On /report/<response-id> that hit exists and the chat bubble injected. On
+ * anchor links (a research-record id, live or superseded) the raw hit is
+ * null, injectResourceChatLauncher read no organisation_id off it, returned
+ * SILENTLY, and the page rendered a complete report at 200 with the
+ * assistant simply absent — 552KB of script gone, no error anywhere. The
+ * page's reportData was byte-identical across all three shapes, which is
+ * exactly why a data-equality check could not see it: the launcher is a
+ * separate BLOCK whose presence depends on resolved[resourceKey], not on the
+ * report data.
+ *
+ * THE FIX SHAPE: the page's resource_key names the PAIRED key ("pair"),
+ * which exists on every link shape and carries organisation_id (the pair
+ * resolver returns the anchor half's organisation). These tests drive the
+ * injector with graphs shaped exactly like the loader produces for each of
+ * the three link shapes and assert the launcher lands in the rendered
+ * content tree — the thing that becomes markup — for ALL THREE. A
+ * data-equality assertion cannot pass in their place.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+/** The ONE active launcher block_schema slug — the Puck registry key. */
+const REGISTERED_LAUNCHER_SLUG = "ResourceLauncher";
+
+mock.module("@teamscala/db/registry/load-config", () => ({
+	loadRegistryConfig: async () => ({ agentId: "agent-1" }),
+}));
+mock.module("./page-server-orpc/server-client.ts", () => ({
+	getServerClient: () => ({
+		ai_agents: {
+			findFirst: async () => ({
+				name: "Results Assistant",
+				welcome_message: "Hi! Ask me anything about your results.",
+				conversation_starters: ["What are my strengths?"],
+				primary_color: "#6366f1",
+			}),
+		},
+	}),
+}));
+mock.module("@teamscala/logger/app-loggers", () => ({
+	getAppLogger: () => ({ error: (...args: unknown[]) => void args }),
+}));
+
+const { injectResourceChatLauncher } = await import("./resource-chat-inject.ts");
+
+const ORG = "org-1";
+const AGENT_OPTS = {
+	agentConfigSlug: "assessment-assistant-agent" as never,
+	launchLabel: "Ask about your results",
+	placeholder: "Ask about your results…",
+	regionSlots: ["header", "body", "footer"] as readonly string[],
+};
+
+/** A resolved response row as the loader's response source selects it. */
+const RESPONSE_ROW = {
+	id: "resp-1",
+	assessment_id: "asm-1",
+	organisation_id: ORG,
+	total_score: 64,
+	first_name: "Anna",
+};
+
+/** The paired key as resolveReportHalves returns it — present on EVERY link
+ *  shape, carrying the anchor half's organisation. */
+const PAIRED = {
+	response: RESPONSE_ROW,
+	research: { id: "research-live", assessment_id: "asm-1", organisation_id: ORG },
+	assessment_id: "asm-1",
+	organisation_id: ORG,
+};
+
+function pageGraph(
+	responseSource: unknown,
+	pairSource: Record<string, unknown>,
+): Record<string, unknown> {
+	return {
+		response: responseSource,
+		pair: pairSource,
+		quiz: { id: "asm-1", organisation_id: ORG, title: "Authority Index" },
+		brand: { primaryColor: "#123456" },
+		body: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+		header: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+		footer: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+	};
+}
+
+/** The launcher renders `position: fixed`, so it may land in whichever
+ *  region slot is declared first — count across EVERY slot, not one. */
+function launcherBlocks(
+	resolved: Record<string, unknown>,
+): Array<{ type: string; props?: Record<string, unknown> }> {
+	const out: Array<{ type: string; props?: Record<string, unknown> }> = [];
+	for (const slot of AGENT_OPTS.regionSlots) {
+		const content = (
+			resolved[slot] as {
+				puck_data?: { content?: Array<{ type: string; props?: Record<string, unknown> }> };
+			}
+		).puck_data?.content;
+		for (const block of content ?? []) {
+			if (block.type === REGISTERED_LAUNCHER_SLUG) out.push(block);
+		}
+	}
+	return out;
+}
+
+async function launcherCount(
+	responseSource: unknown,
+	pairSource: Record<string, unknown>,
+	resourceKey: string,
+): Promise<number> {
+	const resolved = pageGraph(responseSource, pairSource);
+	await injectResourceChatLauncher(resolved, "", { ...AGENT_OPTS, resourceKey });
+	return launcherBlocks(resolved).length;
+}
+
+describe("page assistant renders on every link shape", () => {
+	test("response-id link: raw hit exists, launcher renders", async () => {
+		expect(await launcherCount(RESPONSE_ROW, PAIRED, "pair")).toBe(1);
+	});
+
+	test("live research-anchor link: raw hit is null, launcher still renders", async () => {
+		expect(await launcherCount(null, PAIRED, "pair")).toBe(1);
+	});
+
+	test("superseded research-anchor link: raw hit is null, launcher still renders", async () => {
+		// identical graph shape to the live anchor — resolution to the live
+		// pass happens upstream in the pair resolver, so the injection surface
+		// is the same and is exercised identically
+		expect(await launcherCount(null, PAIRED, "pair")).toBe(1);
+	});
+
+	test("the launcher block carries the agent, org scope and context", async () => {
+		const resolved = pageGraph(null, PAIRED);
+		await injectResourceChatLauncher(resolved, "viewer@example.com", {
+			...AGENT_OPTS,
+			resourceKey: "pair",
+		});
+		const launchers = launcherBlocks(resolved);
+		expect(launchers.length).toBe(1);
+		const launcher = launchers[0];
+		expect(launcher.props.agentId).toBe("agent-1");
+		expect(launcher.props.organisationId).toBe(ORG);
+		expect(typeof launcher.props.runtimeContext).toBe("string");
+		expect((launcher.props.runtimeContext as string).length).toBeGreaterThan(0);
+	});
+
+	test("the DEFECT SHAPE: keying the raw response hit on an anchor link silently renders none", async () => {
+		// resource_key "response" + a null raw hit is the 2026-09-08 regression.
+		// The injector contract is fail-soft for the render, so the absence is
+		// quiet — this pins the shape with the reason spelled out, so the row
+		// can never go back to a key that is null on anchor links without the
+		// next reader finding this.
+		expect(await launcherCount(null, PAIRED, "response")).toBe(0);
+	});
+});

package/src/resource-chat-inject.ts

@@ -315,7 +315,21 @@ export async function injectResourceChatLauncher(
 	const organisationId =
 		opts.organisationId ||
 		(typeof record?.organisation_id === "string" ? record.organisation_id : "");
-	if (!organisationId) return;
+	if (!organisationId) {
+		// THIS BAIL USED TO BE SILENT, AND A SILENT DROP IS THE WORST FAILURE
+		// SHAPE A BLOCK CAN HAVE (measured 2026-09-08 on the quiz report): the
+		// page returns 200 and looks complete while the assistant is simply
+		// absent — resource_key named a resolved key that is null on some link
+		// shapes (a research-anchor link has no raw response match), and the
+		// page rendered a full report with no bubble and no error anywhere.
+		// The page must stay usable (fail-soft for the RENDER is the contract),
+		// but a declared assistant that did not inject is never "fine": name
+		// the key and the reason so the absence is observable.
+		getAppLogger().error(
+			`[resource-chat] assistant declared but NOT injected: resolved["${opts.resourceKey}"] is ${record === undefined ? "absent" : "null"} or carries no organisation_id — the launcher is silently missing from this page`,
+		);
+		return;
+	}
 
 	let agentId = "";
 	try {