@teamscala/service-boot 0.23.421 → 0.23.425

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

@@ -16,11 +16,14 @@ import type { ExecutionContext } from "@teamscala/os/contracts/mcp";
 import { recordEvent } from "@teamscala/event-log/record-event";
 import {
 	composeEscalationMessage,
+	composeZeroVolumeMessage,
 	extractWhatsAppMessageId,
 	type EscalationEpisode,
 	type FaultAggregate,
+	type ZeroVolumeSource,
 } from "../platform-fault-escalation-logic.ts";
 import type { FaultEscalationConfig } from "./config.ts";
+import { loadFaultEscalationConfig } from "./config.ts";
 import { fetchLatestEvidence } from "./event-log-queries.ts";
 import { getSystemIdentity, orpc } from "./orpc-client.ts";
 
@@ -150,7 +153,10 @@ export async function deliverEscalation(
 	return { messageId, workItemId: config.orchestrator_work_item_id };
 }
 
-export async function resolveEpisode(episode: EscalationEpisode, quietMinutes: number): Promise<void> {
+export async function resolveEpisode(
+	episode: EscalationEpisode,
+	quietMinutes: number,
+): Promise<void> {
 	const now = new Date();
 	await (await orpc()).platform_fault_escalations.update({
 		where: { kind: episode.kind },
@@ -171,3 +177,71 @@ export async function resolveEpisode(episode: EscalationEpisode, quietMinutes: n
 		payload: { event_kind: episode.kind, quiet_minutes: Math.round(quietMinutes), work_item_id: episode.workItemId },
 	});
 }
+
+/** Send one message to the operator through the verified WhatsApp relay and
+ * record it as a comment on the orchestrator's work item. Returns the
+ * verified ids; throws when the send carries no message id so the caller's
+ * durable claim stays undelivered and retries next sweep (same contract as
+ * deliverEscalation — a component may not report a delivery it cannot show). */
+async function sendOperatorNotice(message: string): Promise<{ messageId: string; workItemId: string }> {
+	const bot = await resolveOperatorRelay();
+	const operatorPhone = (bot.flow_config as { operator_phone?: string }).operator_phone!;
+	const { userId, organisationId } = await getSystemIdentity();
+	const systemCtx: ExecutionContext = { userId, organisationId } as ExecutionContext;
+	const { forwardToolToCentralMcp } = await import("@teamscala/chat-completion/central-tool-forwarder");
+	const sendResult = await forwardToolToCentralMcp("messaging_whatsapp_send", { phone: operatorPhone, message }, systemCtx);
+	const messageId = extractWhatsAppMessageId(sendResult);
+	if (!messageId) {
+		throw new Error(
+			`platform-fault-escalation: zero-volume notice send returned no message id — not recording delivery. ` +
+				`Response: ${JSON.stringify(sendResult).slice(0, 400)}`,
+		);
+	}
+	const config = await loadFaultEscalationConfig();
+	await (await orpc()).comments.create({
+		data: { work_item_id: config.orchestrator_work_item_id, content: message, source_cli_session_id: null },
+	});
+	return { messageId, workItemId: config.orchestrator_work_item_id };
+}
+
+/** Raise the zero-volume hold ONCE for an open episode whose producer went
+ * silent alongside its failures. Delivery is VERIFIED before the marker
+ * event lands, so a failed send leaves the hold unflagged and the next
+ * sweep retries — never a flagged-but-unheard hold. */
+export async function deliverZeroVolumeHold(
+	episode: EscalationEpisode,
+	quietMinutes: number,
+	volumeCount: number,
+	source: ZeroVolumeSource,
+): Promise<void> {
+	const message = composeZeroVolumeMessage({
+		kind: episode.kind,
+		volumeKindPattern: source.volume_kind_pattern,
+		minVolume: source.min_volume ?? 1,
+		quietMinutes,
+		volumeCount,
+		firstSeenAt: episode.firstSeenAt,
+	});
+	const { messageId, workItemId } = await sendOperatorNotice(message);
+	recordEvent({
+		kind: "platform.fault.zero_volume_flagged",
+		payload: {
+			event_kind: episode.kind,
+			volume_kind_pattern: source.volume_kind_pattern,
+			volume_count: volumeCount,
+			quiet_minutes: Math.round(quietMinutes),
+			work_item_id: workItemId,
+			delivered_message_id: messageId,
+		},
+	});
+}
+
+/** Clear a standing zero-volume hold: volume is back above floor (or faults
+ * recurred), so quiet regains its meaning and the normal resolve path takes
+ * over. One clearing emission per flag — transitions, not conditions. */
+export async function clearZeroVolumeHold(episode: EscalationEpisode, volumeCount: number): Promise<void> {
+	recordEvent({
+		kind: "platform.fault.zero_volume_cleared",
+		payload: { event_kind: episode.kind, volume_count: volumeCount, work_item_id: episode.workItemId },
+	});
+}

package/src/handlers/platform-fault-escalation/event-log-queries.ts

@@ -120,3 +120,43 @@ export async function fetchLatestEvidence(
 function isoSeconds(value: Date | string): string {
 	return new Date(value).toISOString().replace(/\.\d{3}Z$/, "Z");
 }
+
+/** The bounded VOLUME count for one fault kind's volume source: how many
+ * rows of `kind ~ pattern` landed inside the window (both edges database-
+ * clock-bounded, identical discipline to fetchAggregates). A floor-checked
+ * zero here is what separates "failures stopped because things recovered"
+ * from "failures stopped because nothing is calling anymore" — 2026-08-27:
+ * the dead llm-router produced BOTH zeros and read as healthy. */
+export async function fetchVolumeCount(pattern: string, windowMinutes: number): Promise<number> {
+	const prisma = getPrisma();
+	const regexClass = /^[A-Za-z0-9_\\^$.*+?()[\]{}|-]+$/;
+	if (!regexClass.test(pattern)) {
+		throw new Error(`config/${CONFIG_SLUG}: volume_kind_pattern is not regex-only: ${pattern}`);
+	}
+	const rows = await prisma.$queryRawUnsafe<Array<{ n: bigint }>>(
+		`SELECT count(*)::bigint AS n
+			 FROM event_log
+			 WHERE occurred_at > now() - ($1::int * interval '1 minute')
+			   AND occurred_at <= now()
+			   AND kind ~ $2::text`,
+		windowMinutes,
+		pattern,
+	);
+	return Number(rows[0]?.n ?? 0);
+}
+
+/** Whether a zero-volume hold marker STANDS for a fault kind: derived from
+ * the durable stream (latest flagged/cleared wins), never from process
+ * memory — a restart must not re-raise or silently drop a standing hold.
+ * Returns false when no marker exists (unflagged). */
+export async function zeroVolumeFlagActive(kind: string): Promise<boolean> {
+	const prisma = getPrisma();
+	const rows = await prisma.$queryRawUnsafe<Array<{ kind: string }>>(
+		`SELECT kind FROM event_log
+			 WHERE kind IN ('platform.fault.zero_volume_flagged', 'platform.fault.zero_volume_cleared')
+			   AND payload_json->>'event_kind' = $1::text
+			 ORDER BY occurred_at DESC LIMIT 1`,
+		kind,
+	);
+	return rows[0]?.kind === "platform.fault.zero_volume_flagged";
+}

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

@@ -52,7 +52,36 @@ export interface SweepDecision {
 	/** Sustained faults needing a FIRST delivery (new episode, or a claim whose send failed). */
 	escalate: Array<{ aggregate: FaultAggregate; episode: EscalationEpisode | null }>;
 	/** Open episodes whose kind went quiet past the resolve window — close them. */
-	resolve: Array<{ episode: EscalationEpisode; quietMinutes: number }>;
+	resolve: Array<{ episode: EscalationEpisode; quietMinutes: number; clearZeroVolumeFlag: boolean }>;
+	/** Open episodes quiet past the resolve window whose producer ALSO went
+	 * silent: zero failure rows AND zero call volume that would produce them.
+	 * Quiet is NOT evidence of health here (measured 2026-08-27: llm-router
+	 * died and produced zero llm.provider.call.failed events, which the
+	 * sweep closed as "no failures for 30 min" while crush lanes had no
+	 * model backend at all). The episode HOLDS OPEN and the hold raises
+	 * once; it never resolves from silence alone. */
+	zeroVolumeHold: Array<{ episode: EscalationEpisode; quietMinutes: number; volumeCount: number }>;
+}
+
+/** Per-kind config naming the kind whose VOLUME proves the producing
+ * pipeline is alive — e.g. failures pair with completed calls. A fault kind
+ * without a source resolves on quiet exactly as before; with one, resolve
+ * additionally requires the volume floor to be met inside the window. */
+export interface ZeroVolumeSource {
+	volume_kind_pattern: string;
+	min_volume?: number;
+}
+
+/** Everything decideSweep needs to judge quiet-vs-healthy, computed by the
+ * caller from the valibot-validated config row + bounded queries. */
+export interface ZeroVolumeInputs {
+	/** Configured sources keyed by watched kind. */
+	sources: Record<string, ZeroVolumeSource>;
+	/** Resolved volume count per watched kind over the window. */
+	countByKind: Record<string, number>;
+	/** Whether a flagged/cleared marker already stands for the kind (derived
+	 * from event_log by the caller — never process memory). */
+	flagActiveByKind: Record<string, boolean>;
 }
 
 function minutesBetween(a: Date, b: Date): number {
@@ -95,10 +124,11 @@ export function decideSweep(
 	policy: FaultEscalationPolicy,
 	now: Date,
 	kindThresholds: Record<string, KindThresholdOverride> = {},
+	zeroVolume?: ZeroVolumeInputs,
 ): SweepDecision {
 	const byKind = new Map(episodes.map((e) => [e.kind, e]));
 	const aggregateByKind = new Map(aggregates.map((a) => [a.kind, a]));
-	const decision: SweepDecision = { escalate: [], resolve: [] };
+	const decision: SweepDecision = { escalate: [], resolve: [], zeroVolumeHold: [] };
 
 	for (const aggregate of aggregates) {
 		const episode = byKind.get(aggregate.kind);
@@ -132,9 +162,29 @@ export function decideSweep(
 		const quietReference =
 			aggregate && aggregate.lastSeen.getTime() <= now.getTime() ? aggregate.lastSeen : episode.lastSeenAt;
 		const quietMinutes = minutesBetween(quietReference, now);
-		if (quietMinutes >= policy.resolveAfterMinutes) {
-			decision.resolve.push({ episode, quietMinutes });
+		if (quietMinutes < policy.resolveAfterMinutes) continue;
+
+		// ZERO-VOLUME GATE on resolution. When this fault kind declares a
+		// volume source and that volume is below its floor inside the window,
+		// "no failure rows" no longer separates healthy from dead-producer:
+		// hold the episode open instead of closing it. The hold raises once
+		// (when unflagged) through zeroVolumeHold; a flagged hold emits
+		// nothing while it persists — same transitions-only rule as an open
+		// escalation.
+		const source = zeroVolume?.sources[episode.kind];
+		const volumeCount = zeroVolume?.countByKind[episode.kind];
+		if (source) {
+			const floor = source.min_volume ?? 1;
+			if ((volumeCount ?? 0) < floor) {
+				decision.zeroVolumeHold.push({ episode, quietMinutes, volumeCount: volumeCount ?? 0 });
+				continue;
+			}
 		}
+		decision.resolve.push({
+			episode,
+			quietMinutes,
+			clearZeroVolumeFlag: Boolean(source && zeroVolume?.flagActiveByKind[episode.kind]),
+		});
 	}
 
 	return decision;
@@ -216,3 +266,32 @@ export function composeEscalationMessage(input: {
 	lines.push(`Impact: ${input.impact}`, `Recommendation: ${input.recommendation}`);
 	return lines.join("\n");
 }
+
+/**
+ * The zero-volume hold notice — the same three-field contract, for the shape
+ * where the watched failures went quiet AND the call volume that would have
+ * produced them went quiet too. That combination is NOT a resolution: it is
+ * either "fault ended" or "the producer itself died" (2026-08-27: the dead
+ * llm-router emitted zero llm.provider.call.failed rows and the sweep closed
+ * the episode as healthy while crush lanes had no model backend). Holds one
+ * episode open; raises once per episode-state, never on cadence.
+ */
+export function composeZeroVolumeMessage(input: {
+	kind: string;
+	volumeKindPattern: string;
+	minVolume: number;
+	quietMinutes: number;
+	volumeCount: number;
+	firstSeenAt: Date;
+}): string {
+	const observed =
+		`Observed: '${input.kind}' open since ${input.firstSeenAt.toISOString()}, ` +
+		`quiet ${Math.round(input.quietMinutes)} min — but volume kind ~${input.volumeKindPattern} is ALSO silent ` +
+		`(${input.volumeCount} < floor ${input.minVolume} in window). Quiet is indistinguishable from dead.`;
+	return [
+		`🟡 Platform fault unresolved: ${input.kind}`,
+		observed,
+		"Impact: failures stopping means EITHER recovery OR its producer died entirely — this exact ambiguity hid llm-router's halt behind an all-clear.",
+		`Recommendation: probe/restart the producer of ${input.volumeKindPattern} directly; resolve the episode by hand only once completion is verified.`,
+	].join("\n");
+}

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

@@ -11,6 +11,7 @@
 import { describe, expect, test } from "bun:test";
 import {
 	composeEscalationMessage,
+	composeZeroVolumeMessage,
 	decideSweep,
 	extractWhatsAppMessageId,
 	formatEscalationSample,
@@ -114,7 +115,7 @@ describe("decideSweep — dedup (one escalation per fault, no re-fire)", () => {
 		const decision = decideSweep([sustained], [longOpen], POLICY, NOW);
 		expect(decision.escalate).toHaveLength(0);
 		expect(decision.resolve).toHaveLength(0);
-		expect(Object.keys(decision).sort()).toEqual(["escalate", "resolve"]);
+		expect(Object.keys(decision).sort()).toEqual(["escalate", "resolve", "zeroVolumeHold"]);
 	});
 
 	test("a claimed-but-undelivered episode is RETRIED, not counted as escalated", () => {
@@ -332,3 +333,69 @@ describe("decideSweep — qualification asks 'is this happening', not 'did this
 		expect(decision.escalate).toHaveLength(1);
 	});
 });
+
+describe("decideSweep — zero-volume gate (quiet vs dead producer)", () => {
+	const SOURCES = {
+		"llm.provider.call.failed": { volume_kind_pattern: "^llm\.router\.routing_decision$", min_volume: 1 },
+	};
+	const VOLUME_BACKED = { sources: SOURCES, countByKind: {}, flagActiveByKind: {} };
+
+	test("an open episode with NO volume does not resolve — it holds", () => {
+		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
+		const inputs = { ...VOLUME_BACKED, countByKind: { "llm.provider.call.failed": 0 } };
+		const decision = decideSweep([], episodes, POLICY, NOW, {}, inputs);
+		expect(decision.resolve).toHaveLength(0);
+		expect(decision.zeroVolumeHold).toHaveLength(1);
+		expect(decision.zeroVolumeHold[0].volumeCount).toBe(0);
+	});
+
+	test("quiet WITH healthy call volume still resolves (the normal close)", () => {
+		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
+		const inputs = { ...VOLUME_BACKED, countByKind: { "llm.provider.call.failed": 120 } };
+		const decision = decideSweep([], episodes, POLICY, NOW, {}, inputs);
+		expect(decision.zeroVolumeHold).toHaveLength(0);
+		expect(decision.resolve).toHaveLength(1);
+		expect(decision.resolve[0].clearZeroVolumeFlag).toBe(false);
+	});
+
+	test("a sourceless kind resolves on quiet exactly as before", () => {
+		const episodes = [episode({ kind: "guard.fail.open", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
+		const decision = decideSweep([], episodes, POLICY, NOW, {}, { ...VOLUME_BACKED, countByKind: {} });
+		expect(decision.resolve).toHaveLength(1);
+		expect(decision.zeroVolumeHold).toHaveLength(0);
+	});
+
+	test("recovery from a flagged hold clears the flag on resolve", () => {
+		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
+		const inputs = {
+			...VOLUME_BACKED,
+			countByKind: { "llm.provider.call.failed": 50 },
+			flagActiveByKind: { "llm.provider.call.failed": true },
+		};
+		const decision = decideSweep([], episodes, POLICY, NOW, {}, inputs);
+		expect(decision.resolve[0].clearZeroVolumeFlag).toBe(true);
+	});
+
+	test("without a sixth argument the legacy shape is untouched", () => {
+		const episodes = [episode({ kind: "llm.provider.call.failed", lastSeenAt: new Date(NOW.getTime() - 45 * 60_000) })];
+		const decision = decideSweep([], episodes, POLICY, NOW);
+		expect(decision.resolve).toHaveLength(1);
+	});
+});
+
+describe("composeZeroVolumeMessage — the quiet-is-not-healthy notice", () => {
+	test("names the held kind, both absences and the floors; stays phone-sized", () => {
+		const message = composeZeroVolumeMessage({
+			kind: "llm.provider.call.failed",
+			volumeKindPattern: "^llm\.router\.routing_decision$",
+			minVolume: 1,
+			quietMinutes: 600,
+			volumeCount: 0,
+			firstSeenAt: new Date(NOW.getTime() - 700 * 60_000),
+		});
+		for (const fragment of ["llm.provider.call.failed", "routing_decision", "(0 < floor 1", "Recommendation:"]) {
+			expect(message).toContain(fragment);
+		}
+		expect(message.split("\n").length).toBeLessThanOrEqual(4);
+	});
+});

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

@@ -22,12 +22,19 @@ import {
 	decideSweep,
 	type EscalationEpisode,
 	type KindThresholdOverride,
+	type ZeroVolumeInputs,
 } from "./platform-fault-escalation-logic.ts";
 import { loadFaultEscalationConfig } from "./platform-fault-escalation/config.ts";
-import { fetchAggregates } from "./platform-fault-escalation/event-log-queries.ts";
+import {
+	fetchAggregates,
+	fetchVolumeCount,
+	zeroVolumeFlagActive,
+} from "./platform-fault-escalation/event-log-queries.ts";
 import { orpc } from "./platform-fault-escalation/orpc-client.ts";
 import {
+	clearZeroVolumeHold,
 	deliverEscalation,
+	deliverZeroVolumeHold,
 	resolveEpisode,
 } from "./platform-fault-escalation/delivery.ts";
 
@@ -70,6 +77,22 @@ async function platformFaultEscalationSweep(ctx: { config: ScheduledJobConfig })
 			minSpanMinutes: override?.min_span_minutes,
 		};
 	}
+
+	// ZERO-VOLUME INPUTS: per configured kind, resolve its source's window
+	// volume and standing-flag state so decideSweep can tell quiet apart
+	// from dead-producer. Computed here, pure decision stays in logic.
+	const volumeSources = config.volume_sources ?? {};
+	const zeroVolume: ZeroVolumeInputs = { sources: volumeSources, countByKind: {}, flagActiveByKind: {} };
+	for (const [kind, source] of Object.entries(volumeSources)) {
+		try {
+			zeroVolume.countByKind[kind] = await fetchVolumeCount(source.volume_kind_pattern, config.window_minutes);
+		} catch (err) {
+			log.error(
+				`[platform-fault-escalation] volume count for '${kind}' (~${source.volume_kind_pattern}) failed (${err instanceof Error ? err.message : String(err)}) — treating as unmeasured for this sweep`,
+			);
+		}
+	}
+
 	const decision = decideSweep(
 		aggregates,
 		episodes,
@@ -80,6 +103,7 @@ async function platformFaultEscalationSweep(ctx: { config: ScheduledJobConfig })
 		},
 		now,
 		kindThresholds,
+		Object.keys(volumeSources).length > 0 ? zeroVolume : undefined,
 	);
 
 	// Per-kind isolation: one fault's delivery failure must never block the
@@ -97,9 +121,28 @@ async function platformFaultEscalationSweep(ctx: { config: ScheduledJobConfig })
 			recordEvent({ kind: "platform.fault.escalation_failed", payload: { event_kind: aggregate.kind, reason } });
 		}
 	}
-	for (const { episode, quietMinutes } of decision.resolve) {
+	for (const { episode, quietMinutes } of decision.zeroVolumeHold) {
+		const source = volumeSources[episode.kind];
+		if (!source) continue;
+		try {
+			if (await zeroVolumeFlagActive(episode.kind)) continue; // hold already raised once
+			await deliverZeroVolumeHold(
+				episode,
+				quietMinutes,
+				zeroVolume.countByKind[episode.kind] ?? 0,
+				source,
+			);
+			log.warn(
+				`[platform-fault-escalation] ZERO-VOLUME HOLD raised for '${episode.kind}' — failures quiet AND producer quiet; episode held open`,
+			);
+		} catch (err) {
+			log.error(`[platform-fault-escalation] zero-volume hold for '${episode.kind}' failed (retried next sweep): ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	for (const { episode, quietMinutes, clearZeroVolumeFlag } of decision.resolve) {
 		try {
 			await resolveEpisode(episode, quietMinutes);
+			if (clearZeroVolumeFlag) await clearZeroVolumeHold(episode, zeroVolume.countByKind[episode.kind] ?? 0);
 		} catch (err) {
 			log.error(`[platform-fault-escalation] resolve for '${episode.kind}' failed: ${err instanceof Error ? err.message : String(err)}`);
 		}
@@ -113,9 +156,10 @@ async function platformFaultEscalationSweep(ctx: { config: ScheduledJobConfig })
 			watched_kinds: aggregates.length,
 			escalated: decision.escalate.length,
 			resolved: decision.resolve.length,
+			zero_volume_holds: decision.zeroVolumeHold.length,
 		},
 	});
-	if (decision.escalate.length > 0 || decision.resolve.length > 0) {
+	if (decision.escalate.length > 0 || decision.resolve.length > 0 || decision.zeroVolumeHold.length > 0) {
 		log.info(
 			`[platform-fault-escalation] sweep — ${aggregates.length} kind(s) watched, ${decision.escalate.length} escalated, ${decision.resolve.length} resolved`,
 		);

package/src/page-server-orpc/audit-revert-router.ts

@@ -47,7 +47,7 @@ export const auditRevertRouter = {
 		if (!user?.isSuperAdmin) {
 			throw new Error("auditRevert: requires super-admin");
 		}
-		const prisma = getPrisma(context) as unknown as Record<string, any>;
+		const prisma = getPrisma(context) as unknown as Record<string, unknown>;
 		const log = getAppLogger();
 		const { auditTrailId } = input;
 

package/src/pg-boss-mount.ts

@@ -147,7 +147,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.serviceSiblingConnections.
+		// config/db-pool-sizing.perServiceOverhead (pg-boss 1 + LISTEN 1 = 2).
 		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/resolve-from-loader-config.ts

@@ -13,7 +13,7 @@
 
 import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
 import { ResolverFnConfigSchema } from "@teamscala/db-validation/registry-schemas/resolver-fn";
-import { getServerClient } from "@teamscala/service-boot/page-server-orpc/server-client";
+import { getServerClient } from "./page-server-orpc/server-client";
 
 interface SourceConfig {
 	key: string;

package/src/two-phase-readiness.ts

@@ -10,6 +10,7 @@
  */
 
 import { buildWakingPageHtml } from "@teamscala/os/brand/waking-page-html";
+import { WAKING_RETRY_SECONDS } from "@teamscala/os/brand/waking-page-budget.generated";
 import type { Context } from "hono";
 import { getServerClientCapabilityFault } from "./page-server-orpc/server-client.ts";
 import { resolveErrorPageLogo } from "./resource-not-found.ts";
@@ -160,7 +161,7 @@ export function createPhase1PageHandler(serviceSlug: string): CreatePageHandler
 					headers: {
 						"content-type": "text/html; charset=utf-8",
 						"cache-control": "no-store, no-transform",
-						"retry-after": "5",
+						"retry-after": String(WAKING_RETRY_SECONDS),
 					},
 				});
 			}