@teamscala/service-boot 0.23.284

package/src/install-logging.ts

@@ -0,0 +1,182 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ * @indivisible-unit
+ *
+ * One-call install of the entire logging pipeline. After installLogging()
+ * runs, every error in the service — process-level, HTTP middleware, Hono
+ * handlers, Puck blocks, even third-party packages calling console.* — is
+ * captured by @teamscala/logger and flows to Sentry/GlitchTip (prod) or
+ * loga (dev) with full context. Application code never imports the logger
+ * or wraps anything in try/catch for telemetry purposes.
+ *
+ * Marked @indivisible-unit: installLogging (early bootstrap, hardcoded
+ * defaults) and applyLoggerConfig (late-stage, DB-driven) are the two
+ * phases of the same one-call install — the service boot pipeline calls
+ * them in sequence with the same serviceSlug.
+ */
+
+import { ManagedCache } from "@teamscala/cache/cache";
+import { createCache } from "@teamscala/cache/create-cache";
+import { createDiskCache } from "@teamscala/cache/disk-cache";
+import { join } from "node:path";
+import { userHome } from "@teamscala/os/host-paths";
+import { slugify } from "@teamscala/formatters/slugify";
+import { createTimer } from "@teamscala/timing/create-timer";
+import { configure as dbConfigure } from "@teamscala/db/configure";
+import { getPrisma as dbGetPrisma } from "@teamscala/db/prisma-registry";
+import { getEntriesByType as dbGetEntriesByType } from "@teamscala/db/registry/getEntriesByType";
+import { loadRegistryConfig as dbLoadRegistryConfig } from "@teamscala/db/registry/load-config";
+import { configure as httpConfigure } from "@teamscala/http/configure";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { setMinLevel } from "@teamscala/logger/creator";
+import { configureFileSink } from "@teamscala/logger/file-sink";
+import { initSentry } from "@teamscala/logger/init-sentry";
+import { attachRequestLogger } from "@teamscala/logger/install-logging";
+import { getRequestContext } from "@teamscala/logger/request-context-async";
+import { configure as orpcConfigure } from "@teamscala/orpc/configure";
+
+// Re-exported from @teamscala/logger (the canonical home, per
+// vertical-dependency-only). service-boot consumers that previously
+// imported from service-boot/install-logging continue to work; the
+// implementation lives once in @teamscala/logger.
+export { attachRequestLogger };
+
+const CONSOLE_METHODS = [
+	"log",
+	"info",
+	"warn",
+	"error",
+	"debug",
+	"trace",
+] as const;
+type ConsoleMethod = (typeof CONSOLE_METHODS)[number];
+
+export interface InstallLoggingOptions {
+	serviceSlug: string;
+}
+
+/** Initial bootstrap install — runs BEFORE DB/Registry are available.
+ *  Uses hardcoded defaults (INFO level, /tmp/scala-logs). */
+export function installLogging(opts: InstallLoggingOptions): void {
+	const { serviceSlug } = opts;
+
+	initSentry({ service: serviceSlug, dsn: process.env.SENTRY_DSN });
+
+	installConsoleShim(serviceSlug);
+	installProcessHandlers(serviceSlug);
+
+	// Bootloader injection per `bootloader-injection-contract`. After
+	// initSentry + the console redirect, the logger surface is live; inject it
+	// into every configurable primitive that defaults to noop. The list is
+	// enumerated here; it becomes registry-driven once #57 lands.
+	const log = getAppLogger();
+	// Persisted last-known-good tier for registry config reads — created here
+	// (runtime tier) so host-path resolution stays out of the foundation-tier
+	// db package, which cannot import @teamscala/cache or resolve userHome itself.
+	// load-config serves this on a transient DB failure instead of crash-looping.
+	const registryConfigDiskCache = createDiskCache("db:registry-config", {
+		dir: join(userHome(), ".scala-db-cache", "registry-config"),
+		ttlMs: 24 * 60 * 60 * 1000,
+	});
+	dbConfigure({
+		logger: log,
+		// `as never` bridges the configured-primitives type gap: db holds
+		// structural approximations of these foundation factories (it cannot
+		// import @teamscala/cache/timing for the real CacheOptions/TimerOptions
+		// without re-creating the same-tier edge). The runtime values are the
+		// real factories; the cast only reconciles the approximate signatures.
+		ManagedCache: ManagedCache as never,
+		createCache: createCache as never,
+		createTimer: createTimer as never,
+		diskCache: registryConfigDiskCache as never,
+		slugify,
+	});
+	orpcConfigure({
+		logger: log,
+		getPrisma: () => dbGetPrisma() as never,
+		loadRegistryConfig: dbLoadRegistryConfig as never,
+		getEntriesByType: async (type) =>
+			dbGetEntriesByType(type as never) as never,
+		scalaDevKey: process.env.SCALA_DEV_KEY,
+	});
+	httpConfigure({
+		logger: log,
+		requestContextProvider: () => getRequestContext(),
+	});
+	// @teamscala/mcp-multi-session and @teamscala/tool-executor are MCP-only;
+	// their configure() calls moved to @teamscala/mcp-tool-runtime/mount.ts
+	// per `runtime-deps-universal-only`. MCP services declare mcp-tool-runtime
+	// in service_install.server_packages and pick up the configures there.
+}
+
+/** Late-stage configuration — runs AFTER Registry is loaded.
+ *  Injects DB-driven settings into the logger primitive. */
+export function applyLoggerConfig(config: {
+	minLevel?: "debug" | "info" | "warn" | "error";
+	logDir?: string;
+	maxFileSize?: number;
+	maxFiles?: number;
+}): void {
+	if (config.minLevel) {
+		setMinLevel(config.minLevel);
+	}
+	configureFileSink({
+		logDir: config.logDir,
+		maxFileSize: config.maxFileSize,
+		maxFiles: config.maxFiles,
+	});
+}
+
+function installConsoleShim(serviceSlug: string): void {
+	const log = getAppLogger();
+	const methodMap: Record<
+		ConsoleMethod,
+		(msg: string, ctx: Record<string, unknown>) => void
+	> = {
+		log: (m, c) => log.info(m, c),
+		info: (m, c) => log.info(m, c),
+		warn: (m, c) => log.warn(m, c),
+		error: (m, c) => log.error(m, c),
+		debug: (m, c) => log.debug?.(m, c) ?? log.info(m, c),
+		trace: (m, c) => log.debug?.(m, c) ?? log.info(m, c),
+	};
+	for (const method of CONSOLE_METHODS) {
+		const original = console[method].bind(console);
+		(console as unknown as Record<string, unknown>)[method] = (
+			...args: unknown[]
+		) => {
+			try {
+				const msg = args
+					.map((a) => (typeof a === "string" ? a : safeStringify(a)))
+					.join(" ");
+				methodMap[method](msg, { service: serviceSlug, source: "console" });
+			} catch {
+				original(...args);
+			}
+		};
+	}
+}
+
+function installProcessHandlers(serviceSlug: string): void {
+	const log = getAppLogger();
+	process.on("unhandledRejection", (reason) => {
+		log.error(`[${serviceSlug}] unhandledRejection`, {
+			err: reason,
+			stack: (reason as Error)?.stack,
+		});
+	});
+	process.on("uncaughtException", (err) => {
+		log.error(`[${serviceSlug}] uncaughtException`, { err, stack: err.stack });
+	});
+}
+
+function safeStringify(v: unknown): string {
+	if (v instanceof Error) return v.stack ?? v.message;
+	try {
+		return JSON.stringify(v);
+	} catch {
+		return String(v);
+	}
+}

package/src/load-service-install-row.ts

@@ -0,0 +1,98 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Loads the service_install registry row for a given service slug.
+ * Uses registry.require() per Constitution Rule 11.
+ * Schema is owned by @teamscala/db-validation (Rule 7).
+ */
+
+import { getCache } from "@teamscala/db/registry/loader/cache/get-cache";
+import {
+	RegistryMissingError,
+	RegistryValidationError,
+} from "@teamscala/db/registry/require";
+import { normalizeRegistryConfigObject } from "@teamscala/db/registry/validation";
+import type { ServiceInstallConfig } from "@teamscala/db-validation/registry-schemas/service-install";
+import {
+	enforceExplicitRenderMode,
+	ServiceInstallConfigSchema,
+	ServiceInstallValidationError,
+} from "@teamscala/db-validation/registry-schemas/service-install";
+import * as v from "valibot";
+
+export { ServiceInstallConfigSchema } from "@teamscala/db-validation/registry-schemas/service-install";
+export type { ServiceInstallConfig };
+
+export interface LoadServiceInstallRowResult {
+	success: true;
+	config: ServiceInstallConfig;
+}
+
+export interface LoadServiceInstallRowError {
+	success: false;
+	error: "row_not_found" | "validation_failed";
+	slug: string;
+	message: string;
+}
+
+export type LoadServiceInstallRowOutcome =
+	| LoadServiceInstallRowResult
+	| LoadServiceInstallRowError;
+
+export async function loadServiceInstallRow(
+	serviceSlug: string,
+): Promise<LoadServiceInstallRowOutcome> {
+	try {
+		const cacheEntry = getCache().get(`service_install:${serviceSlug}`);
+		if (!cacheEntry) {
+			throw new RegistryMissingError(serviceSlug);
+		}
+		const rawConfig = normalizeRegistryConfigObject(
+			cacheEntry.config,
+			`service_install:${serviceSlug}`,
+		) as Record<string, unknown>;
+		enforceExplicitRenderMode(serviceSlug, rawConfig);
+		const config = v.parse(ServiceInstallConfigSchema, rawConfig);
+		return { success: true, config };
+	} catch (err) {
+		if (err instanceof RegistryMissingError) {
+			const sql = `INSERT INTO registry_entries (type, slug, config, is_active) VALUES ('service_install', '${serviceSlug}', '{"kind":"ui","render_mode":"public","port":null,"page_routes":[],"providers":[],"api_routes":[],"block_packages":[],"teamgbg_packages":[],"env_vars":[]}'::jsonb, true);`;
+			return {
+				success: false,
+				error: "row_not_found",
+				slug: serviceSlug,
+				message: [
+					`service_install row not found for "${serviceSlug}".`,
+					``,
+					`Create it with:`,
+					sql,
+				].join("\n"),
+			};
+		}
+		if (err instanceof RegistryValidationError) {
+			return {
+				success: false,
+				error: "validation_failed",
+				slug: serviceSlug,
+				message: `service_install row for "${serviceSlug}" failed schema validation`,
+			};
+		}
+		if (err instanceof ServiceInstallValidationError) {
+			return {
+				success: false,
+				error: "validation_failed",
+				slug: serviceSlug,
+				message: err.message,
+			};
+		}
+
+		return {
+			success: false,
+			error: "row_not_found",
+			slug: serviceSlug,
+			message: `Unexpected error loading service_install for "${serviceSlug}": ${err}`,
+		};
+	}
+}

package/src/load-service-prisma-client.ts

@@ -0,0 +1,53 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Loads the service's own generated PrismaClient from
+ * <cwd>/prisma/generated/prisma/client.ts. Each service repo generates its own
+ * client from its own schema.prisma; resolving a static import would pick up
+ * whichever @prisma/generated bun resolves first in a multi-service workspace,
+ * which is wrong.
+ *
+ * No fallback: if the generated client is missing the deploy is broken — fail
+ * loud with the remediation step.
+ */
+
+export type ServicePrismaClientConstructor = new (args: {
+	adapter: unknown;
+}) => unknown;
+
+export async function loadServicePrismaClient(
+	serviceSlug: string,
+): Promise<ServicePrismaClientConstructor> {
+	// Per `near-empty-services`, the platform owns one Prisma client (in
+	// @teamscala/db) shared by every service. Service-local Prisma clients
+	// remain supported when a service ships its own `prisma/schema.prisma`.
+	const fs = await import("node:fs");
+	const servicePath = `${process.cwd()}/prisma/generated/prisma/client.ts`;
+	// `@teamscala/db/client` is the sanctioned subpath that re-exports the
+	// generated PrismaClient (per `@teamscala/db/package.json#exports`).
+	// The previous import of `@teamscala/db/generated/client/client.ts`
+	// reached into an internal path that isn't exported; under bun
+	// isolated-linker + node's exports-field enforcement, that path
+	// fails to resolve at runtime even though the file is on disk.
+	const platformPath = "@teamscala/db/client";
+	const path = fs.existsSync(servicePath) ? servicePath : platformPath;
+	let mod: { PrismaClient?: ServicePrismaClientConstructor };
+	try {
+		mod = (await import(path)) as {
+			PrismaClient?: ServicePrismaClientConstructor;
+		};
+	} catch (err) {
+		throw new Error(
+			`[scala-install:${serviceSlug}] Failed to load Prisma client at ${path}. ` +
+				`Cause: ${err instanceof Error ? err.message : err}`,
+		);
+	}
+	if (!mod.PrismaClient) {
+		throw new Error(
+			`[scala-install:${serviceSlug}] Prisma client at ${path} has no PrismaClient export.`,
+		);
+	}
+	return mod.PrismaClient;
+}

package/src/mount-orpc-router.ts

@@ -0,0 +1,148 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Mounts the composed ORPC app router (generated Prisma CRUD + custom fn routers)
+ * at /api/rpc/* over HTTP via @orpc/server/fetch's RPCHandler.
+ * Uses getAppRouter() from @teamscala/orpc/app-router which merges generated
+ * routers with custom routers registered via registerCustomRouter().
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { registerFnRouters } from "./fn-routers/index.ts";
+import type { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+
+export interface OrpcMountResult {
+	routeCount: number;
+}
+
+function isLocalhostRequest(headers: Headers): boolean {
+	const host = (headers.get("host") || "").split(":")[0];
+	return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+
+export async function mountOrpcRouter(
+	app: Hono,
+	serviceSlug: string,
+): Promise<OrpcMountResult | null> {
+	const log = getAppLogger();
+	registerFnRouters();
+	const routerPath = join(
+		process.cwd(),
+		"prisma/generated/orpc/routers/index.ts",
+	);
+
+	// No generated ORPC router is the EXPECTED state for daemon-only / boot-hook
+	// services (session-picker, package-poller, etc.) that own no DB schema or
+	// api_routes — they serve no /api/rpc surface. Skip silently: importing a
+	// nonexistent module would throw into the catch below and surface a
+	// misleading "ORPC router not mounted" WARN on every boot. The catch is
+	// reserved for GENUINE mount failures (router present but fails to load).
+	// 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)) {
+		return null;
+	}
+
+	try {
+		const { getAppRouter } = await import("@teamscala/orpc/app-router");
+		const router = await getAppRouter();
+		if (!router || Object.keys(router).length === 0) return null;
+
+		const { RPCHandler } = await import("@orpc/server/fetch");
+		const handler = new RPCHandler(router as never, {});
+
+		const { getPrisma } = await import("@teamscala/db/prisma-registry");
+
+		// Bridge the composed router into tool-executor so in-process tool
+		// dispatch (chat agents' work_items/meetings/agreements/proposals
+		// tools, etc.) resolves against this service's ORPC router + Prisma
+		// client. Without this every ORPC tool call throws
+		// "app router provider not configured". Parallel to dev-mcp-boot's
+		// configureToolExecutor. Calls getAppRouter() fresh each time (not a
+		// boot-time capture) so the tool-executor always resolves the CURRENT
+		// memoized router — the tool-generator listener may regenerate the
+		// ORPC router and call clearAppRouterCache() after boot, producing a
+		// new router object that a captured closure would miss.
+		const { configure: configureToolExecutor } = await import(
+			"@teamscala/tool-executor/configure"
+		);
+		configureToolExecutor({
+			getAppRouter: () => getAppRouter(),
+			getPrisma: () => getPrisma(),
+		});
+
+		const resolveUser = async (headers: Headers) => {
+			if (isLocalhostRequest(headers)) {
+				return {
+					id: "localhost",
+					role: "super_admin" as const,
+					isSuperAdmin: true,
+					organisationId: null,
+				};
+			}
+			try {
+				const { getSession } = await import("@teamscala/auth/get-session.ts");
+				const session = await getSession(headers);
+				if (!session?.user) return null;
+				const role = session.user.role;
+				return {
+					id: session.user.id,
+					name: session.user.name ?? undefined,
+					email: session.user.email,
+					// The active organisation lives on the SESSION
+					// (activeOrganizationId, set at sign-in by scala-otp's
+					// session.create hook), NOT on the user object — getSession's
+					// ResolvedSession.user carries no organisationId. Reading the
+					// user field left organisationId always null, so the generated
+					// router's org-scope gate 403'd every non-super-admin write
+					// ("Organization membership required") on the public-HTTP path.
+					organisationId: session.session.activeOrganizationId ?? null,
+					// better-auth's admin plugin issues role "admin"; the platform
+					// also uses "super-admin"/"super_admin". All three are platform
+					// super-admins for ORPC org-scope bypass.
+					isSuperAdmin:
+						role === "super_admin" ||
+						role === "super-admin" ||
+						role === "admin",
+				};
+			} catch {
+				return null;
+			}
+		};
+
+		app.post(
+			"/api/rpc/*",
+			bodyLimit({
+				maxSize: 10 * 1024 * 1024,
+				onError: (c) => c.json({ error: "Request body too large" }, 413),
+			}),
+			async (c) => {
+				const prisma = getPrisma();
+				const result = await handler.handle(c.req.raw, {
+					prefix: "/api/rpc",
+					context: { prisma, headers: c.req.raw.headers, resolveUser },
+				});
+				if (!result?.matched) return c.notFound();
+				return result.response;
+			},
+		);
+
+		const routeKeys = Object.keys(router as Record<string, unknown>).filter(
+			(k) => typeof (router as Record<string, unknown>)[k] !== "undefined",
+		);
+		log.info(
+			`[scala-install:${serviceSlug}] ORPC router mounted at /api/rpc/* (${routeKeys.length} procedure(s))`,
+		);
+		return { routeCount: routeKeys.length };
+	} catch (err) {
+		log.warn(
+			`[scala-install:${serviceSlug}] ORPC router not mounted: ${err instanceof Error ? err.message : err}`,
+		);
+		return null;
+	}
+}

package/src/mount-server-packages.ts

@@ -0,0 +1,155 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Walks `service_install.server_packages[]`, dynamic-imports each, and calls
+ * its `mount(ctx)` function. Server packages register handlers / boot hooks /
+ * scheduled jobs / WS routes via the MountContext exposed in ctx; the
+ * resulting MountRegistry is consumed by register-api-routes /
+ * register-ws-routes / run-boot-hook-list / start-scheduled-jobs.
+ */
+
+import type { ServiceInstallConfig } from "@teamscala/db/registry/loader/load-service-install-row";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
+import { BootFatalError } from "@teamscala/os/errors/boot-error";
+import {
+	createMountContext,
+	createMountRegistry,
+	type MountContext,
+	type MountRegistry,
+} from "@teamscala/os/runtime-contracts/mount-context";
+import type { Hono } from "hono";
+
+type ServerPackageMount = (ctx: MountContext) => Promise<void> | void;
+
+/** Candidate import paths tried for each server_package, in priority order.
+ *  Shared by preloadServerPackages (cache-warming) and mountServerPackages
+ *  (resolution) so the candidate set has ONE source of truth. */
+function mountCandidates(pkg: string): string[] {
+	return [`${pkg}/mount.ts`, `${pkg}/boot/mount.ts`, pkg];
+}
+
+/**
+ * Speculatively import every server_package's mount module so Bun compiles
+ * the module graphs into its cache NOW, overlapping the (CPU-bound)
+ * compilation with whatever I/O the caller runs next. When mountServerPackages
+ * later imports the same paths they hit the cache (instant).
+ *
+ * Same pattern as create-boot-pipeline's speculative preloads — the
+ * cross-internet DB I/O in the gate chain (~3.4s) is dead time the compiler
+ * can use. Best-effort + non-fatal: a failed import here (wrong candidate
+ * path, transient resolution race) is silently swallowed because
+ * mountServerPackages will re-attempt with full error surfacing; the preload
+ * only warms the cache, never gates boot.
+ */
+export async function preloadServerPackages(packages: string[]): Promise<void> {
+	await Promise.allSettled(
+		packages.flatMap((pkg) =>
+			mountCandidates(pkg).map((candidate) =>
+				import(candidate).catch(() => {}),
+			),
+		),
+	);
+}
+
+export async function mountServerPackages(
+	app: Hono,
+	config: ServiceInstallConfig,
+	serviceSlug: string,
+): Promise<MountRegistry> {
+	const log = getAppLogger();
+	const mountRegistry = createMountRegistry();
+	const mountCtx = createMountContext(serviceSlug, config, app, mountRegistry);
+	const serverPackages = (config.server_packages ?? []) as string[];
+
+	if (serverPackages.length === 0) {
+		log.info(`[scala-install:${serviceSlug}] No server_packages declared`);
+		return mountRegistry;
+	}
+
+	const isModuleNotFound = (err: unknown, requestedPath: string): boolean => {
+		// Bun's ResolveMessage is not an Error subclass — read message defensively.
+		// Match ONLY when the missing module is the candidate path itself; transitive
+		// not-found errors (e.g. a file inside the candidate fails to resolve a
+		// different module) must surface, not be swallowed as "not found here".
+		const msg =
+			(err as { message?: string })?.message ??
+			(typeof err === "string" ? err : String(err));
+		return (
+			msg.includes(`Cannot find module '${requestedPath}'`) ||
+			msg.includes(`Cannot find package '${requestedPath}'`)
+		);
+	};
+
+	for (const pkg of serverPackages) {
+		try {
+			let mod: {
+				mount?: ServerPackageMount;
+				default?: { mount?: ServerPackageMount };
+			} | undefined;
+			const candidates = mountCandidates(pkg);
+			let lastNotFound: unknown;
+			let resolved: (typeof candidates)[number] | undefined;
+			let loaded = false;
+			for (const candidate of candidates) {
+				try {
+					mod = (await import(candidate)) as typeof mod;
+					resolved = candidate;
+					loaded = true;
+					break;
+				} catch (err) {
+					if (isModuleNotFound(err, candidate)) {
+						lastNotFound = err;
+						continue;
+					}
+					// Real error (syntax, runtime, transitive resolution failure inside the
+					// loaded module) — surface it directly. Swallowing here is what hides
+					// the true cause behind a misleading "cannot find <pkg>" further down.
+					throw new BootFatalError(
+						"mount-server-packages",
+						serviceSlug,
+						`server_package "${pkg}" load failed at "${candidate}": ${err instanceof Error ? err.message : err}`,
+						err,
+					);
+				}
+			}
+			if (!loaded) {
+				throw new BootFatalError(
+					"mount-server-packages",
+					serviceSlug,
+					`server_package "${pkg}" not found at any of: ${candidates.join(", ")}`,
+					lastNotFound,
+				);
+			}
+			const mountFn: ServerPackageMount | undefined =
+				typeof mod?.mount === "function"
+					? mod?.mount
+					: typeof mod?.default?.mount === "function"
+						? mod?.default.mount
+						: undefined;
+			if (mountFn) {
+				await mountFn(mountCtx);
+				log.info(
+					`[scala-install:${serviceSlug}] Mounted server_package: ${pkg} (via ${resolved})`,
+				);
+			}
+		} catch (err) {
+			if (err instanceof BootFatalError) throw err;
+			throw new BootFatalError(
+				"mount-server-packages",
+				serviceSlug,
+				`server_package "${pkg}" mount failed: ${err instanceof Error ? err.message : err}`,
+				err,
+			);
+		}
+	}
+
+	log.info(
+		`[scala-install:${serviceSlug}] Registered ${mountRegistry.handlers.size} handler(s), ` +
+			`${mountRegistry.wsRoutes.size} ws route(s), ${mountRegistry.scheduledJobs.size} scheduled job(s), ` +
+			`${mountRegistry.bootHooks.size} boot hook(s)`,
+	);
+
+	return mountRegistry;
+}

package/src/mount.ts

@@ -0,0 +1,18 @@
+/**
+ * @system server-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Server-package mount for opt-in service-boot watchdogs.
+ */
+
+import type { MountContext } from "@teamscala/os/runtime-contracts/mount-context";
+import { startScalaToolsCurrencyWatchdog } from "./scala-tools-currency-watchdog";
+
+export function mount(ctx: MountContext): void {
+	if (ctx.serviceSlug !== "scala-sentinel") return;
+	ctx.registerBootHook("scala-tools-currency-watchdog", async () => {
+		startScalaToolsCurrencyWatchdog();
+	});
+}
+