@teamscala/service-boot 0.23.506 → 0.23.508

package/package.json

@@ -1131,5 +1131,5 @@
   "repository": "https://github.com/teamgbg/service-boot",
   "sideEffects": false,
   "type": "module",
-  "version": "0.23.506"
+  "version": "0.23.508"
 }

package/src/bind-page-handler.ts

@@ -22,10 +22,7 @@
 		// wave-parallel loader, brotli) is the sanctioned path; re-adding shared-cache headers needs a fresh operator ruling.
 
 import { getAppLogger } from "@teamscala/logger/app-loggers";
-import {
-	withGateEntryClears,
-	takeGateEntryClears,
-} from "./content-gate/gate-entry-clears.ts";
+import { withGateEntryClears } from "./content-gate/gate-entry-clears.ts";
 import type { Context } from "hono";
 import { readHtmlTemplate } from "./read-html-template.ts";
 import {
@@ -127,7 +124,7 @@ export async function bindPageHandler(
 
 		const nonce = c.get("nonce") as string | undefined;
 
-		const resp = await withGateEntryClears(async () =>
+		const { result: resp, clears: gateEntryClears } = await withGateEntryClears(async () =>
 			handler(c.req.raw, {
 				userId,
 				orgId,
@@ -142,7 +139,7 @@ export async function bindPageHandler(
 		// clears it here, so the next load (a refresh) is unauthorized and shows
 		// the gate again. Without this the marker would outlive the view that
 		// used it and every load would skip the gate.
-		for (const name of takeGateEntryClears()) {
+		for (const name of gateEntryClears) {
 			headers.append(
 				"Set-Cookie",
 				`${name}=; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=0`,

package/src/content-gate/access.ts

@@ -38,6 +38,17 @@ export async function attachContentGateAccess(
 		let email = "";
 		let name = "";
 		let phone = "";
+		// Optional prospect segmentation a capture gate's composed form may post
+		// (the quiz identity screen: company, LinkedIn, website, team size). Every
+		// field is optional and every reader treats absence as "" — a gate that
+		// never collects them (the GPT) is unaffected, and a form that collects
+		// only some carries the rest as absent. Field names follow the response
+		// columns the segmentation lands in (linkedin_url / team_size, snake case)
+		// because the composed form posts exactly what its FormField rows name.
+		let company = "";
+		let linkedinUrl = "";
+		let website = "";
+		let teamSize = "";
 		let bodyFailed = false;
 		// The resource id may ride on the URL instead of the body. A gate whose
 		// form is COMPOSED FROM BLOCKS has no place to put a hidden field — the
@@ -58,6 +69,10 @@ export async function attachContentGateAccess(
 			// Captured alongside the email by an open-capture gate's composed
 			// form. It rides in the signed token rather than any client store.
 			phone = String(form.phone ?? "").trim();
+			company = String(form.company ?? "").trim();
+			linkedinUrl = String(form.linkedin_url ?? "").trim();
+			website = String(form.website ?? "").trim();
+			teamSize = String(form.team_size ?? "").trim();
 		} catch (error) {
 			log.warn(`[content-gate:${config.cookieName}] body parse failed — redirecting back: ${String(error)}`);
 			bodyFailed = true;
@@ -94,6 +109,9 @@ export async function attachContentGateAccess(
 			Date.now(),
 			name || undefined,
 			phone || undefined,
+			company || linkedinUrl || website || teamSize
+				? { company, linkedinUrl, website, teamSize }
+				: undefined,
 		);
 		if (token) {
 			const maxAge = Math.floor(config.ttlMs / 1000);

package/src/content-gate/config-types.ts

@@ -11,6 +11,19 @@
 
 type Resolved = Record<string, unknown>;
 
+/**
+ * Optional prospect-segmentation a lead-capture gate may capture alongside the
+ * identity. The quiz gate collects these on its composed identity screen; the
+ * token carries them so the next render and the final submit know the visitor
+ * fully, with NO client storage (same reasoning as the captured name/phone).
+ */
+export interface GateSegmentation {
+	company?: string;
+	linkedinUrl?: string;
+	website?: string;
+	teamSize?: string;
+}
+
 /** Drives the SSR-time gate (gate.ts / runContentGate). */
 export interface ContentGateConfig {
 	/** Cookie that carries this gate's access token (e.g. "ag_token"). */
@@ -35,7 +48,7 @@ export interface ContentGateConfig {
 		token: string | undefined,
 		resourceId: string,
 		nowMs: number,
-	): { email: string; name?: string; phone?: string } | null;
+	): { email: string; name?: string; phone?: string; segmentation?: GateSegmentation } | null;
 	/**
 	 * BAKED-IN unified auth. When a gate provides this resolver, the engine
 	 * AUTOMATICALLY releases a logged-in viewer whose session email is in the
@@ -64,7 +77,7 @@ export interface ContentGateConfig {
 	onAuthorized(
 		resolved: Resolved,
 		resourceId: string,
-		identity: { email: string; name?: string; phone?: string },
+		identity: { email: string; name?: string; phone?: string; segmentation?: GateSegmentation },
 	): void | Promise<void>;
 	/** Withhold content (strip/inject the gate) — token absent/invalid. Async-
 	 *  capable so a gate can load its display/behaviour settings from a registry
@@ -111,9 +124,10 @@ export interface AccessConfig {
 	resolveAuthorizedEmails(resourceId: string): Promise<Set<string>>;
 	/**
 	 * Mint the access token for a matched email (token-agnostic per gate).
-	 * `name` and `phone` are the optional captured identity (open-capture gates
-	 * carry them in the token; allow-list gates ignore them). They exist so a
-	 * capture gate needs no browser storage to remember who this is.
+	 * `name` and `phone` are the optional captured identity, `segmentation` the
+	 * optional captured prospect fields (open-capture gates carry them in the
+	 * token; allow-list gates ignore them). They exist so a capture gate needs
+	 * no browser storage to remember who this is.
 	 */
 	signToken(
 		resourceId: string,
@@ -121,5 +135,6 @@ export interface AccessConfig {
 		nowMs: number,
 		name?: string,
 		phone?: string,
+		segmentation?: GateSegmentation,
 	): string | null;
 }

package/src/content-gate/gate-entry-clears.ts

@@ -10,6 +10,12 @@
  * gate. The gate writes the name here; bindPageHandler — which owns the page
  * Response — drains it into Set-Cookie, so the marker lives exactly one view.
  *
+ * THE CLEARS COME BACK AS THE CALL'S RETURN VALUE, never from a post-hoc
+ * read: the store only exists inside the run() scope, so a reader called after
+ * the awaited call has already left it and would see an empty list — which is
+ * exactly how the first version of this file shipped a marker that was never
+ * cleared (measured live 2026-09-14: the cookie survived the render).
+ *
  * AsyncLocalStorage rather than a module-level map: request-scoped by
  * construction, no accumulated process state that a restart would silently
  * reset (in-memory-state-is-not-durable).
@@ -18,8 +24,12 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 const clears = new AsyncLocalStorage<string[]>();
 
-export async function withGateEntryClears<T>(fn: () => Promise<T>): Promise<T> {
-	return clears.run([], fn);
+export async function withGateEntryClears<T>(
+	fn: () => Promise<T>,
+): Promise<{ result: T; clears: string[] }> {
+	const list: string[] = [];
+	const result = await clears.run(list, fn);
+	return { result, clears: [...list] };
 }
 
 export function recordGateEntryClear(cookieName: string): void {
@@ -29,10 +39,3 @@ export function recordGateEntryClear(cookieName: string): void {
 	// throwing would make an otherwise valid direct invocation a failure.
 	if (list && !list.includes(cookieName)) list.push(cookieName);
 }
-
-export function takeGateEntryClears(): string[] {
-	const list = clears.getStore() ?? [];
-	const out = [...list];
-	list.length = 0;
-	return out;
-}

package/src/content-gate/gate-entry-marker.test.ts

@@ -7,8 +7,12 @@
  * entryCookieName must behave exactly as before — a valid token authorizes on
  * any load and nothing is recorded for clearing (condition 1: every non-opting
  * service unchanged). An opting gate authorizes ONLY the request that carries
- * the marker (the identity submit's own redirect) and records the marker so the
- * page Response clears it — one view, then the gate is presented again.
+ * the marker (the identity submit's own redirect) and returns the marker name
+ * so the page Response clears it — one view, then the gate is presented again.
+ *
+ * The clears are asserted from the CALL'S RETURN VALUE: the store lives only
+ * inside the run() scope, and the first shipped version read it afterwards,
+ * saw nothing, and left the marker in the browser (measured live 2026-09-14).
  *
  * Operator ruling 2026-09-14 (refresh must return to the identity gate),
  * mechanism measured live: the quiz_token cookie alone was the carrier that
@@ -17,10 +21,7 @@
 import { describe, expect, test } from "bun:test";
 import type { ContentGateConfig } from "./config-types.ts";
 import { runContentGate } from "./gate.ts";
-import {
-	takeGateEntryClears,
-	withGateEntryClears,
-} from "./gate-entry-clears.ts";
+import { withGateEntryClears } from "./gate-entry-clears.ts";
 
 function makeConfig(entryCookieName?: string) {
 	const calls = { authorized: 0, unauthorized: 0 };
@@ -41,30 +42,30 @@ function makeConfig(entryCookieName?: string) {
 }
 
 describe("gate entry marker is opt-in and one-view", () => {
-	test("non-opting gate: a valid token authorizes on any load, nothing recorded — behaviour unchanged", async () => {
+	test("non-opting gate: a valid token authorizes on any load, nothing cleared — behaviour unchanged", async () => {
 		const { cfg, calls } = makeConfig();
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate({}, "quiz_token=good", Date.now(), cfg);
 			expect(out.authorized).toBe(true);
 			expect(calls.authorized).toBe(1);
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual([]);
 	});
 
 	test("opting gate: token WITHOUT the marker is unauthorized — a refresh shows the gate", async () => {
 		const { cfg, calls } = makeConfig("quiz_token_entered");
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate({}, "quiz_token=good", Date.now(), cfg);
 			expect(out.authorized).toBe(false);
 			expect(calls.unauthorized).toBe(1);
 			expect(calls.authorized).toBe(0);
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual([]);
 	});
 
-	test("opting gate: token + marker authorizes and records the marker for clearing, exactly once", async () => {
+	test("opting gate: token + marker authorizes and RETURNS the marker for clearing — one view", async () => {
 		const { cfg, calls } = makeConfig("quiz_token_entered");
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate(
 				{},
 				"quiz_token=good; quiz_token_entered=1",
@@ -73,15 +74,13 @@ describe("gate entry marker is opt-in and one-view", () => {
 			);
 			expect(out.authorized).toBe(true);
 			expect(calls.authorized).toBe(1);
-			expect(takeGateEntryClears()).toEqual(["quiz_token_entered"]);
-			// drained: the next load must not re-clear
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual(["quiz_token_entered"]);
 	});
 
-	test("opting gate: marker present but token invalid stays unauthorized and records nothing", async () => {
+	test("opting gate: marker present but token invalid stays unauthorized and clears nothing", async () => {
 		const { cfg, calls } = makeConfig("quiz_token_entered");
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate(
 				{},
 				"quiz_token=bad; quiz_token_entered=1",
@@ -90,8 +89,18 @@ describe("gate entry marker is opt-in and one-view", () => {
 			);
 			expect(out.authorized).toBe(false);
 			expect(calls.unauthorized).toBe(1);
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual([]);
+	});
+
+	test("two gates in one request each report their own marker, drained once", async () => {
+		const first = makeConfig("gate_a_entered");
+		const second = makeConfig("gate_b_entered");
+		const { clears } = await withGateEntryClears(async () => {
+			await runContentGate({}, "quiz_token=good; gate_a_entered=1", Date.now(), first.cfg);
+			await runContentGate({}, "quiz_token=good; gate_b_entered=1", Date.now(), second.cfg);
+		});
+		expect(clears).toEqual(["gate_a_entered", "gate_b_entered"]);
 	});
 
 	test("the quiz gate and its access endpoint both opt in on the same marker name", async () => {

package/src/content-gate/token.segmentation.test.ts

@@ -0,0 +1,76 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Segmentation carriage in the content-gate token. The quiz's composed gate
+ * screen captures company/linkedin_url/website/team_size alongside the
+ * identity; the token carries them to the next render so the submit can put
+ * all seven fields on the ONE response row with no client storage. The
+ * generated `token.test.ts` owns the identity/binding suite; these are the
+ * segmentation-specific cases (including the backward-compatibility contract:
+ * a token minted before `s` existed verifies identically).
+ */
+
+process.env.AUTH_SECRET = "local-test-fixture-entropy-0001";
+
+import { describe, expect, test } from "bun:test";
+import { signAccessToken, verifyAccessTokenIdentity } from "./token.ts";
+
+const NOW = 1_000_000_000_000;
+const TTL = 60_000;
+
+function decodePayload(token: string): Record<string, unknown> {
+	return JSON.parse(Buffer.from(token.split(".")[0], "base64url").toString());
+}
+
+describe("content-gate token — segmentation carriage", () => {
+	test("round-trips the four captured fields", () => {
+		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, "Ann", "+614", {
+			company: "Acme",
+			linkedinUrl: "https://www.linkedin.com/in/ann",
+			website: "https://acme.test",
+			teamSize: "Me + team of 2–5",
+		});
+		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
+		expect(id?.email).toBe("a@b.com");
+		expect(id?.name).toBe("Ann");
+		expect(id?.phone).toBe("+614");
+		expect(id?.segmentation).toEqual({
+			company: "Acme",
+			linkedinUrl: "https://www.linkedin.com/in/ann",
+			website: "https://acme.test",
+			teamSize: "Me + team of 2–5",
+		});
+	});
+
+	test("BACKWARD COMPATIBILITY: a pre-widening token (no s key) verifies with segmentation undefined — never an error", () => {
+		// Mint with the old shape by omitting segmentation entirely, then assert
+		// the exact contract a deploy-window survivor must satisfy.
+		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, "Ann", "+614");
+		expect(decodePayload(t as string).s).toBeUndefined();
+		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
+		expect(id).toEqual({ email: "a@b.com", name: "Ann", phone: "+614", segmentation: undefined });
+	});
+
+	test("empty/whitespace segmentation values produce no s key at all", () => {
+		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, undefined, undefined, {
+			company: "   ",
+			linkedinUrl: "",
+			website: undefined,
+			teamSize: undefined,
+		});
+		expect(decodePayload(t as string).s).toBeUndefined();
+		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
+		expect(id?.segmentation).toBeUndefined();
+	});
+
+	test("values are trimmed on sign", () => {
+		const t = signAccessToken("quiz_token", "quiz-1", "a@b.com", NOW, TTL, undefined, undefined, {
+			company: "  Acme  ",
+			teamSize: "Just me",
+		});
+		const id = verifyAccessTokenIdentity(t, "quiz_token", "quiz-1", NOW + 1);
+		expect(id?.segmentation).toEqual({ company: "Acme", teamSize: "Just me" });
+	});
+});

package/src/content-gate/token.ts

@@ -24,6 +24,8 @@
  * Fail-closed: no usable secret yields null (no token, no access).
  */
 
+import type { GateSegmentation } from "./config-types.ts";
+
 function secret(): string | null {
 	for (const s of [
 		process.env.AUTH_SECRET,
@@ -68,10 +70,26 @@ export function signAccessToken(
 	 * 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 } = {
+	const payload: {
+		c: string;
+		r: string;
+		e: string;
+		x: number;
+		n?: string;
+		p?: string;
+		s?: GateSegmentation;
+	} = {
 		c: cookieName,
 		r: resourceId,
 		e: email.trim().toLowerCase(),
@@ -81,6 +99,16 @@ export function signAccessToken(
 	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)}`;
 }
@@ -121,17 +149,25 @@ export function verifyAccessToken(
 }
 
 /**
- * Like `verifyAccessToken` but returns the full verified identity ({email, name, phone})
- * 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. Same
- * signature/expiry/gate-binding checks; null on any failure.
+ * 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 } | null {
+): {
+	email: string;
+	name?: string;
+	phone?: string;
+	segmentation?: GateSegmentation;
+} | null {
 	if (!token) return null;
 	const key = secret();
 	if (!key) return null;
@@ -148,15 +184,27 @@ export function verifyAccessTokenIdentity(
 			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/handlers/platform-fault-escalation/delivery.ts

@@ -13,6 +13,7 @@
  */
 
 import type { ExecutionContext } from "@teamscala/os/contracts/mcp";
+import { idsWhereJsonKey } from "@teamscala/db/json-key-filter";
 import { recordEvent } from "@teamscala/event-log/record-event";
 import {
 	composeEscalationMessage,
@@ -36,11 +37,18 @@ interface OperatorRelayBot {
 }
 
 async function resolveOperatorRelay(): Promise<OperatorRelayBot> {
+	// flow_config.mode lives inside json; the v8 builder cannot address it.
+	const relayBotIds = await idsWhereJsonKey({
+		table: "messaging_bots",
+		column: "flow_config",
+		key: "mode",
+		equals: "operator-relay",
+	});
 	const bot = (await (await orpc()).messaging_bots.findFirst({
 		where: {
 			is_active: true,
 			platform: "whatsapp",
-			flow_config: { path: ["mode"], equals: "operator-relay" },
+			id: { in: relayBotIds },
 		},
 		select: { id: true, organisation_id: true, external_id: true, flow_config: true },
 	})) as unknown as OperatorRelayBot | null;

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

@@ -0,0 +1,100 @@
+/**
+ * @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 connectionString = captured?.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(captured?.useListenNotify).toBe(false);
+		// pg-boss stays a single sibling connection (pool sizing doctrine).
+		expect(captured?.max).toBe(1);
+	});
+});

package/src/pg-boss-mount.ts

@@ -135,7 +135,22 @@ export async function mountPgBoss(
 	// shared URL's libpq spelling — route through the canonical rewrite.
 	// Config object (not a bare connectionString) so the internal pool is
 	// bounded + tagged for the ~220ms cross-internet dev→Railway RTT.
+	// POLL-ONLY, EXPLICITLY. pg-boss v12 dispatches by polling (SELECT .. FOR
+	// UPDATE SKIP LOCKED inside a transaction; its locks are
+	// pg_advisory_xact_lock — transaction-scoped, so a transaction pooler
+	// cannot leak them); LISTEN/NOTIFY is a supplier-documented latency hint
+	// whose registration dies on a transaction-pooler backend reassignment
+	// (measured 2026-09-14: the opted-in sync worker boss logged
+	// `LISTEN/NOTIFY channel registration was lost` every log window).
+	// attorney.js defaults useListenNotify to false in 12.29.0 (pinned),
+	// 12.30.0 (deployed) and 12.31.1 (latest) — all three read directly —
+	// and spelling it here keeps that contract explicit so a pg-boss bump
+	// cannot silently re-introduce a LISTEN dependency
+	// (close-the-session-mode-door, 2026-09-14). The connection dials the
+	// injected DATABASE_URL — the transaction pooler — reconciling the pg
+	// sslmode dialect; the mount adds no endpoint derivation of its own.
 	const boss = new PgBoss({
+		useListenNotify: false,
 		connectionString: pgSslCompatUrl(ctx.databaseUrl),
 		application_name: `pgboss:${ctx.serviceSlug}`,
 		// ONE connection, not three: pg-boss is a sibling pool that sits OUTSIDE
@@ -145,7 +160,7 @@ export async function mountPgBoss(
 		// background degradation (`a-per-consumer-pool-max-is-not-a-bound-on-the-server`:
 		// background work degrades to a queue, interactive work degrades to an
 		// outage). The sibling total is declared in
-		// config/db-pool-sizing.perServiceOverhead (pg-boss 1 + LISTEN 1 = 2).
+		// config/db-pool-sizing.perServiceOverhead (pg-boss 1; the LISTEN allowance is gone with poll-only).
 		max: 1,
 		// Generous connection-acquisition budget for the cross-internet link so
 		// a slow TLS handshake under sustained load doesn't terminate the conn.

package/src/quiz-gate.ts

@@ -56,12 +56,23 @@ export const quizGateConfig: ContentGateConfig = {
 	verifyToken(token, resourceId, nowMs) {
 		return verifyAccessTokenIdentity(token, QUIZ_COOKIE, resourceId, nowMs);
 	},
-	onAuthorized(resolved, _resourceId, { email, name, phone }) {
+	onAuthorized(resolved, _resourceId, { email, name, phone, segmentation }) {
 		// The one fact the page's block conditions read. Present → the identity
 		// container hides and the quiz container shows; absent → the reverse.
+		// The segmentation (captured on the same composed screen) rides along so
+		// the quiz flow starts already knowing the prospect — its submit then
+		// persists all seven identity fields on the ONE response row.
 		(resolved as {
-			initialVisitor?: { name?: string; email: string; phone?: string };
-		}).initialVisitor = { name, email, phone };
+			initialVisitor?: {
+				name?: string;
+				email: string;
+				phone?: string;
+				company?: string;
+				linkedinUrl?: string;
+				website?: string;
+				teamSize?: string;
+			};
+		}).initialVisitor = { name, email, phone, ...segmentation };
 	},
 	onUnauthorized(resolved, resourceId) {
 		// The endpoint the identity form posts to, PUBLISHED INTO THE PAGE DATA
@@ -91,7 +102,7 @@ export const quizAccessConfig: AccessConfig = {
 	async resolveAuthorizedEmails() {
 		return new Set<string>();
 	},
-	signToken(resourceId, email, nowMs, name, phone) {
-		return signAccessToken(QUIZ_COOKIE, resourceId, email, nowMs, quizTtlMs(), name, phone);
+	signToken(resourceId, email, nowMs, name, phone, segmentation) {
+		return signAccessToken(QUIZ_COOKIE, resourceId, email, nowMs, quizTtlMs(), name, phone, segmentation);
 	},
 };