@camstack/system 1.2.441 → 1.2.443

package/dist/builtins/alerts/alerts.addon.mjs

@@ -1,4 +1,108 @@
-import { Ar as errMsg, Si as EventCategory, i as AlertSchema, jr as BaseAddon, qr as createEvent, st as alertsCapability } from "../../dist-BWvkuc31.mjs";
+import { Ar as errMsg, Ei as EventCategory, Jr as createEvent, i as AlertSchema, jr as BaseAddon, st as alertsCapability } from "../../dist-Bxt_S-9a.mjs";
+//#region src/builtins/alerts/critical-push.ts
+/** Alert categories that are critical system findings. */
+var CRITICAL_CATEGORIES = new Set([
+	"addon.runner-failed",
+	"addon.runner-refused",
+	"system.runner-check"
+]);
+function isPushState(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const rec = value;
+	return (rec["state"] === "pending" || rec["state"] === "delivered" || rec["state"] === "disabled") && typeof rec["key"] === "string" && typeof rec["attempts"] === "number";
+}
+function selectPushTargets(targets, policy) {
+	const enabled = targets.filter((t) => t.enabled);
+	if (policy.targetIds.length > 0) return enabled.filter((t) => policy.targetIds.includes(t.id));
+	return enabled.filter((t) => t.ownerUserId === void 0);
+}
+var MAX_DIGEST_LINES = 20;
+/** The one message a target gets for a set of findings. */
+function composeDigest(items) {
+	const first = items[0];
+	if (items.length === 1 && first !== void 0) return {
+		title: first.title,
+		body: first.line
+	};
+	const shown = items.slice(0, MAX_DIGEST_LINES).map((i) => i.line);
+	const more = items.length - shown.length;
+	return {
+		title: `${String(items.length)} addons need attention`,
+		body: [...shown, ...more > 0 ? [`... and ${String(more)} more`] : []].join("\n")
+	};
+}
+/**
+* Push every item that still needs it, as ONE message per target. Returns the new
+* state of each item whose state changed (an item already delivered/disabled for
+* its key is absent from the result).
+*/
+async function deliverDigest(input) {
+	const out = /* @__PURE__ */ new Map();
+	const work = input.items.filter((i) => !(i.previous !== null && i.previous.key === i.key && i.previous.state !== "pending"));
+	if (work.length === 0) return out;
+	const sameKey = (i) => i.previous !== null && i.previous.key === i.key ? i.previous : null;
+	const attemptsOf = (i) => (sameKey(i)?.attempts ?? 0) + 1;
+	const sentOf = (i) => sameKey(i)?.sentTo ?? [];
+	if (!input.policy.enabled) {
+		for (const i of work) out.set(i.alertId, {
+			state: "disabled",
+			key: i.key,
+			attempts: attemptsOf(i)
+		});
+		return out;
+	}
+	const fail = (error) => {
+		for (const i of work) out.set(i.alertId, {
+			state: "pending",
+			key: i.key,
+			attempts: attemptsOf(i),
+			lastError: error,
+			...sentOf(i).length > 0 ? { sentTo: sentOf(i) } : {}
+		});
+		return out;
+	};
+	let targets;
+	try {
+		targets = selectPushTargets(await input.ports.listTargets(), input.policy);
+	} catch (err) {
+		return fail(`notifiers unavailable: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (targets.length === 0) return fail("no eligible notifier target");
+	const sent = new Map(work.map((i) => [i.alertId, [...sentOf(i)]]));
+	const errors = new Map(work.map((i) => [i.alertId, []]));
+	for (const target of targets) {
+		const todo = work.filter((i) => !(sent.get(i.alertId) ?? []).includes(target.id));
+		if (todo.length === 0) continue;
+		let failure = null;
+		try {
+			const result = await input.ports.send(target, composeDigest(todo));
+			if (!result.success) failure = `${target.id}: ${result.error ?? "send failed"}`;
+		} catch (err) {
+			failure = `${target.id}: ${err instanceof Error ? err.message : String(err)}`;
+		}
+		for (const i of todo) if (failure === null) sent.get(i.alertId)?.push(target.id);
+		else errors.get(i.alertId)?.push(failure);
+	}
+	for (const i of work) {
+		const sentTo = sent.get(i.alertId) ?? [];
+		const complete = targets.every((t) => sentTo.includes(t.id));
+		out.set(i.alertId, complete ? {
+			state: "delivered",
+			key: i.key,
+			at: input.now,
+			attempts: attemptsOf(i),
+			sentTo
+		} : {
+			state: "pending",
+			key: i.key,
+			attempts: attemptsOf(i),
+			lastError: (errors.get(i.alertId) ?? []).join("; "),
+			...sentTo.length > 0 ? { sentTo } : {}
+		});
+	}
+	return out;
+}
+//#endregion
 //#region src/builtins/alerts/device-label.ts
 /**
 * Operator-facing device label for alert messages.
@@ -42,6 +146,137 @@ function selectOverflow(alerts, maxAlerts) {
 	return [...byAge.filter((a) => a.read), ...byAge.filter((a) => !a.read)].slice(0, excess).map((a) => a.id);
 }
 //#endregion
+//#region src/builtins/alerts/runner-alert.ts
+var RUNNER_ALERT_CATEGORIES = [
+	"process.crashed",
+	"addon.crashed",
+	"addon.runner-failed",
+	"addon.runner-refused"
+];
+function isRunnerAlertCategory(category) {
+	return RUNNER_ALERT_CATEGORIES.includes(category);
+}
+/** Stable alert id of a runner on a node. */
+function runnerAlertId(nodeId, runnerId) {
+	return `runner:${nodeId}:${runnerId}`;
+}
+function str(data, key) {
+	const value = data[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function strList(data, key) {
+	const value = data[key];
+	return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+/** Which runner an event is about; `null` when it names none. */
+function runnerKeyOf(category, data, source) {
+	const nodeId = str(data, "nodeId") ?? source?.nodeId ?? "hub";
+	const runnerId = category === "process.crashed" ? str(data, "processId") ?? source?.id ?? "unknown" : category === "addon.crashed" ? str(data, "addonId") ?? source?.id ?? "unknown" : str(data, "runnerId");
+	return runnerId === void 0 ? null : {
+		nodeId,
+		runnerId
+	};
+}
+/** Fold one event into the runner's record. */
+function foldRunnerEvent(previous, category, data, key, now) {
+	const base = previous ?? {
+		nodeId: key.nodeId,
+		runnerId: key.runnerId,
+		state: "crashed",
+		since: now,
+		count: 0,
+		addonIds: []
+	};
+	const addonIds = [...new Set([...base.addonIds, ...strList(data, "addonIds")])];
+	const count = base.count + 1;
+	switch (category) {
+		case "addon.runner-refused": return {
+			...base,
+			state: "refused",
+			count,
+			addonIds,
+			reason: str(data, "reason") ?? "refused to start",
+			...str(data, "remedy") !== void 0 ? { remedy: str(data, "remedy") } : {}
+		};
+		case "addon.runner-failed": {
+			if (base.state === "refused") return {
+				...base,
+				count,
+				addonIds
+			};
+			const crashes = data["crashesInWindow"];
+			return {
+				...base,
+				state: "failed",
+				count,
+				addonIds,
+				...typeof crashes === "number" ? { crashesInWindow: crashes } : {}
+			};
+		}
+		case "addon.crashed": {
+			const error = str(data, "error");
+			const addonId = str(data, "addonId");
+			return {
+				...base,
+				count,
+				addonIds: addonId !== void 0 ? [...new Set([...addonIds, addonId])] : addonIds,
+				...error !== void 0 ? { lastError: error } : {}
+			};
+		}
+		case "process.crashed": return {
+			...base,
+			count,
+			addonIds
+		};
+	}
+}
+function renderRunnerAlert(record) {
+	const where = record.nodeId === "hub" ? record.runnerId : `${record.runnerId} on ${record.nodeId}`;
+	switch (record.state) {
+		case "refused": return {
+			severity: "error",
+			title: "Addon refused to start",
+			message: `${where}: refused - ${record.reason ?? "no reason reported"}${record.remedy !== void 0 ? ` ${record.remedy}` : ""}`
+		};
+		case "failed": return {
+			severity: "error",
+			title: "Addon crash loop",
+			message: `Runner "${where}" gave up${record.crashesInWindow !== void 0 ? ` after ${String(record.crashesInWindow)} crashes` : ""}${record.addonIds.length > 0 ? ` (addons: ${record.addonIds.join(", ")})` : ""} - ${String(record.count)} events`
+		};
+		case "crashed": return {
+			severity: "error",
+			title: "Addon crashed",
+			message: `Addon "${where}" crashed${record.lastError !== void 0 ? `: ${record.lastError}` : ""}${record.count > 1 ? ` (${String(record.count)} events)` : ""}`
+		};
+	}
+}
+/** Is the record in a state an operator must act on (terminal)? */
+function isTerminalRunnerState(state) {
+	return state === "failed" || state === "refused";
+}
+function hash(text) {
+	let h = 5381;
+	for (let i = 0; i < text.length; i++) h = (h << 5) + h + text.charCodeAt(i) | 0;
+	return (h >>> 0).toString(36);
+}
+/**
+* The push key of a record: its episode and its cause. The same refusal of the
+* same episode is never pushed twice; a refusal with another reason, a breaker
+* trip, or any failure after a recovery (a new episode) is a new push.
+*/
+function runnerPushKey(record) {
+	const cause = record.state === "refused" ? hash(`${record.reason ?? ""}|${record.remedy ?? ""}`) : "breaker";
+	return `runner:${record.state}:${String(record.since)}:${cause}`;
+}
+/**
+* The one line a push carries: runner, state and the remedy. Deliberately NOT
+* the raw reason or error text - those stay on the alert.
+*/
+function runnerPushLine(record) {
+	const where = record.nodeId === "hub" ? record.runnerId : `${record.runnerId} on ${record.nodeId}`;
+	return record.state === "refused" ? `${where}: refused to start. ${record.remedy ?? "See the Addons page."}` : `${where}: stopped after repeated crashes. Restart it from the Addons page.`;
+}
+//#endregion
 //#region src/builtins/alerts/alerts.addon.ts
 var CATEGORY_MAPPINGS = {
 	"addon.crashed": {
@@ -52,6 +287,14 @@ var CATEGORY_MAPPINGS = {
 		severity: "error",
 		titleTemplate: "Addon crash loop"
 	},
+	"addon.runner-refused": {
+		severity: "error",
+		titleTemplate: "Addon refused to start"
+	},
+	"system.runner-check": {
+		severity: "error",
+		titleTemplate: "Runners degraded"
+	},
 	"addon.error": {
 		severity: "error",
 		titleTemplate: "Addon error"
@@ -135,6 +378,8 @@ var CATEGORY_MAPPINGS = {
 * {@link CATEGORY_MAPPINGS}.
 */
 var SILENT_TRACKED_CATEGORIES = [
+	"addon.started",
+	"process.state-changed",
 	"addon.load-recovered",
 	"system.liveness-recovered",
 	"stream.online"
@@ -156,6 +401,28 @@ var TRACKED_CATEGORIES = [...Object.keys(CATEGORY_MAPPINGS), ...SILENT_TRACKED_C
 */
 var RATE_LIMIT_WINDOW_MS = 6e4;
 var RATE_LIMIT_MAX_PER_SOURCE = 5;
+/** The alert `category` a runner record carries - the state it is in. */
+function runnerCategoryOf(state) {
+	return state === "refused" ? "addon.runner-refused" : state === "failed" ? "addon.runner-failed" : "addon.crashed";
+}
+function parseRunnerRecord(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const rec = value;
+	const state = rec["state"];
+	if (typeof rec["nodeId"] !== "string" || typeof rec["runnerId"] !== "string" || state !== "crashed" && state !== "failed" && state !== "refused" || typeof rec["count"] !== "number" || !Array.isArray(rec["addonIds"])) return null;
+	return {
+		nodeId: rec["nodeId"],
+		runnerId: rec["runnerId"],
+		state,
+		since: typeof rec["since"] === "number" ? rec["since"] : 0,
+		count: rec["count"],
+		addonIds: rec["addonIds"].filter((x) => typeof x === "string"),
+		...typeof rec["lastError"] === "string" ? { lastError: rec["lastError"] } : {},
+		...typeof rec["reason"] === "string" ? { reason: rec["reason"] } : {},
+		...typeof rec["remedy"] === "string" ? { remedy: rec["remedy"] } : {},
+		...typeof rec["crashesInWindow"] === "number" ? { crashesInWindow: rec["crashesInWindow"] } : {}
+	};
+}
 /** Parse a raw settings record into a validated Alert. */
 function parseAlert(record) {
 	return AlertSchema.parse({
@@ -165,8 +432,14 @@ function parseAlert(record) {
 }
 var DEFAULT_CONFIG = {
 	maxAlerts: 500,
-	retentionDays: 30
+	retentionDays: 30,
+	criticalPushEnabled: true,
+	criticalPushTargetIds: ""
 };
+/** One burst of critical findings (a whole boot of refused runners) is ONE digest push. */
+var PUSH_COALESCE_MS = 2e3;
+/** Addons whose (re)start is a reason to retry pending critical pushes. */
+var PUSH_RECONCILE_ADDONS = new Set(["notifiers", "notification-center"]);
 var ALERTS_COLLECTION = "alerts";
 var EVENT_SOURCE = {
 	type: "addon",
@@ -189,8 +462,11 @@ function toPrunable(record) {
 }
 var AlertCenterAddon = class extends BaseAddon {
 	unsubscribers = [];
-	constructor() {
+	/** How long a burst of critical findings is gathered into one digest push. */
+	pushCoalesceMs;
+	constructor(options) {
 		super({ ...DEFAULT_CONFIG });
+		this.pushCoalesceMs = options?.pushCoalesceMs ?? PUSH_COALESCE_MS;
 	}
 	/**
 	* Per `(category, source.id)` counter used to rate-limit chatty
@@ -216,6 +492,7 @@ var AlertCenterAddon = class extends BaseAddon {
 			unsubs.push(unsub);
 		}
 		this.unsubscribers = unsubs;
+		this.reconcilePendingPushes();
 		this.ctx.logger.info("Initialized", { meta: { trackedCategoriesCount: TRACKED_CATEGORIES.length } });
 		return [{
 			capability: alertsCapability,
@@ -234,29 +511,46 @@ var AlertCenterAddon = class extends BaseAddon {
 			description: "Configure alert storage and retention.",
 			descriptionKey: "server:globalSettings.s_alerts.description",
 			columns: 1,
-			fields: [this.field({
-				type: "number",
-				key: "maxAlerts",
-				label: "Maximum stored alerts",
-				labelKey: "server:globalSettings.s_alerts.maxAlerts.label",
-				description: "Oldest read alerts are deleted when this limit is exceeded.",
-				descriptionKey: "server:globalSettings.s_alerts.maxAlerts.description",
-				min: 50,
-				max: 5e3,
-				step: 50,
-				default: 500
-			}), this.field({
-				type: "number",
-				key: "retentionDays",
-				label: "Alert retention (days)",
-				labelKey: "server:globalSettings.s_alerts.retentionDays.label",
-				description: "Alerts older than this are automatically removed.",
-				descriptionKey: "server:globalSettings.s_alerts.retentionDays.description",
-				min: 1,
-				max: 365,
-				step: 1,
-				default: 30
-			})]
+			fields: [
+				this.field({
+					type: "number",
+					key: "maxAlerts",
+					label: "Maximum stored alerts",
+					labelKey: "server:globalSettings.s_alerts.maxAlerts.label",
+					description: "Oldest read alerts are deleted when this limit is exceeded.",
+					descriptionKey: "server:globalSettings.s_alerts.maxAlerts.description",
+					min: 50,
+					max: 5e3,
+					step: 50,
+					default: 500
+				}),
+				this.field({
+					type: "number",
+					key: "retentionDays",
+					label: "Alert retention (days)",
+					labelKey: "server:globalSettings.s_alerts.retentionDays.label",
+					description: "Alerts older than this are automatically removed.",
+					descriptionKey: "server:globalSettings.s_alerts.retentionDays.description",
+					min: 1,
+					max: 365,
+					step: 1,
+					default: 30
+				}),
+				this.field({
+					type: "boolean",
+					key: "criticalPushEnabled",
+					label: "Push critical system alerts",
+					description: "A runner that failed or refused to start, or a node whose runners are degraded, is pushed straight to the notifier targets - even when notification-center is down.",
+					default: true
+				}),
+				this.field({
+					type: "text",
+					key: "criticalPushTargetIds",
+					label: "Critical push targets",
+					description: "Comma-separated notifier target ids. Empty = every enabled shared (not personal) target.",
+					default: ""
+				})
+			]
 		}] });
 	}
 	async listAlerts(filter) {
@@ -316,6 +610,23 @@ var AlertCenterAddon = class extends BaseAddon {
 				await this.handleModelDownload(event);
 				return;
 			}
+			if (isRunnerAlertCategory(category)) {
+				await this.handleRunnerEvent(category, event);
+				return;
+			}
+			if (category === EventCategory.ProcessStateChanged) {
+				await this.handleRunnerStateChanged(event);
+				return;
+			}
+			if (category === EventCategory.SystemRunnerCheck) {
+				await this.handleRunnerCheck(event);
+				return;
+			}
+			if (category === EventCategory.AddonStarted) {
+				const addonId = event.data["addonId"];
+				if (typeof addonId === "string" && PUSH_RECONCILE_ADDONS.has(addonId)) await this.reconcilePendingPushes();
+				return;
+			}
 			if (category === EventCategory.AddonLoadFailed) {
 				await this.handleAddonLoadFailed(event);
 				return;
@@ -374,6 +685,307 @@ var AlertCenterAddon = class extends BaseAddon {
 			} });
 		}
 	}
+	async readRunnerRecord(alertId) {
+		const backend = this.ctx.api.settingsStore;
+		if (!backend) return null;
+		const raw = await backend.get.query({
+			collection: ALERTS_COLLECTION,
+			key: alertId
+		});
+		if (raw === null || raw === void 0 || typeof raw !== "object") return null;
+		const alert = AlertSchema.safeParse(raw);
+		if (!alert.success || alert.data.status === "dismissed") return null;
+		return parseRunnerRecord(alert.data.metadata?.["runner"]);
+	}
+	async handleRunnerEvent(category, event) {
+		if (!isRunnerAlertCategory(category)) return;
+		const key = runnerKeyOf(category, event.data, event.source ? {
+			id: String(event.source.id),
+			...typeof event.source.nodeId === "string" ? { nodeId: event.source.nodeId } : {}
+		} : void 0);
+		if (key === null) return;
+		const alertId = runnerAlertId(key.nodeId, key.runnerId);
+		const previous = await this.readRunnerRecord(alertId);
+		const record = foldRunnerEvent(previous, category, event.data, key, Date.now());
+		const rendered = renderRunnerAlert(record);
+		const existing = await this.readAlertRaw(alertId);
+		const now = Date.now();
+		const alert = {
+			id: alertId,
+			category: runnerCategoryOf(record.state),
+			severity: rendered.severity,
+			title: rendered.title,
+			message: rendered.message,
+			status: "active",
+			read: previous !== null && previous.state === record.state ? existing?.read === true : false,
+			createdAt: previous !== null ? existing?.createdAt ?? now : now,
+			updatedAt: now,
+			source: event.source ? {
+				type: event.source.type,
+				id: String(event.source.id)
+			} : {
+				type: "runner",
+				id: record.runnerId
+			},
+			metadata: {
+				runner: record,
+				pushLine: runnerPushLine(record),
+				...existing?.push !== void 0 ? { push: existing.push } : {}
+			}
+		};
+		await this.persistAlert(alert);
+		if (previous === null) this.emitAlertCreatedEvent(alert);
+		else this.emitAlertUpdatedEvent(alertId, {
+			message: alert.message,
+			title: alert.title
+		});
+		await this.enforceMaxAlerts();
+		if (isTerminalRunnerState(record.state)) this.queuePush({
+			alertId,
+			key: runnerPushKey(record),
+			title: rendered.title,
+			line: runnerPushLine(record)
+		});
+	}
+	/**
+	* A runner reached `running`: its episode is over. Close the runner alert so a
+	* later failure opens a NEW episode (new push key), instead of folding into a
+	* stale `refused` record that would never push again.
+	*/
+	async handleRunnerStateChanged(event) {
+		if (event.data["state"] !== "running") return;
+		const runnerId = typeof event.data["runnerId"] === "string" ? event.data["runnerId"] : null;
+		if (runnerId === null) return;
+		const alertId = runnerAlertId(typeof event.data["nodeId"] === "string" ? event.data["nodeId"] : "hub", runnerId);
+		if (await this.readRunnerRecord(alertId) === null) return;
+		await this.dismiss(alertId);
+	}
+	/** The node's one-shot runner boot check: one alert, dismissed when the node is clean. */
+	async handleRunnerCheck(event) {
+		const nodeId = typeof event.data["nodeId"] === "string" ? event.data["nodeId"] : "hub";
+		const alertId = `runner-check:${nodeId}`;
+		if (event.data["degraded"] !== true) {
+			await this.dismiss(alertId);
+			return;
+		}
+		const summary = typeof event.data["summary"] === "string" ? event.data["summary"] : "degraded";
+		const ids = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+		const refusedIds = Array.isArray(event.data["refused"]) ? event.data["refused"].flatMap((r) => {
+			const id = typeof r === "object" && r !== null ? r["runnerId"] : void 0;
+			return typeof id === "string" ? [id] : [];
+		}) : [];
+		const failedIds = ids(event.data["failed"]);
+		const missingIds = ids(event.data["missing"]);
+		const pushLine = `${nodeId}: runners degraded - ${[
+			...failedIds.length > 0 ? [`failed: ${failedIds.join(", ")}`] : [],
+			...refusedIds.length > 0 ? [`refused: ${refusedIds.join(", ")}`] : [],
+			...missingIds.length > 0 ? [`missing: ${missingIds.join(", ")}`] : []
+		].join("; ")}. See the Addons page.`;
+		const pushKey = `check:${[
+			...failedIds,
+			...refusedIds,
+			...missingIds
+		].sort().join(",")}`;
+		const now = Date.now();
+		const existing = await this.readAlertRaw(alertId);
+		const alert = {
+			id: alertId,
+			category: "system.runner-check",
+			severity: "error",
+			title: "Runners degraded",
+			message: `${nodeId}: ${summary}`,
+			status: "active",
+			read: false,
+			createdAt: existing?.createdAt ?? now,
+			updatedAt: now,
+			source: {
+				type: "node",
+				id: nodeId
+			},
+			metadata: {
+				nodeId,
+				failed: event.data["failed"],
+				refused: event.data["refused"],
+				missing: event.data["missing"],
+				pushLine,
+				...existing?.push !== void 0 ? { push: existing.push } : {}
+			}
+		};
+		await this.persistAlert(alert);
+		this.emitAlertCreatedEvent(alert);
+		this.queuePush({
+			alertId,
+			key: pushKey,
+			title: alert.title,
+			line: pushLine
+		});
+	}
+	async readAlertRaw(alertId) {
+		const backend = this.ctx.api.settingsStore;
+		if (!backend) return null;
+		const raw = await backend.get.query({
+			collection: ALERTS_COLLECTION,
+			key: alertId
+		});
+		if (raw === null || raw === void 0 || typeof raw !== "object") return null;
+		const rec = Object.fromEntries(Object.entries(raw));
+		const meta = rec["metadata"];
+		const push = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta["push"] : void 0;
+		return {
+			...typeof rec["createdAt"] === "number" ? { createdAt: rec["createdAt"] } : {},
+			...typeof rec["read"] === "boolean" ? { read: rec["read"] } : {},
+			...isPushState(push) ? { push } : {}
+		};
+	}
+	/** Pushes run one at a time so a burst can never send the same state twice. */
+	pushChain = Promise.resolve();
+	/** Findings waiting for the next digest, by alert id. */
+	pushQueue = /* @__PURE__ */ new Map();
+	pushTimer = null;
+	pushPolicy() {
+		return {
+			enabled: this.config.criticalPushEnabled,
+			targetIds: this.config.criticalPushTargetIds.split(",").map((id) => id.trim()).filter((id) => id.length > 0)
+		};
+	}
+	pushPorts() {
+		const api = this.ctx.api;
+		return {
+			listTargets: async () => {
+				return (await api.notificationOutput.listTargets.query({})).map((t) => {
+					const owner = t.config["ownerUserId"];
+					return {
+						id: t.id,
+						addonId: t.addonId,
+						enabled: t.enabled,
+						...typeof owner === "string" && owner.length > 0 ? { ownerUserId: owner } : {}
+					};
+				});
+			},
+			send: async (target, message) => api.notificationOutput.send.mutate({
+				addonId: target.addonId,
+				targetId: target.id,
+				notification: {
+					title: message.title,
+					body: message.body,
+					format: "text",
+					priority: 5
+				}
+			})
+		};
+	}
+	/**
+	* Queue a critical finding for the next digest. A burst (every runner of a boot)
+	* arrives within the coalesce window and leaves as ONE message per target.
+	*/
+	queuePush(item) {
+		this.pushQueue.set(item.alertId, item);
+		if (this.pushTimer !== null) return;
+		this.pushTimer = setTimeout(() => {
+			this.pushTimer = null;
+			this.flushPushes();
+		}, this.pushCoalesceMs);
+		this.pushTimer.unref?.();
+	}
+	/** Send the queued findings now (also the reconcile path). */
+	flushPushes() {
+		this.pushChain = this.pushChain.then(async () => {
+			const queued = [...this.pushQueue.values()];
+			this.pushQueue.clear();
+			if (queued.length === 0) return;
+			try {
+				const items = [];
+				for (const q of queued) {
+					const existing = await this.readAlertRaw(q.alertId);
+					items.push({
+						...q,
+						previous: existing?.push ?? null
+					});
+				}
+				const states = await deliverDigest({
+					items,
+					policy: this.pushPolicy(),
+					ports: this.pushPorts(),
+					now: Date.now()
+				});
+				for (const [alertId, state] of states) {
+					await this.storePushState(alertId, state);
+					this.ctx.logger?.info("critical alert push", { meta: {
+						alertId,
+						state: state.state,
+						attempts: state.attempts,
+						error: state.lastError
+					} });
+				}
+			} catch (err) {
+				this.ctx.logger?.warn("critical alert push failed unexpectedly", { meta: { error: errMsg(err) } });
+			}
+		});
+		return this.pushChain;
+	}
+	async storePushState(alertId, push) {
+		const backend = this.ctx.api.settingsStore;
+		if (!backend) return;
+		const raw = await backend.get.query({
+			collection: ALERTS_COLLECTION,
+			key: alertId
+		});
+		if (raw === null || raw === void 0 || typeof raw !== "object") return;
+		const existing = Object.fromEntries(Object.entries(raw));
+		const meta = existing["metadata"];
+		const metadata = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
+		await backend.set.mutate({
+			collection: ALERTS_COLLECTION,
+			key: alertId,
+			value: {
+				...existing,
+				metadata: {
+					...metadata,
+					push
+				}
+			}
+		});
+	}
+	/**
+	* Retry every critical alert whose push is still pending - at boot and when
+	* the notifiers or notification-center start. An alert whose state was already
+	* delivered is skipped by its key, so reconciling never sends twice.
+	*/
+	async reconcilePendingPushes() {
+		const backend = this.ctx.api.settingsStore;
+		if (!backend) return;
+		try {
+			const rows = await backend.query.query({
+				collection: ALERTS_COLLECTION,
+				filter: {
+					orderBy: {
+						field: "updatedAt",
+						direction: "desc"
+					},
+					limit: 500
+				}
+			});
+			for (const row of rows) {
+				const parsed = AlertSchema.safeParse({
+					id: row.id,
+					...row.data
+				});
+				if (!parsed.success || parsed.data.status !== "active") continue;
+				if (!CRITICAL_CATEGORIES.has(parsed.data.category)) continue;
+				const push = parsed.data.metadata?.["push"];
+				if (!isPushState(push) || push.state !== "pending") continue;
+				this.pushQueue.set(parsed.data.id, {
+					alertId: parsed.data.id,
+					key: push.key,
+					title: parsed.data.title,
+					line: String(parsed.data.metadata?.["pushLine"] ?? parsed.data.title)
+				});
+			}
+			await this.flushPushes();
+		} catch (err) {
+			this.ctx.logger?.warn("pending critical push reconcile failed", { meta: { error: errMsg(err) } });
+		}
+	}
 	async handleModelDownload(event) {
 		const data = event.data;
 		const modelId = data.modelId ?? "unknown";