@teamscala/service-boot 0.23.366 → 0.23.368

package/package.json

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

package/src/handlers/platform-fault-escalation-logic.ts

@@ -40,6 +40,7 @@ export interface EscalationEpisode {
 	workItemId: string | null;
 	resolvedAt: Date | null;
 	lastUpdatedAt: Date | null;
+	deliveredCommentId?: string | null;
 }
 
 export interface FaultEscalationPolicy {

package/src/handlers/platform-fault-escalation.ts

@@ -51,7 +51,6 @@ import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
 import { recordEvent } from "@teamscala/event-log/record-event";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
-import { getServerClient } from "../page-server-orpc/server-client.ts";
 import {
 	composeEscalationDescription,
 	composeEscalationMessage,
@@ -83,8 +82,11 @@ const FaultEscalationConfigSchema = v.object({
 	),
 	resolve_after_minutes: v.number(),
 	update_after_minutes: v.number(),
-	/** The developer-session project escalations are parented to. */
-	parent_project_id: v.string(),
+	/** The orchestrator's work item — escalations are COMMENTS on it, never
+	 * task rows (the fleet-task-placement CHECK constraint refuses a system
+	 * task without session identity, and an escalation is a finding, not an
+	 * assigned unit of work). */
+	orchestrator_work_item_id: v.string(),
 	/** Per-kind copy for the message (impact + recommendation). Falls back to default_copy. */
 	copy: v.record(v.string(), v.object({ impact: v.string(), recommendation: v.string() })),
 	default_copy: v.object({ impact: v.string(), recommendation: v.string() }),
@@ -118,17 +120,55 @@ async function getSystemIdentity(): Promise<{ userId: string | undefined; organi
 }
 
 /**
- * The system-authed in-process ORPC client (set at boot after the router is
- * built — no-arg form carries the system super-admin context, correct for a
- * platform system action). Per `no-direct-prisma-outside-orpc`, every WRITE in
- * this handler routes through it; the single raw read (the event_log
- * recurrence aggregate, a GROUP BY no generated CRUD expresses) uses the
- * assigned-client form with $queryRawUnsafe — the lane-attention-sweep
+ * The system-authed in-process ORPC client, built LAZILY on first use from the
+ * SAME composed appRouter the /api/rpc mount uses (getAppRouter — never a raw
+ * re-import of the generated routers, per register-page-server-client's
+ * documented module-identity trap). Built here rather than read from
+ * page-server-orpc/server-client because a pg-boss handler can fire on a
+ * BACKEND service, where the page-server client is never registered — the
+ * empty-router fallback returns a client with no model namespaces (the
+ * TypeError this replaced). Per `no-direct-prisma-outside-orpc`, every WRITE
+ * in this handler routes through this client; the single raw read (the
+ * event_log recurrence aggregate, a GROUP BY no generated CRUD expresses) uses
+ * the assigned-client form with $queryRawUnsafe — the lane-attention-sweep
  * precedent in this same directory. Timestamps are ISO strings, never Date
  * instances (the generated valibot schemas require it).
  */
-function orpc(): OrpcSurface {
-	return getServerClient() as unknown as OrpcSurface;
+let cachedOrpc: OrpcSurface | null = null;
+async function orpc(): Promise<OrpcSurface> {
+	if (cachedOrpc) return cachedOrpc;
+	const { createRouterClient } = await import("@orpc/server");
+	const { getAppRouter } = await import("@teamscala/orpc/app-router");
+	const appRouter = (await getAppRouter()) as Record<string, unknown> | null;
+	if (!appRouter) {
+		throw new Error(
+			"platform-fault-escalation: no ORPC appRouter — the service has no generated routers to write through",
+		);
+	}
+	const { getPrisma } = await import("@teamscala/db/prisma-registry");
+	const { loadRegistryConfig } = await import("@teamscala/db/registry/load-config");
+	const { PlatformIdentitySchema } = await import(
+		"@teamscala/db-validation/registry-schemas/platform-identity"
+	);
+	const platformIdentity = await loadRegistryConfig(
+		"config",
+		"platform-identity",
+		PlatformIdentitySchema,
+	);
+	cachedOrpc = createRouterClient(
+		{ ...appRouter } as never,
+		{
+			context: {
+				prisma: getPrisma(),
+				user: {
+					id: "system",
+					isSuperAdmin: true,
+					organisationId: platformIdentity.platformOrganisationId,
+				},
+			},
+		} as never,
+	) as unknown as OrpcSurface;
+	return cachedOrpc;
 }
 
 /** The router subset this handler uses — mirrors the generated procedure args. */
@@ -187,7 +227,7 @@ async function fetchAggregates(patterns: string[], windowMinutes: number): Promi
 }
 
 async function resolveOperatorRelay(): Promise<OperatorRelayBot> {
-	const bot = (await orpc().messaging_bots.findFirst({
+	const bot = (await (await orpc()).messaging_bots.findFirst({
 		where: {
 			is_active: true,
 			platform: "whatsapp",
@@ -225,7 +265,7 @@ async function deliverEscalation(
 
 	// 1. Claim the episode BEFORE sending, so a send failure leaves a durable
 	// claim the next sweep retries instead of a lost escalation.
-	await orpc().platform_fault_escalations.upsert({
+	await (await orpc()).platform_fault_escalations.upsert({
 		where: { kind },
 		create: {
 			kind,
@@ -279,34 +319,30 @@ async function deliverEscalation(
 		);
 	}
 
-	// 4. Durable record: the work_items task the PA reads back / the operator answers on.
-	const workItem = await orpc().work_items.create({
+	// 4. Durable record: a COMMENT on the orchestrator's work item — an
+	// escalation is a finding the orchestrator/operator triages, not an
+	// assigned task (the fleet-task-placement constraint refuses task rows
+	// without session identity by design).
+	const comment = await (await orpc()).comments.create({
 		data: {
-			kind: "task",
-			parent_id: config.parent_project_id,
-			organisation_id: bot.organisation_id,
-			title: `Fault: ${kind}`.slice(0, 50),
-			description: composeEscalationDescription({ aggregate, impact: copy.impact, recommendation: copy.recommendation }),
-			status: "pending",
-			kind_data: {
-				platform_fault: true,
-				event_kind: kind,
-				event_count: aggregate.count,
-				first_seen_at: aggregate.firstSeen.toISOString(),
-				last_seen_at: aggregate.lastSeen.toISOString(),
-				delivered_message_id: messageId,
-				escalated_at: now.toISOString(),
-			},
+			work_item_id: config.orchestrator_work_item_id,
+			content: composeEscalationMessage({
+				kind,
+				aggregate,
+				impact: copy.impact,
+				recommendation: copy.recommendation,
+			}),
+			source_cli_session_id: null,
 		},
-		select: { id: true },
 	});
 
 	// 5. Readback-correct the episode: delivered + linked in one update.
-	await orpc().platform_fault_escalations.update({
+	await (await orpc()).platform_fault_escalations.update({
 		where: { kind },
 		data: {
 			escalated_at: now.toISOString(),
-			work_item_id: workItem.id,
+			work_item_id: config.orchestrator_work_item_id,
+			delivered_comment_id: comment.id,
 			delivered_message_id: messageId,
 			last_updated_at: now.toISOString(),
 			updated_at: now.toISOString(),
@@ -318,16 +354,17 @@ async function deliverEscalation(
 		payload: {
 			event_kind: kind,
 			count: aggregate.count,
-			work_item_id: workItem.id,
+			work_item_id: config.orchestrator_work_item_id,
+			delivered_comment_id: comment.id,
 			delivered_message_id: messageId,
 		},
 	});
-	return { messageId, workItemId: workItem.id };
+	return { messageId, workItemId: config.orchestrator_work_item_id };
 }
 
 async function updateEpisode(aggregate: FaultAggregate, episode: EscalationEpisode): Promise<void> {
 	const now = new Date();
-	await orpc().platform_fault_escalations.update({
+	await (await orpc()).platform_fault_escalations.update({
 		where: { kind: episode.kind },
 		data: {
 			last_seen_at: aggregate.lastSeen.toISOString(),
@@ -337,7 +374,7 @@ async function updateEpisode(aggregate: FaultAggregate, episode: EscalationEpiso
 		},
 	});
 	if (episode.workItemId) {
-		await orpc().comments.create({
+		await (await orpc()).comments.create({
 			data: {
 				work_item_id: episode.workItemId,
 				content: `Still recurring: ${aggregate.count} events, last at ${aggregate.lastSeen.toISOString()}. No new escalation (already escalated and unresolved).`,
@@ -354,12 +391,12 @@ async function updateEpisode(aggregate: FaultAggregate, episode: EscalationEpiso
 
 async function resolveEpisode(episode: EscalationEpisode, quietMinutes: number): Promise<void> {
 	const now = new Date();
-	await orpc().platform_fault_escalations.update({
+	await (await orpc()).platform_fault_escalations.update({
 		where: { kind: episode.kind },
 		data: { resolved_at: now.toISOString(), updated_at: now.toISOString() },
 	});
 	if (episode.workItemId) {
-		await orpc().comments.create({
+		await (await orpc()).comments.create({
 			data: {
 				work_item_id: episode.workItemId,
 				content: `Fault stopped — no '${episode.kind}' events for ${Math.round(quietMinutes)} min. Episode closed; the fault will re-escalate if it recurs.`,
@@ -383,7 +420,7 @@ async function platformFaultEscalationSweep(ctx: { config: ScheduledJobConfig })
 	// Only OPEN episodes matter: a resolved episode and no episode at all have
 	// the same meaning to decideSweep (a recurring sustained fault opens a NEW
 	// episode and escalates again).
-	const openEpisodes = (await orpc().platform_fault_escalations.findMany({
+	const openEpisodes = (await (await orpc()).platform_fault_escalations.findMany({
 		where: { resolved_at: null },
 	})) as Array<{
 		kind: string;