@camstack/system 1.2.453 → 1.2.455

package/dist/builtins/alerts/alerts.addon.js

@@ -3,114 +3,50 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-DyjNaeIj.js");
+const require_dist = require("../../dist-DjQ8C-ku.js");
 const require_read_all_rows$1 = require("../../read-all-rows-CVoO1ONM.js");
-const require_phase6_declare_gate = require("../../phase6-declare-gate-BlTDMI3t.js");
-//#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 isCriticalPush(alert) {
-	return alert.severity === "critical" || CRITICAL_CATEGORIES.has(alert.category);
-}
-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")
-	};
-}
+const require_phase6_declare_gate = require("../../phase6-declare-gate-DrmTtz7F.js");
+//#region src/builtins/alerts/alert-episode-policy.ts
 /**
-* 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).
+* When does an alert open a new EPISODE, and which edge of it is announced?
+*
+* The alert centre sends no notification. It stamps every alert it stores with
+* an `episodeId` (`metadata.episodeId`) and announces the opening and the
+* closing of critical and error episodes on the bus; Notification Center turns
+* those into notifications (`alert-critical`, `alert-error`,
+* `alert-critical-resolved`). The identity is what makes a notification
+* once-per-episode: any number of re-emits of an open alert keep the id, a new
+* episode after completion gets a new one.
 */
-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 } : {}
-		});
+/**
+* The previous episode continues while its alert is still open and the emitter
+* did not mark a new one; anything else opens `<alertId>@<now>`.
+*/
+function nextEpisodeId(input) {
+	const { previous } = input;
+	if (previous !== null && require_dist.isAlertEpisodeOpen(previous.status)) {
+		if (input.incomingKey === void 0 || input.incomingKey === previous.episodeKey) return previous.episodeId;
 	}
-	return out;
+	const minted = `${input.alertId}@${String(input.now)}`;
+	return previous !== null && previous.episodeId === minted ? `${minted}+` : minted;
+}
+/**
+* The edge to announce for a write that took `previous` to `next`, or `null`.
+* A re-emit that changes nothing about the episode announces nothing; an
+* escalation from `error` to `critical` inside one episode is announced again
+* (it is a different kind, and the operator opted into it separately).
+*/
+function episodeEdge(previous, next) {
+	const nextOpen = require_dist.isAlertEpisodeOpen(next.status);
+	const continues = previous !== null && require_dist.isAlertEpisodeOpen(previous.status) && previous.episodeId === next.episodeId;
+	if (nextOpen) {
+		if (!require_dist.isAlertEpisodeSeverity(next.severity)) return null;
+		if (!continues || previous === null) return "raised";
+		if (!require_dist.isAlertEpisodeSeverity(previous.severity)) return "raised";
+		return previous.severity === "error" && next.severity === "critical" ? "raised" : null;
+	}
+	if (previous !== null && require_dist.isAlertEpisodeOpen(previous.status) && require_dist.isAlertEpisodeSeverity(previous.severity)) return "resolved";
+	return null;
 }
 //#endregion
 //#region src/builtins/alerts/emit-alert-policy.ts
@@ -118,24 +54,9 @@ function episodeKeyFromMetadata(metadata) {
 	const key = metadata?.["episodeKey"];
 	return typeof key === "string" ? key : void 0;
 }
-/** Completed episodes start fresh — prior push must not suppress the next digest. */
-function shouldDropPriorPush(existingStatus) {
-	return existingStatus === "completed";
-}
-function alertWithRetainedPush(toStore, existingPush, existingStatus) {
-	if (existingPush === void 0 || shouldDropPriorPush(existingStatus)) return toStore;
-	return {
-		...toStore,
-		metadata: {
-			...toStore.metadata,
-			push: existingPush
-		}
-	};
-}
 /**
-* Re-emit of the same alert id: preserve read when the episode is unchanged
-* and still active. A completed episode starts again. Queue a critical push
-* only for active, unread critical findings.
+* Re-emit of the same alert id: preserve `read` when the episode is unchanged
+* and still active. A completed episode starts again.
 */
 function mergeEmitAlert(input) {
 	const incomingKey = episodeKeyFromMetadata(input.incoming.metadata);
@@ -144,26 +65,11 @@ function mergeEmitAlert(input) {
 		const sameEpisode = incomingKey === void 0 || incomingKey === existingKey;
 		const priorCompleted = input.existing.status === "completed";
 		if (sameEpisode && !priorCompleted) return {
-			alert: {
-				...input.incoming,
-				read: true
-			},
-			queuePush: false
+			...input.incoming,
+			read: true
 		};
 	}
-	const queuePush = isCriticalPush(input.incoming) && input.incoming.status === "active" && input.incoming.read === false;
-	return {
-		alert: input.incoming,
-		queuePush
-	};
-}
-function criticalPushPayload(alert) {
-	const key = episodeKeyFromMetadata(alert.metadata) ?? alert.id;
-	const pushLine = alert.metadata?.["pushLine"];
-	return {
-		key,
-		line: typeof pushLine === "string" ? pushLine : alert.title
-	};
+	return input.incoming;
 }
 //#endregion
 //#region src/builtins/alerts/device-label.ts
@@ -297,12 +203,12 @@ function renderRunnerAlert(record) {
 	const where = record.nodeId === "hub" ? record.runnerId : `${record.runnerId} on ${record.nodeId}`;
 	switch (record.state) {
 		case "refused": return {
-			severity: "error",
+			severity: "critical",
 			title: "Addon refused to start",
 			message: `${where}: refused - ${record.reason ?? "no reason reported"}${record.remedy !== void 0 ? ` ${record.remedy}` : ""}`
 		};
 		case "failed": return {
-			severity: "error",
+			severity: "critical",
 			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`
 		};
@@ -313,32 +219,6 @@ function renderRunnerAlert(record) {
 		};
 	}
 }
-/** 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/record-kinds.ts
 var import_read_all_rows = require_read_all_rows$1.require_read_all_rows();
@@ -646,7 +526,6 @@ var CATEGORY_MAPPINGS = {
 * {@link CATEGORY_MAPPINGS}.
 */
 var SILENT_TRACKED_CATEGORIES = [
-	"addon.started",
 	"process.state-changed",
 	"addon.load-recovered",
 	"system.liveness-recovered",
@@ -715,24 +594,26 @@ function parseAlert(record) {
 }
 var DEFAULT_CONFIG = {
 	maxAlerts: 500,
-	retentionDays: 30,
-	criticalPushEnabled: true,
-	criticalPushTargetIds: []
+	retentionDays: 30
 };
-/** Accept the live `string[]` shape and the pre-multiselect CSV string. */
-function normalizeCriticalPushTargetIds(raw) {
-	if (Array.isArray(raw)) return raw.filter((id) => typeof id === "string" && id.trim().length > 0).map((id) => id.trim());
-	if (typeof raw === "string" && raw.trim().length > 0) return raw.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
-	return [];
-}
-/** 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 EVENT_SOURCE = {
 	type: "addon",
 	id: "alert-center"
 };
+/** Where the operator acts on a runner that failed, was refused or is missing. */
+var ADDONS_PAGE_ACTION = {
+	label: "Open Addons",
+	href: "/system/addons"
+};
+function episodeViewOf(alert) {
+	const key = episodeKeyFromMetadata(alert.metadata);
+	return {
+		status: alert.status,
+		severity: alert.severity,
+		episodeId: require_dist.alertEpisodeId(alert),
+		...key !== void 0 ? { episodeKey: key } : {}
+	};
+}
 /**
 * Alert Center addon — core builtin that persists alerts in a
 * structured SQLite table and serves them to the admin UI.
@@ -751,11 +632,8 @@ function toPrunable(record) {
 var AlertCenterAddon = class extends require_dist.BaseAddon {
 	alertStore = null;
 	unsubscribers = [];
-	/** How long a burst of critical findings is gathered into one digest push. */
-	pushCoalesceMs;
-	constructor(options) {
+	constructor() {
 		super({ ...DEFAULT_CONFIG });
-		this.pushCoalesceMs = options?.pushCoalesceMs ?? PUSH_COALESCE_MS;
 	}
 	/**
 	* Per `(category, source.id)` counter used to rate-limit chatty
@@ -786,9 +664,7 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 			unsubs.push(unsub);
 		}
 		this.unsubscribers = unsubs;
-		this.reconcilePendingPushes();
 		this.dismissLegacyStreamCards(void 0);
-		this.migrateCriticalPushTargetIds();
 		this.ctx.logger.info("Initialized", { meta: { trackedCategoriesCount: TRACKED_CATEGORIES.length } });
 		return [{
 			capability: require_dist.alertsCapability,
@@ -807,46 +683,29 @@ var AlertCenterAddon = class extends require_dist.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
-				}),
-				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. This path does not use notification rules.",
-					default: true
-				}),
-				this.field({
-					type: "notification-target-multiselect",
-					key: "criticalPushTargetIds",
-					label: "Critical push targets",
-					description: "Notifier targets that receive critical system alerts. Empty = every enabled shared (not personal) target.",
-					default: []
-				})
-			]
+			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
+			})]
 		}] });
 	}
 	async listAlerts(filter) {
@@ -885,7 +744,17 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 			updatedAt: Date.now()
 		});
 	}
-	async handleEvent(category, event) {
+	/**
+	* Events are handled one at a time: every handler is a read-modify-write of
+	* an alert, and two concurrent events about one runner would both read "no
+	* alert yet" and open two episodes for it.
+	*/
+	eventChain = Promise.resolve();
+	handleEvent(category, event) {
+		this.eventChain = this.eventChain.then(() => this.processEvent(category, event));
+		return this.eventChain;
+	}
+	async processEvent(category, event) {
 		try {
 			if (category === "model.download.progress") {
 				await this.handleModelDownload(event);
@@ -903,11 +772,6 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 				await this.handleRunnerCheck(event);
 				return;
 			}
-			if (category === require_dist.EventCategory.AddonStarted) {
-				const addonId = event.data["addonId"];
-				if (typeof addonId === "string" && PUSH_RECONCILE_ADDONS.has(addonId)) await this.reconcilePendingPushes();
-				return;
-			}
 			if (category === require_dist.EventCategory.AddonLoadFailed) {
 				await this.handleAddonLoadFailed(event);
 				return;
@@ -1008,11 +872,8 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 				type: "runner",
 				id: record.runnerId
 			},
-			metadata: {
-				runner: record,
-				pushLine: runnerPushLine(record),
-				...existing?.push !== void 0 ? { push: existing.push } : {}
-			}
+			action: ADDONS_PAGE_ACTION,
+			metadata: { runner: record }
 		};
 		await this.persistAlert(alert);
 		if (previous === null) this.emitAlertCreatedEvent(alert);
@@ -1021,17 +882,11 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 			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.
+	* later failure opens a NEW episode, instead of folding into a stale
+	* `refused` record whose notification was already sent.
 	*/
 	async handleRunnerStateChanged(event) {
 		if (event.data["state"] !== "running") return;
@@ -1057,24 +912,20 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 		}) : [];
 		const failedIds = ids(event.data["failed"]);
 		const missingIds = ids(event.data["missing"]);
-		const pushLine = `${nodeId}: runners degraded - ${[
+		const parts = [
 			...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",
+			severity: "critical",
 			title: "Runners degraded",
-			message: `${nodeId}: ${summary}`,
+			message: `${nodeId}: ${summary}${parts.length > 0 ? ` (${parts.join("; ")})` : ""}`,
+			action: ADDONS_PAGE_ACTION,
 			status: "active",
 			read: false,
 			createdAt: existing?.createdAt ?? now,
@@ -1087,19 +938,11 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 				nodeId,
 				failed: event.data["failed"],
 				refused: event.data["refused"],
-				missing: event.data["missing"],
-				pushLine,
-				...existing?.push !== void 0 ? { push: existing.push } : {}
+				missing: event.data["missing"]
 			}
 		};
 		await this.persistAlert(alert);
 		this.emitAlertCreatedEvent(alert);
-		this.queuePush({
-			alertId,
-			key: pushKey,
-			title: alert.title,
-			line: pushLine
-		});
 	}
 	async readAlertRaw(alertId) {
 		const store = this.alertStore;
@@ -1108,155 +951,19 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 		if (raw === null) 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;
 		const metadata = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : void 0;
+		const parsed = require_dist.AlertSchema.safeParse({
+			id: alertId,
+			...rec
+		});
 		return {
 			...typeof rec["createdAt"] === "number" ? { createdAt: rec["createdAt"] } : {},
 			...typeof rec["read"] === "boolean" ? { read: rec["read"] } : {},
 			...typeof rec["status"] === "string" ? { status: rec["status"] } : {},
-			...isPushState(push) ? { push } : {},
-			...episodeKeyFromMetadata(metadata) !== void 0 ? { episodeKey: episodeKeyFromMetadata(metadata) } : {}
-		};
-	}
-	/** 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: normalizeCriticalPushTargetIds(this.config.criticalPushTargetIds)
-		};
-	}
-	/** Rewrite a legacy CSV `criticalPushTargetIds` string into `string[]`. */
-	async migrateCriticalPushTargetIds() {
-		const raw = this.config.criticalPushTargetIds;
-		if (typeof raw !== "string") return;
-		try {
-			await this.updateGlobalSettings({ criticalPushTargetIds: normalizeCriticalPushTargetIds(raw) });
-		} catch (err) {
-			this.ctx.logger.warn("criticalPushTargetIds CSV migration failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		}
-	}
-	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
-				}
-			})
+			...episodeKeyFromMetadata(metadata) !== void 0 ? { episodeKey: episodeKeyFromMetadata(metadata) } : {},
+			...parsed.success ? { episode: episodeViewOf(parsed.data) } : {}
 		};
 	}
-	/**
-	* 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: require_dist.errMsg(err) } });
-			}
-		});
-		return this.pushChain;
-	}
-	async storePushState(alertId, push) {
-		const store = this.alertStore;
-		if (store === null) return;
-		const raw = await store.getData(alertId);
-		if (raw === null) return;
-		const meta = raw["metadata"];
-		const metadata = typeof meta === "object" && meta !== null && !Array.isArray(meta) ? meta : {};
-		await store.mergeUpdate(alertId, { 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 store = this.alertStore;
-		if (store === null) return;
-		try {
-			const rows = await store.listRecent(500);
-			for (const row of rows) {
-				const parsed = require_dist.AlertSchema.safeParse({
-					id: row.id,
-					...row.data
-				});
-				if (!parsed.success || parsed.data.status !== "active") continue;
-				if (!isCriticalPush(parsed.data)) 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: require_dist.errMsg(err) } });
-		}
-	}
 	async handleModelDownload(event) {
 		const data = event.data;
 		const modelId = data.modelId ?? "unknown";
@@ -1589,7 +1296,7 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 	}
 	async emitAlert(alert) {
 		const existingRaw = await this.readAlertRaw(alert.id);
-		const { alert: toStore, queuePush } = mergeEmitAlert({
+		const toStore = mergeEmitAlert({
 			existing: existingRaw === null ? null : {
 				read: existingRaw.read,
 				episodeKey: existingRaw.episodeKey,
@@ -1597,20 +1304,10 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 			},
 			incoming: alert
 		});
-		const stored = alertWithRetainedPush(toStore, existingRaw?.push, existingRaw?.status);
 		const isNew = existingRaw === null;
-		await this.persistAlert(stored);
+		const stored = await this.persistAlert(toStore);
 		if (isNew) this.emitAlertCreatedEvent(stored);
 		else this.emitAlertUpdatedEvent(alert.id, stored);
-		if (queuePush) {
-			const { key, line } = criticalPushPayload(stored);
-			this.queuePush({
-				alertId: stored.id,
-				key,
-				title: stored.title,
-				line
-			});
-		}
 		await this.enforceMaxAlerts();
 		await this.enforceRetention();
 	}
@@ -1625,15 +1322,73 @@ var AlertCenterAddon = class extends require_dist.BaseAddon {
 	* Read-merge-write: SettingsBackend.update() replaces the entire `data` blob,
 	* so we must read the existing record, merge the patch, and write back.
 	*/
-	async mergeUpdate(id, patch) {
+	/** Alert writes (stamp + store + announce) from any caller, one at a time. */
+	writeChain = Promise.resolve();
+	serializedWrite(write) {
+		const run = this.writeChain.then(write, write);
+		this.writeChain = run.catch(() => void 0);
+		return run;
+	}
+	mergeUpdate(id, patch) {
+		return this.serializedWrite(() => this.mergeUpdateNow(id, patch));
+	}
+	async mergeUpdateNow(id, patch) {
 		const store = this.alertStore;
 		if (store === null) return;
-		await store.mergeUpdate(id, patch);
+		const previous = (await this.readAlertRaw(id))?.episode ?? null;
+		const metadata = patch["metadata"];
+		const keepEpisode = previous !== null && typeof metadata === "object" && metadata !== null ? { metadata: {
+			...metadata,
+			episodeId: previous.episodeId
+		} } : {};
+		await store.mergeUpdate(id, {
+			...patch,
+			...keepEpisode
+		});
+		const after = await store.getData(id);
+		const parsed = after === null ? null : require_dist.AlertSchema.safeParse({
+			id,
+			...after
+		});
+		if (parsed?.success === true) this.announceEpisode(previous, parsed.data);
 	}
-	async persistAlert(alert) {
+	/**
+	* Store an alert, stamping its episode identity. The stored alert is what a
+	* caller must use afterwards, and the opening or closing of a critical/error
+	* episode is announced here, in the one place every write passes through.
+	*/
+	persistAlert(alert) {
+		return this.serializedWrite(() => this.persistAlertNow(alert));
+	}
+	async persistAlertNow(alert) {
 		const store = this.alertStore;
-		if (store === null) return;
-		await store.persist(alert);
+		if (store === null) return alert;
+		const previous = (await this.readAlertRaw(alert.id))?.episode ?? null;
+		const episodeId = nextEpisodeId({
+			alertId: alert.id,
+			previous,
+			incomingKey: episodeKeyFromMetadata(alert.metadata),
+			now: Date.now()
+		});
+		const stamped = {
+			...alert,
+			metadata: {
+				...alert.metadata,
+				episodeId
+			}
+		};
+		await store.persist(stamped);
+		this.announceEpisode(previous, stamped);
+		return stamped;
+	}
+	/**
+	* Announce an episode edge on the bus. Telemetry, and it may be dropped
+	* (D8): Notification Center reconciles from the alerts store (D11, D49).
+	*/
+	announceEpisode(previous, alert) {
+		const edge = episodeEdge(previous, episodeViewOf(alert));
+		if (edge === null) return;
+		this.ctx.eventBus?.emit(require_dist.createEvent(require_dist.EventCategory.AlertEpisode, EVENT_SOURCE, require_dist.alertEpisodePayload(alert, edge, Date.now())));
 	}
 	emitAlertCreatedEvent(alert) {
 		this.ctx.eventBus?.emit(require_dist.createEvent("alert.created", EVENT_SOURCE, {