@teamscala/service-boot 0.23.350 → 0.23.352

package/src/agreement-gate.ts

@@ -280,7 +280,7 @@ async function buildSigningSession(
 				// A named "viewer"/"cc" recipient — like an org member below — is
 				// view-only: authedRole "viewer" matches no party key, so no slot.
 				// Certificate data is built only for a party signer (same email-must-
-				// be-a-party gate as publicAgreement.certificate) and seeded for inline
+				// be-a-party gate) and seeded for inline
 				// render; a view-only recipient gets null (and the cell never shows it).
 				const isSigner = me.recipientRole === "signer";
 				const cert = isSigner

package/src/auth-gate.ts

@@ -107,17 +107,6 @@ const PUBLIC_INFRA_PREFIXES = [
 	// for no session). They replaced the former /api/data/sign-in-flow-config,
 	// /check-session, /portals HANDLER_MAP entries (handler-map-retirement).
 	"/api/rpc/fn/signInFlow/",
-	// fn.taskSync procedures (lane task-list <-> work_items). Exempt so a
-	// localhost hook/plugin (Claude PostToolUse curl, OpenCode scala-hooks
-	// fetch) reaches the ORPC router, where mount-orpc-router's resolveUser
-	// grants localhost -> super_admin (the documented internal caller model) and
-	// a non-localhost caller still needs a session (resolveUser returns null ->
-	// authed throws 401). Safety rests on Host:127.0.0.1 being unforgeable
-	// through the Cloudflare tunnel (the edge sets Host to the public hostname)
-	// — verified by the negative case (a non-localhost caller is rejected).
-	// Tighter than signInFlow: NOT anonymous-allowed (signInFlow returns {} for
-	// no session; taskSync writes require super-admin or a real session).
-	"/api/rpc/fn/taskSync/",
 	// scala-enroll device-onboarding: the machine-facing installer + register
 	// routes are TOKEN-authenticated (a single-use enrollment token issued by a
 	// logged-in, dev_access-approved operator), fetched by the onboardee via

package/src/fn-routers/index.ts

@@ -12,34 +12,27 @@
  * `loadPage` procedure (reusing puckPagesRouter.loadFromWebsite) so a client
  * RegionPageSwap can fetch a region's Puck page on demand and render it into a
  * slot — the no-reload half of `region-views-are-pages` (every region is a Puck
- * page; switching a view loads a different page's content). loadById is NOT
- * exposed (website+path is the client-facing contract, not raw page ids).
+ * page; switching a view loads a different page's content).
  */
 
 import { registerCustomRouter } from "@teamscala/orpc/app-router";
 import { puckPagesRouter } from "@teamscala/service-boot/page-server-orpc/puck-pages-router";
 import { watchDataChange } from "@teamscala/realtime-utils/data-change-procedure";
 import { watchPresence } from "@teamscala/realtime-utils/presence-procedure";
-import { aiHealthHandler } from "./ai-health-router.ts";
-import { resolvePanelDataHandler } from "./panel-data-router.ts";
 import { agreementSendRouter } from "./agreement-send-router.ts";
 import { cacheAdminRouter } from "./cache-admin-router.ts";
 import { chatSessionRouter } from "./chat-session-router.ts";
 import { proposalSendRouter } from "./proposal-send-router.ts";
 import { authRouter } from "./auth-router.ts";
-import { plansRouter } from "./plans-router.ts";
 import { publicAgreementRouter } from "./public-agreement-router.ts";
 import { publicAssessmentRouter } from "./public-assessment-router.ts";
 import { publicGptSessionRouter } from "./public-gpt-session-router.ts";
 import { signInFlowRouter } from "./sign-in-flow-router.ts";
-import { tasksRouter } from "./tasks-router.ts";
 import { userPreferencesRouter } from "./user-preferences-router.ts";
-import { userPreferencesRouter as portalPreferencesRouter } from "../page-server-orpc/user-preferences-router.ts";
 import { workItemsRouter } from "./work-items-router.ts";
 
 export function registerFnRouters(): void {
 	registerCustomRouter("fn", {
-		aiHealth: aiHealthHandler,
 		agreementSend: agreementSendRouter,
 		proposalSend: proposalSendRouter,
 		auth: authRouter,
@@ -49,17 +42,13 @@ export function registerFnRouters(): void {
 		publicAssessment: publicAssessmentRouter,
 		publicGptSession: publicGptSessionRouter,
 		signInFlow: signInFlowRouter,
-		tasks: tasksRouter,
 		workItems: workItemsRouter,
 		userPreferences: userPreferencesRouter,
-		portalPreferences: portalPreferencesRouter,
-		plans: plansRouter,
 	});
 	registerCustomRouter("regions", {
 		loadPage: puckPagesRouter.loadFromWebsite,
 		// Resolve a page-kind panel's OWN loaderData (panel_view.loader_slug) so a
 		// panel region renders against the panel page's data, not the host's.
-		resolvePanelData: resolvePanelDataHandler,
 	});
 	registerCustomRouter("realtime", {
 		watchDataChange,

package/src/fn-routers/public-agreement-router.ts

@@ -256,10 +256,8 @@ async function loadCertificateCopy(): Promise<CertificateCopy | null> {
 }
 
 /** The Certificate of Completion data shape — the court-style audit certificate.
- *  One home: {@link buildCertificateData} is consumed by both the
- *  `publicAgreement.certificate` ORPC and the SSR agreement gate, so the signing
- *  block receives identical data whether it reads the ORPC response or the
- *  server-seeded prop. */
+ *  One home: {@link buildCertificateData} is consumed by the SSR agreement
+ *  gate, so the signing block receives the server-seeded prop. */
 export interface CertificateData {
 	ok: boolean;
 	envelopeId?: string;
@@ -292,8 +290,8 @@ export interface CertificateData {
 /**
  * Build the Certificate of Completion data for an agreement, gated to a party
  * email — signer evidence (IP/device) is never exposed to a non-party. One data
- * home: the `publicAgreement.certificate` ORPC and the SSR agreement gate
- * (`buildSigningSession` in agreement-gate.ts) both call this. The read is
+ * home: the SSR agreement gate (`buildSigningSession` in agreement-gate.ts)
+ * calls this. The read is
  * intentionally RLS-unscoped via the raw registry prisma — the certificate is
  * reached without a session (AG cookie only), which context.prisma's RLS would
  * otherwise treat as no-org and hide. Accepts either the agreement record id or
@@ -306,22 +304,24 @@ export async function buildCertificateData(
 	const id = agreementId.trim();
 	const mail = email.trim().toLowerCase();
 	if (!id || !mail) return { ok: false };
-	const { getPrisma } = await import("@teamscala/db/prisma-registry");
-	const db = getPrisma();
-	const agreement = await db.agreements.findFirst({
-		where: { OR: [{ id }, { page_id: id }] },
-		select: {
-			id: true,
-			name: true,
-			created_at: true,
-			sent_at: true,
-			viewed_at: true,
-			signed_at: true,
-			signature_data: true,
-			signer_email: true,
-			signer_name: true,
-		},
-	});
+	const [agreement] = await queryRows<
+		{
+			id: string;
+			name: string;
+			created_at: Date | null;
+			sent_at: Date | null;
+			viewed_at: Date | null;
+			signed_at: Date | null;
+			signature_data: unknown;
+			signer_email: string | null;
+			signer_name: string | null;
+		}[]
+	>`
+		SELECT id, name, created_at, sent_at, viewed_at, signed_at,
+		       signature_data, signer_email, signer_name
+		  FROM agreements
+		 WHERE (id = ${id} OR page_id = ${id})
+		 LIMIT 1`;
 	if (!agreement) return { ok: false };
 	const parties = parseParties(agreement.signature_data);
 	const evidence = parseEvidence(agreement.signature_data);
@@ -793,17 +793,6 @@ export const publicAgreementRouter = {
 		}
 	}),
 
-	// Certificate of Completion — the court-style audit certificate for an
-	// agreement. Delegates to buildCertificateData (the single data home shared
-	// with the SSR agreement gate); the email-must-be-a-party gate lives there,
-	// so signer evidence (IP/device) is never exposed to a non-party. Read-only;
-	// the signing block renders it inline.
-	certificate: pub
-		.input(v.object({ agreementId: v.string(), email: v.string() }))
-		.handler(async ({ input }) =>
-			buildCertificateData(input.agreementId, input.email),
-		),
-
 	// Public tamper-verification: re-hash the currently-stored document + roster
 	// and compare to the sealed hash captured at completion. Returns only
 	// public-safe data (names, roles, signed timestamps, hash match) — never
@@ -818,18 +807,19 @@ export const publicAgreementRouter = {
 			// is unauthenticated (no access cookie), so context.prisma's RLS would
 			// hide the row — use the raw registry prisma, the same bypass the gate's
 			// signer-email resolver uses.
-			const { getPrisma } = await import("@teamscala/db/prisma-registry");
-			const db = getPrisma();
-			const agreement = await db.agreements.findFirst({
-				where: { OR: [{ id: agreementId }, { page_id: agreementId }] },
-				select: {
-					id: true,
-					name: true,
-					signed_at: true,
-					signature_data: true,
-					page_id: true,
-				},
-			});
+			const [agreement] = await queryRows<
+				{
+					id: string;
+					name: string;
+					signed_at: Date | null;
+					signature_data: unknown;
+					page_id: string | null;
+				}[]
+			>`
+				SELECT id, name, signed_at, signature_data, page_id
+				  FROM agreements
+				 WHERE (id = ${agreementId} OR page_id = ${agreementId})
+				 LIMIT 1`;
 			if (!agreement) return { ok: false as const };
 			const parties = parseParties(agreement.signature_data);
 			const evidence = parseEvidence(agreement.signature_data);
@@ -837,10 +827,8 @@ export const publicAgreementRouter = {
 				!!agreement.signed_at || (parties?.every((p) => p.signedAt) ?? false);
 			let recomputedHash: string | null = null;
 			if (evidence?.documentHash && parties && agreement.page_id) {
-				const doc = await db.builda_pages.findFirst({
-					where: { id: agreement.page_id },
-					select: { puck_data: true },
-				});
+				const [doc] = await queryRows<{ puck_data: unknown }[]>`
+					SELECT puck_data FROM builda_pages WHERE id = ${agreement.page_id} LIMIT 1`;
 				recomputedHash = computeDocumentHash(doc?.puck_data ?? null, parties);
 			}
 			return {

package/src/mount-orpc-router.test.ts

@@ -0,0 +1,46 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Regression coverage for the generated-router boot seam. A service schema
+ * without its generated router is a codegen failure, not a daemon-only
+ * service, so production boot must fail before it can report healthy.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mountOrpcRouter } from "./mount-orpc-router.ts";
+
+const originalCwd = process.cwd();
+const tempDirs: string[] = [];
+
+afterEach(() => {
+	process.chdir(originalCwd);
+	for (const directory of tempDirs.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("mountOrpcRouter generated-artifact seam", () => {
+	test("fails when schema exists but generated router is absent", async () => {
+		const service = mkdtempSync(join(tmpdir(), "mount-orpc-router-test-"));
+		tempDirs.push(service);
+		mkdirSync(join(service, "prisma"), { recursive: true });
+		writeFileSync(
+			join(service, "prisma/schema.prisma"),
+			'datasource db { provider = "postgresql" }',
+		);
+		process.chdir(service);
+
+		await expect(
+			mountOrpcRouter({} as never, "scala-mcp"),
+		).rejects.toThrow(
+			"Prisma schema exists at " +
+				join(service, "prisma/schema.prisma") +
+				" but the generated ORPC router is missing",
+		);
+	});
+});

package/src/mount-orpc-router.ts

@@ -35,6 +35,7 @@ export async function mountOrpcRouter(
 		process.cwd(),
 		"prisma/generated/orpc/routers/index.ts",
 	);
+	const schemaPath = join(process.cwd(), "prisma/schema.prisma");
 
 	// No generated ORPC router is the EXPECTED state for daemon-only / boot-hook
 	// services (session-picker, dep-sync, etc.) that own no DB schema or
@@ -45,6 +46,13 @@ export async function mountOrpcRouter(
 	// A service that SHOULD have a router but doesn't is a codegen gap caught by
 	// API verification, not a boot warning.
 	if (!existsSync(routerPath)) {
+		if (existsSync(schemaPath)) {
+			throw new Error(
+				`[scala-install:${serviceSlug}] Prisma schema exists at ${schemaPath} ` +
+					`but the generated ORPC router is missing at ${routerPath}. ` +
+					`Refusing to boot without the generated router; regenerate codegen before starting.`,
+			);
+		}
 		return null;
 	}
 
@@ -56,7 +64,12 @@ export async function mountOrpcRouter(
 		const { RPCHandler } = await import("@orpc/server/fetch");
 		const handler = new RPCHandler(router as never, {});
 
-		const { getPrisma } = await import("@teamscala/db/prisma-registry");
+		// The bootloader injects the service Prisma client into ORPC's configured
+		// primitive. Reading it through that surface keeps this mount on the same
+		// dependency boundary as the generated procedures.
+		const { getPrisma: getConfiguredPrisma } = await import(
+			"@teamscala/orpc/configure"
+		);
 
 		// Bridge the composed router into tool-executor so in-process tool
 		// dispatch (chat agents' work_items/meetings/agreements/proposals
@@ -73,7 +86,7 @@ export async function mountOrpcRouter(
 		);
 		configureToolExecutor({
 			getAppRouter: () => getAppRouter(),
-			getPrisma: () => getPrisma(),
+			getPrisma: () => getConfiguredPrisma(),
 		});
 
 		const resolveUser = async (headers: Headers) => {
@@ -122,7 +135,7 @@ export async function mountOrpcRouter(
 				onError: (c) => c.json({ error: "Request body too large" }, 413),
 			}),
 			async (c) => {
-				const prisma = getPrisma();
+				const prisma = getConfiguredPrisma();
 				const result = await handler.handle(c.req.raw, {
 					prefix: "/api/rpc",
 					context: { prisma, headers: c.req.raw.headers, resolveUser },

package/src/mutable-app-ref.ts

@@ -14,8 +14,6 @@
  */
 
 import type { Hono } from "hono";
-import { stampTransportIdentity } from "./serve/stamp-transport-identity.ts";
-
 let currentApp: Hono | null = null;
 let appLabel = "initial";
 
@@ -55,21 +53,3 @@ export function swapApp(newApp: Hono, newLabel: string): string {
 	appLabel = newLabel;
 	return oldLabel;
 }
-
-/**
- * Fetch handler that routes through the mutable app reference.
- * This replaces the direct app.fetch call in the serve layer.
- *
- * Stamps transport-derived identity (x-caller-remote-address/-port + the
- * loopback local-caller comm) via the SAME stampTransportIdentity helper as
- * direct mode, so two-phase-boot (mutable-ref) UI services carry identical
- * identity on every request — closing the gap where the mutable-ref path
- * previously served requests with no transport headers stamped at all.
- */
-export function fetchWithMutableApp(
-	req: Request,
-	server: ReturnType<typeof Bun.serve>,
-): Promise<Response> {
-	const app = getApp();
-	return Promise.resolve(app.fetch(stampTransportIdentity(req, server), { server }));
-}

package/src/page-server-orpc/puck-pages-router.ts

@@ -165,108 +165,6 @@ export const puckPagesRouter = {
 			});
 		}),
 
-	loadById: procedure
-		.input(v.object({ pageId: v.string() }))
-		.output(v.nullable(PuckPageRowSchema))
-		.handler(async ({ input, context }) => {
-			const db = (context as { prisma?: unknown }).prisma;
-			if (!db) throw new Error("puckPages.loadById requires context.prisma");
-
-			console.log("[DEBUG-loadById] pageId:", input.pageId);
-
-			const row = (await (
-				db as {
-					builda_pages: { findFirst: (args: unknown) => Promise<unknown> };
-				}
-			).builda_pages.findFirst({
-				where: { id: input.pageId, is_active: true },
-				select: {
-					id: true,
-					path: true,
-					puck_data: true,
-					website_id: true,
-					meta_title: true,
-					meta_description: true,
-				},
-			})) as {
-				id: string;
-				path: string | null;
-				puck_data: unknown;
-				website_id: string;
-				meta_title: string | null;
-				meta_description: string | null;
-			} | null;
-
-			if (!row) {
-				console.log("[DEBUG-loadById] NO ROW for pageId:", input.pageId);
-				return null;
-			}
-
-			const pd = row.puck_data as { content?: Array<{ type?: string }> } | null;
-			const types = pd?.content?.map((c) => c.type) ?? [];
-			console.log(
-				"[DEBUG-loadById] row found, content types:",
-				JSON.stringify(types),
-			);
-
-			const site = (await (
-				db as {
-					builda_websites: { findFirst: (args: unknown) => Promise<unknown> };
-				}
-			).builda_websites.findFirst({
-				where: { id: row.website_id, status: { not: "archived" } },
-				select: {
-					id: true,
-					name: true,
-					slug: true,
-					organisation_id: true,
-					website_type: true,
-					layout_settings: true,
-					header_settings: true,
-					footer_settings: true,
-				},
-			})) as {
-				id: string;
-				name: string;
-				slug: string;
-				organisation_id: string | null;
-				website_type: string | null;
-				layout_settings: Record<string, unknown> | null;
-				header_settings: Record<string, unknown> | null;
-				footer_settings: Record<string, unknown> | null;
-			} | null;
-
-			return {
-				id: row.id,
-				path: row.path,
-				puckData: row.puck_data,
-				mode: null,
-				render_mode: null,
-				website_slug: site?.slug ?? "",
-				organisation_id: site?.organisation_id ?? null,
-				meta_title: row.meta_title,
-				meta_description: row.meta_description,
-				website: site
-					? {
-							slug: site.slug,
-							name: site.name,
-							organisation_id: site.organisation_id,
-							website_type: site.website_type,
-							layout_settings: site.layout_settings,
-							header_settings: site.header_settings,
-							footer_settings: site.footer_settings,
-						}
-					: {
-							slug: "",
-							name: "",
-							organisation_id: null,
-							website_type: null,
-							layout_settings: null,
-							header_settings: null,
-							footer_settings: null,
-						},
-			};
-		}),
 };
 
 export type PuckPagesRouter = typeof puckPagesRouter;

package/src/register-page-server-client.ts

@@ -55,9 +55,6 @@ export async function registerPageServerClient(
 		const { puckPagesRouter } = await import(
 			"@teamscala/service-boot/page-server-orpc/puck-pages-router"
 		);
-		const { portalDiagRouter } = await import(
-			"@teamscala/service-boot/page-server-orpc/portal-diagnostics-router"
-		);
 		const { userPreferencesRouter } = await import(
 			"@teamscala/service-boot/page-server-orpc/user-preferences-router"
 		);
@@ -67,7 +64,6 @@ export async function registerPageServerClient(
 		const composed = {
 			...((appRouter as Record<string, unknown> | null) ?? {}),
 			puckPages: puckPagesRouter,
-			portalDiag: portalDiagRouter,
 			userPreferences: userPreferencesRouter,
 			auditRevert: auditRevertRouter,
 		};

package/src/register-ws-routes.ts

@@ -34,8 +34,10 @@ import type {
 	WsRouteHandler,
 } from "@teamscala/os/runtime-contracts/mount-context";
 import type { Context, Hono } from "hono";
+import type { createBunWebSocket } from "hono/bun";
 import * as v from "valibot";
-import { upgradeWebSocket } from "./serve/serve.ts";
+
+export type UpgradeWebSocket = ReturnType<typeof createBunWebSocket>["upgradeWebSocket"];
 
 const ORPC_WS_PATH = "/api/rpc/ws";
 
@@ -44,6 +46,7 @@ export async function registerWsRoutes(
 	config: ServiceInstallConfig,
 	mountRegistry: MountRegistry,
 	serviceSlug: string,
+	upgradeWebSocket: UpgradeWebSocket,
 ): Promise<number> {
 	const log = getAppLogger();
 	const allDeclared = new Set(
@@ -87,7 +90,7 @@ export async function registerWsRoutes(
 					`Either remove the route declaration or add a server_package that calls ctx.registerWsRoute("${path}", handler).`,
 			);
 		}
-		app.get(path, adaptLegacyWsHandler(handler, path));
+		app.get(path, adaptLegacyWsHandler(handler, path, upgradeWebSocket));
 	}
 
 	// Unwired: handlers registered by a server_package for a path NOT declared
@@ -112,7 +115,11 @@ export async function registerWsRoutes(
 	return count;
 }
 
-function adaptLegacyWsHandler(legacy: WsRouteHandler, pattern: string) {
+function adaptLegacyWsHandler(
+	legacy: WsRouteHandler,
+	pattern: string,
+	upgradeWebSocket: UpgradeWebSocket,
+) {
 	return upgradeWebSocket((c: Context) => {
 		const params = c.req.param() as Record<string, string>;
 		const upgradeReq = c.req.raw;

package/src/two-phase-boot.ts

@@ -218,6 +218,7 @@ export async function buildMinimalApp(
 	config: ServiceInstallConfig,
 	serviceSlug: string,
 	databaseUrl: string,
+	upgradeWebSocket: import("./register-ws-routes.ts").UpgradeWebSocket,
 ): Promise<MinimalAppResult> {
 	const log = getAppLogger();
 	const blockPackages = ((config as { block_packages?: string[] })
@@ -359,7 +360,7 @@ export async function buildMinimalApp(
 	);
 
 	const wsRouteCount = await runStep("register-ws-routes", () =>
-		registerWsRoutes(app, config, mountRegistry, serviceSlug),
+		registerWsRoutes(app, config, mountRegistry, serviceSlug, upgradeWebSocket),
 	);
 
 	// Resolve the deferred TTL load (started at the top — should be long done,

package/src/ui-service.ts

@@ -15,8 +15,8 @@ import { Hono } from "hono";
 import type { ServiceInstallConfig } from "./load-service-install-row.ts";
 import { setReady } from "./readiness-gate.ts";
 import { resolveServicePort } from "./resolve-service-port.ts";
-import { serveStart } from "./serve/serve";
 import { buildMinimalApp, buildFullApp, swapToFullApp } from "./two-phase-boot.ts";
+import type { UpgradeWebSocket } from "./register-ws-routes.ts";
 
 export interface ResolvedBlock {
 	slug: string;
@@ -40,6 +40,7 @@ export interface UiServiceBootResult {
  */
 export interface PageServerDeps {
 	createPageHandler: import("./types.ts").CreatePageHandler;
+	upgradeWebSocket?: UpgradeWebSocket;
 }
 
 /**
@@ -65,7 +66,12 @@ export async function bootUiService(
 	const startTime = Date.now();
 
 	// Phase 1: Build minimal tool-only app
-	const minimalAppResult = await buildMinimalApp(config, serviceSlug, databaseUrl);
+	const minimalAppResult = await buildMinimalApp(
+		config,
+		serviceSlug,
+		databaseUrl,
+		deps.upgradeWebSocket!,
+	);
 
 	// Resolve the listen port through the SHARED resolver (`resolveServicePort`),
 	// the same one the backend branch uses. The registry wins wherever it has an
@@ -109,25 +115,12 @@ export async function bootUiService(
 	}
 	const port = requireValidPort(resolution.port, serviceSlug);
 
-	// Start serving with the minimal app (useMutableRef=true)
-	try {
-		serveStart(minimalAppResult.app, {
-			port,
-			serviceSlug,
-		}, true); // useMutableRef=true
-	} catch (err) {
-		throw new BootFatalError(
-			"ui-service.server-bind",
-			serviceSlug,
-			`Bun.serve failed to bind on port ${port}. Error: ${err instanceof Error ? err.message : err}`,
-			err,
-		);
-	}
-
+	// service-runtime owns the TCP listener. service-boot only composes the app
+	// and starts the two-phase build; the runtime binds the returned app.
 	const minimalReadyTime = Date.now();
 	const minimalDuration = minimalReadyTime - startTime;
 	log.info(
-		`[ui-service-boot:${serviceSlug}] Minimal app serving on port ${port} in ${minimalDuration}ms`,
+		`[ui-service-boot:${serviceSlug}] Minimal app composed on port ${port} in ${minimalDuration}ms`,
 	);
 
 	// FLIP READY SWITCH: minimal app is ready, MCP tools can connect

package/src/fn-routers/ai-health-router.ts

@@ -1,64 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * `fn.aiHealth` — the AI-availability probe the shared chat hook
- * (`useAIHealthCheck`) polls before showing the chat's health dot. It resolves
- * the same DB-driven default model the chat engine uses (`ai-default-model`
- * config → an active `llm_model` row) and reports `{status, mcp, gateway}`;
- * `status:"ok"` means the chat has a usable model configured.
- *
- * Unauthed (a public GPT surface polls it too) and a LIGHTWEIGHT registry read
- * via the request `prisma` — deliberately NO `@teamscala/chat-completion` import,
- * so wiring this universal procedure never pulls the AI stack into every
- * service. Registered into the `fn` namespace by registerFnRouters, so any
- * chat-capable service answers it instead of 404-ing.
- */
-
-import { os } from "@orpc/server";
-
-interface Context {
-	prisma: {
-		registry_entries: {
-			findFirst: (args: unknown) => Promise<{ config?: unknown; id?: string } | null>;
-		};
-	};
-}
-
-export interface AiHealthResponse {
-	status: "ok" | "error";
-	mcp: boolean;
-	gateway: boolean;
-	error?: string;
-}
-
-export const aiHealthHandler = os
-	.$context<Context>()
-	.handler(async ({ context }): Promise<AiHealthResponse> => {
-		try {
-			const cfg = await context.prisma.registry_entries.findFirst({
-				where: { type: "config", slug: "ai-default-model", is_active: true },
-				select: { config: true },
-			});
-			const modelKey = (cfg?.config as { model?: string } | null)?.model;
-			if (!modelKey) {
-				return { status: "error", mcp: false, gateway: false, error: "No default AI model configured" };
-			}
-			const model = await context.prisma.registry_entries.findFirst({
-				where: { type: "llm_model", slug: modelKey, is_active: true },
-				select: { id: true },
-			});
-			if (!model) {
-				return {
-					status: "error",
-					mcp: false,
-					gateway: false,
-					error: `Default AI model '${modelKey}' has no active llm_model row`,
-				};
-			}
-			return { status: "ok", mcp: true, gateway: true };
-		} catch (err) {
-			return { status: "error", mcp: false, gateway: false, error: (err as Error).message };
-		}
-	});