@teamscala/service-boot 0.23.524 → 0.23.526

package/src/content-gate/token.ts

@@ -1,197 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-
-import type { GateSegmentation } from "./config-types.ts";
-import { resolveDbUrlOrNull } from "@teamscala/db/db-url";
-
-function secret(): string | null {
-	// The last resort is the tenant DB address, read through the named-need
-	// resolver (wrong-database guard, 2026-09-27) — never `process.env` here;
-	// the resolver is the only env-aware surface and it names the plane. It is
-	// used only as a stable per-deployment string (≥16 chars), never as a
-	// connection target.
-	for (const s of [
-		process.env.AUTH_SECRET,
-		process.env.ENCRYPTION_KEY,
-		resolveDbUrlOrNull("tenant"),
-	]) {
-		if (s && s.length >= 16) return s;
-	}
-	return null;
-}
-
-function hmac(payloadB64: string, key: string): string {
-	return new Bun.CryptoHasher("sha256", key).update(payloadB64).digest("base64url");
-}
-
-/** Constant-time string compare (equal-length); avoids node:crypto. */
-function safeEqual(a: string, b: string): boolean {
-	if (a.length !== b.length) return false;
-	let diff = 0;
-	for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-	return diff === 0;
-}
-
-/** Mint a token proving `email` is authorized for `resourceId` under `cookieName`. */
-export function signAccessToken(
-	cookieName: string,
-	resourceId: string,
-	email: string,
-	nowMs: number,
-	ttlMs: number,
-	/**
-	 * Optional display name to carry in the token (the public GPT lead-capture
-	 * gate uses this so a returning visitor's name is known at SSR — first paint
-	 * renders the full identity, not just the email). Allow-list gates
-	 * (proposals/agreements) omit it.
-	 */
-	name?: string,
-	/**
-	 * Optional captured phone, same reasoning as `name`. It exists so a capture
-	 * gate needs NO browser storage to remember it: the operator's ruling is
-	 * that identity lives in the database and the request, never in
-	 * localStorage.
-	 */
-	phone?: string,
-	/**
-	 * Optional prospect segmentation captured alongside the identity on the
-	 * quiz's composed gate screen (company / LinkedIn / website / team size).
-	 * Same reasoning as name/phone: it rides the signed request, never client
-	 * storage. OPTIONAL and absent from older tokens — a token without it
-	 * verifies exactly as before.
-	 */
-	segmentation?: GateSegmentation,
-): string | null {
-	const key = secret();
-	if (!key) return null;
-	const payload: {
-		c: string;
-		r: string;
-		e: string;
-		x: number;
-		n?: string;
-		p?: string;
-		s?: GateSegmentation;
-	} = {
-		c: cookieName,
-		r: resourceId,
-		e: email.trim().toLowerCase(),
-		x: nowMs + ttlMs,
-	};
-	const trimmedName = name?.trim();
-	if (trimmedName) payload.n = trimmedName;
-	const trimmedPhone = phone?.trim();
-	if (trimmedPhone) payload.p = trimmedPhone;
-	const seg: GateSegmentation = {};
-	const segCompany = segmentation?.company?.trim();
-	if (segCompany) seg.company = segCompany;
-	const segLinkedin = segmentation?.linkedinUrl?.trim();
-	if (segLinkedin) seg.linkedinUrl = segLinkedin;
-	const segWebsite = segmentation?.website?.trim();
-	if (segWebsite) seg.website = segWebsite;
-	const segTeamSize = segmentation?.teamSize?.trim();
-	if (segTeamSize) seg.teamSize = segTeamSize;
-	if (Object.keys(seg).length > 0) payload.s = seg;
-	const payloadB64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
-	return `${payloadB64}.${hmac(payloadB64, key)}`;
-}
-
-/**
- * Validate a token for `cookieName` + `resourceId`. Returns the verified email
- * on success, null otherwise (bad signature, wrong gate, wrong resource,
- * expired, no secret).
- */
-export function verifyAccessToken(
-	token: string | undefined | null,
-	cookieName: string,
-	resourceId: string,
-	nowMs: number,
-): string | null {
-	if (!token) return null;
-	const key = secret();
-	if (!key) return null;
-	const dot = token.indexOf(".");
-	if (dot <= 0) return null;
-	const payloadB64 = token.slice(0, dot);
-	const sig = token.slice(dot + 1);
-	if (!safeEqual(sig, hmac(payloadB64, key))) return null;
-	try {
-		const p = JSON.parse(Buffer.from(payloadB64, "base64url").toString()) as {
-			c?: string;
-			r?: string;
-			e?: string;
-			x?: number;
-		};
-		if (p.c !== cookieName) return null;
-		if (p.r !== resourceId) return null;
-		if (typeof p.x !== "number" || p.x < nowMs) return null;
-		return typeof p.e === "string" ? p.e : null;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Like `verifyAccessToken` but returns the full verified identity
- * ({email, name, phone, segmentation}) so a gate that carries a display name in
- * the token (the public GPT lead-capture gate) can seed the visitor's name — not
- * just the email — at SSR, and the quiz gate can seed the captured prospect
- * segmentation the same way. Same signature/expiry/gate-binding checks; null on
- * any failure. A token minted BEFORE segmentation existed carries no `s` key and
- * verifies identically (segmentation comes back undefined) — never an error.
- */
-export function verifyAccessTokenIdentity(
-	token: string | undefined | null,
-	cookieName: string,
-	resourceId: string,
-	nowMs: number,
-): {
-	email: string;
-	name?: string;
-	phone?: string;
-	segmentation?: GateSegmentation;
-} | null {
-	if (!token) return null;
-	const key = secret();
-	if (!key) return null;
-	const dot = token.indexOf(".");
-	if (dot <= 0) return null;
-	const payloadB64 = token.slice(0, dot);
-	const sig = token.slice(dot + 1);
-	if (!safeEqual(sig, hmac(payloadB64, key))) return null;
-	try {
-		const p = JSON.parse(Buffer.from(payloadB64, "base64url").toString()) as {
-			c?: string;
-			r?: string;
-			e?: string;
-			x?: number;
-			n?: string;
-			p?: string;
-			s?: GateSegmentation;
-		};
-		if (p.c !== cookieName) return null;
-		if (p.r !== resourceId) return null;
-		if (typeof p.x !== "number" || p.x < nowMs) return null;
-		if (typeof p.e !== "string") return null;
-		const segmentation =
-			p.s && typeof p.s === "object"
-				? {
-						company: typeof p.s.company === "string" ? p.s.company : undefined,
-						linkedinUrl:
-							typeof p.s.linkedinUrl === "string" ? p.s.linkedinUrl : undefined,
-						website: typeof p.s.website === "string" ? p.s.website : undefined,
-						teamSize: typeof p.s.teamSize === "string" ? p.s.teamSize : undefined,
-					}
-				: undefined;
-		return {
-			email: p.e,
-			name: typeof p.n === "string" ? p.n : undefined,
-			phone: typeof p.p === "string" ? p.p : undefined,
-			segmentation,
-		};
-	} catch {
-		return null;
-	}
-}

package/src/is-react-element-type.test.ts

@@ -1,45 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { expect, test } from "bun:test";
-import { forwardRef, lazy, memo } from "react";
-import { isReactElementType } from "./is-react-element-type.ts";
-
-function Plain() {
-	return null;
-}
-
-test("accepts a plain function component", () => {
-	expect(isReactElementType(Plain)).toBe(true);
-});
-
-test("accepts memo() — the PresenceAvatars shape that rendered blank", () => {
-	expect(isReactElementType(memo(Plain))).toBe(true);
-});
-
-test("accepts forwardRef()", () => {
-	expect(isReactElementType(forwardRef(() => null))).toBe(true);
-});
-
-test("accepts lazy()", () => {
-	expect(isReactElementType(lazy(async () => ({ default: Plain })))).toBe(true);
-});
-
-test("still rejects what genuinely cannot render", () => {
-	expect(isReactElementType(undefined)).toBe(false);
-	expect(isReactElementType(null)).toBe(false);
-	expect(isReactElementType({})).toBe(false);
-	expect(isReactElementType("PresenceAvatarsBlock")).toBe(false);
-	expect(isReactElementType(42)).toBe(false);
-});
-
-test("rejects a plain object wearing a non-symbol $$typeof", () => {
-	// A data blob with the key but not the symbol must not pass as renderable.
-	expect(isReactElementType({ $$typeof: "react.memo" })).toBe(false);
-});

package/src/is-react-element-type.ts

@@ -1,10 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-
-export function isReactElementType(value: unknown): boolean {
-	if (typeof value === "function") return true;
-	if (typeof value !== "object" || value === null) return false;
-	return typeof (value as { $$typeof?: unknown }).$$typeof === "symbol";
-}

package/src/page-server-orpc/hub-mcp-client.ts

@@ -1,14 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-
-let _hubMcpClient: unknown | null = null;
-
-export function setHubMcpClient(client: unknown): void {
-	_hubMcpClient = client;
-}
-
-export function getHubMcpClient(): unknown | undefined {
-	return _hubMcpClient ?? undefined;
-}

package/src/pg-boss-mount.test.ts

@@ -1,101 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * The mount's poll-only contract: pg-boss v12 dispatches by polling, so the
- * mount dials the INJECTED transaction-pooler URL unchanged (no endpoint
- * derivation of its own — the session-port mapping died with the door,
- * 2026-09-14) and constructs with useListenNotify false spelled explicitly
- * rather than inherited from the supplier default, so a pg-boss bump cannot
- * silently re-introduce a LISTEN dependency. The mock captures the opts
- * PgBoss is constructed with — the claim is about what the mount DIALS and
- * how it dispatches, so the assertions are on the captured opts.
- */
-
-import { afterEach, describe, expect, it, mock } from "bun:test";
-
-interface CapturedOpts {
-	connectionString?: string;
-	max?: number;
-	useListenNotify?: boolean;
-}
-
-const POOLED_URL =
-	"postgresql://scala_container_gbg.gbg:s3cret@10.205.50.1:6543/scala_container_gbg?sslmode=require";
-
-function seedScheduledJob() {
-	return {
-		id: "test-job-1",
-		type: "scheduled_job",
-		slug: "scheduled_job:test-sync",
-		label: "Test Sync Job",
-		description: null,
-		config: {
-			handler_slug: "@teamscala/sync-worker:processSyncQueue",
-			cron: "*/5 * * * *",
-			queue_name: "sync-worker",
-		},
-		is_active: true,
-		sort_order: 0,
-		created_at: new Date(),
-		updated_at: new Date(),
-		noun: "scheduled_job",
-		kind: "scheduled_job",
-	};
-}
-
-describe("mountPgBoss poll-only contract", () => {
-	afterEach(() => {
-		mock.restore();
-	});
-
-	it("dials the injected transaction pooler unchanged and dispatches poll-only", async () => {
-		let captured: CapturedOpts | null = null;
-
-		mock.module("pg-boss", () => ({
-			PgBoss: mock((opts: CapturedOpts) => {
-				captured = opts;
-				return {
-					start: mock(() => Promise.resolve()),
-					stop: mock(() => Promise.resolve()),
-					on: mock(() => undefined),
-					createQueue: mock(() => Promise.resolve()),
-					work: mock(() => Promise.resolve("worker-id")),
-					schedule: mock(() => Promise.resolve()),
-					getSchedules: mock(() => Promise.resolve([])),
-					unschedule: mock(() => Promise.resolve()),
-				};
-			}),
-		}));
-		mock.module("@teamscala/db/registry/accessors", () => ({
-			getAllEntries: () => [seedScheduledJob()],
-		}));
-		mock.module("@teamscala/event-log/record-event", () => ({
-			recordEvent: () => undefined,
-		}));
-
-		const { mountPgBoss } = await import("./pg-boss-mount.ts");
-		await mountPgBoss({
-			databaseUrl: POOLED_URL,
-			serviceSlug: "scala-sync-worker",
-			packages: ["@teamscala/sync-worker"],
-		});
-
-		const capturedOpts = captured as unknown as CapturedOpts | undefined;
-		const connectionString = capturedOpts?.connectionString ?? "";
-		// The transaction pooler, exactly as injected — the mount adds no
-		// endpoint derivation.
-		expect(connectionString).toContain(":6543");
-		// NEVER the session port: the door is closing, not widening.
-		expect(connectionString).not.toContain(":5999");
-		// The tenant suffix the pooler routes by is kept.
-		expect(connectionString).toContain("scala_container_gbg.gbg:");
-		// The pg sslmode dialect rewrite still applies.
-		expect(connectionString).toContain("sslmode=no-verify");
-		// Poll-only, spelled: no LISTEN dependency, now and after a bump.
-		expect(capturedOpts?.useListenNotify).toBe(false);
-		// pg-boss stays a single sibling connection (pool sizing doctrine).
-		expect(capturedOpts?.max).toBe(1);
-	});
-});

package/src/register-registry-page-route/graph-cache.test.ts

@@ -1,81 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { describe, expect, test } from "bun:test";
-import { createCache } from "@teamscala/cache/create-cache";
-import { readCachedGraph } from "./graph-cache.ts";
-
-const delay = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
-
-describe("readCachedGraph", () => {
-	test("fresh hit returns the cached value and fires NO refresh", async () => {
-		const cache = createCache<unknown>("graph-cache-test:fresh", {
-			maxSize: 4,
-			ttlMs: 1000,
-			staleTtlMs: 1000,
-		});
-		let refreshCalls = 0;
-		cache.set("k", "v");
-		expect(readCachedGraph(cache, "k", async () => ++refreshCalls)).toBe("v");
-		await delay(5);
-		expect(refreshCalls).toBe(0);
-	});
-
-	test("stale hit returns the cached value AND fires the background refresh", async () => {
-		const cache = createCache<unknown>("graph-cache-test:stale", {
-			maxSize: 4,
-			ttlMs: 20,
-			staleTtlMs: 5000,
-		});
-		let refreshCalls = 0;
-		cache.set("k", "v");
-		await delay(40); // past ttlMs (fresh) → within staleTtlMs → stale
-		// Serves the stale value instantly...
-		expect(readCachedGraph(cache, "k", async () => ++refreshCalls)).toBe("v");
-		// ...and fires exactly one background refresh.
-		await delay(5);
-		expect(refreshCalls).toBe(1); // FAILS if the background refresh stops firing
-	});
-
-	test("miss returns undefined so the caller resolves synchronously", () => {
-		const cache = createCache<unknown>("graph-cache-test:miss", {
-			maxSize: 4,
-			ttlMs: 1000,
-			staleTtlMs: 1000,
-		});
-		let refreshCalls = 0;
-		expect(
-			readCachedGraph(cache, "absent", async () => ++refreshCalls),
-		).toBeUndefined();
-		expect(refreshCalls).toBe(0);
-	});
-
-	test("stale refresh is single-flight (a second stale read while in-flight does not re-fire)", async () => {
-		const cache = createCache<unknown>("graph-cache-test:dedup", {
-			maxSize: 4,
-			ttlMs: 20,
-			staleTtlMs: 5000,
-		});
-		let refreshCalls = 0;
-		let resolveRefresh: (value: number) => void = () => {};
-		const slowRefresh = (): Promise<number> =>
-			new Promise<number>((resolve) => {
-				refreshCalls++;
-				resolveRefresh = resolve;
-			});
-		cache.set("k", "v");
-		await delay(40); // stale
-		readCachedGraph(cache, "k", slowRefresh); // fires refresh → in-flight
-		readCachedGraph(cache, "k", slowRefresh); // deduped against the same in-flight map
-		await delay(5);
-		expect(refreshCalls).toBe(1); // only ONE refresh in flight, not two
-		resolveRefresh(refreshCalls);
-		await delay(5);
-	});
-});

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

@@ -1,71 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- */
-/**
- * Stale-while-revalidate read of a cached loader graph.
- *
- * - Fresh hit (within ttlMs): return the cached graph, no refresh.
- * - Stale hit (within ttlMs + staleTtlMs): return the cached graph AND fire ONE
- *   background refresh via cache.refreshInBackground — single-flight (deduped
- *   against the cache's in-flight map), never rejects, leaves the stale entry in
- *   place on failure. The caller deep-clones the returned value before use.
- * - Miss (past staleTtlMs, or never cached): return undefined — the caller
- *   resolves synchronously and cache.set()s the clone.
- *
- * The refresh callback must return a graph safe to store. To SKIP caching a
- * refresh result (e.g. a primary-missing / dead-link graph that must stay
- * per-request so a just-created record appears immediately), the callback THROWS
- * — refreshInBackground catches it, leaves the stale entry, and logs one line
- * (an observable dead-link signal, not a hard error).
- */
-
-import { createCache } from "@teamscala/cache/create-cache";
-
-// The structural surface readCachedGraph touches (getWithMeta + refreshInBackground).
-// ManagedCache<unknown> satisfies it; declared locally so the SWR decision does
-// not depend on the cache package's internal type export path.
-type GraphCache = {
-	getWithMeta(key: string): { value: unknown; stale: boolean } | undefined;
-	refreshInBackground(
-		key: string,
-		compute: () => Promise<unknown>,
-		opts?: { ttlMs?: number },
-	): void;
-};
-
-// Static-shell routes (no resource_type, no :params, no wildcard — the fleet
-// dashboard's "/", any fixed page) resolve the SAME loader graph every request:
-// pure page/website structure that changes only on editor writes, yet every SSR
-// re-paid the full graph over the tunnel DB (load=1.8-2.2s measured 2026-06-06 —
-// the whole remaining load tier). 60s fresh (ttlMs) + 540s stale (staleTtlMs) =
-// 600s total; past the fresh window a hit still serves instantly and fires ONE
-// background re-resolve. Without SWR every cache-expiry request paid the full
-// resolve in-request — measured 3.8s on a cache-expired hit.
-export const staticShellGraphCache = createCache<unknown>(
-	"registry-route:static-shell-graph",
-	{ maxSize: 64, ttlMs: 60_000, staleTtlMs: 540_000 },
-);
-
-// Parameterised routes (:param / wildcard — record pages, the portal catchall)
-// were permanently uncacheable: every hit re-paid the full graph resolve (~2.3s
-// from the dev host). The graphKey encodes routeRow.slug + host + path and the
-// graph is purely path-determined (searchParams, theme, agreement gating all
-// apply AFTER the clone), so a short fresh window is safe: a record edit is
-// visible within 15s on a trafficked page (background refresh). 15s fresh
-// (ttlMs) + 285s stale (staleTtlMs) = 300s total.
-export const paramRouteGraphCache = createCache<unknown>(
-	"registry-route:param-route-graph",
-	{ maxSize: 256, ttlMs: 15_000, staleTtlMs: 285_000 },
-);
-
-export function readCachedGraph(
-	cache: GraphCache,
-	key: string,
-	refresh: () => Promise<unknown>,
-): unknown | undefined {
-	const meta = cache.getWithMeta(key);
-	if (meta === undefined) return undefined;
-	if (meta.stale) cache.refreshInBackground(key, refresh);
-	return meta.value;
-}

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

@@ -1,145 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-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);
-	});
-});