@camstack/addon-post-analysis 1.2.284 → 1.2.285

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Bpx5JMso.js");
+const require_dist = require("../dist-ITESpHou.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -4104,7 +4104,7 @@ function mimeFromExtension(file) {
 * A value that is negative, NaN or absent falls back to the shipped default:
 * an unreadable window must not become a window nobody chose.
 */
-var DAY_MS$2 = 24 * 36e5;
+var DAY_MS$4 = 24 * 36e5;
 /**
 * The shipped windows. Each one is the value that was hardcoded before this
 * module existed, except the mosaic — see {@link PRUNE_SETTING_KEYS}.
@@ -4150,8 +4150,8 @@ var PRUNE_SETTING_KEYS = [
 */
 function windowMs(raw, defaultDays) {
 	if (raw === 0) return null;
-	if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) return defaultDays * DAY_MS$2;
-	return raw * DAY_MS$2;
+	if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) return defaultDays * DAY_MS$4;
+	return raw * DAY_MS$4;
 }
 function resolvePruneWindows(settings) {
 	return {
@@ -8262,6 +8262,19 @@ var NcAlarmLiveReadLog = class {
 };
 //#endregion
 //#region src/notification-center/alerts/alert-episode.ts
+/** The row with `detail` set (or removed). Unchanged rows are returned as is. */
+function withAlertDetail(row, detail) {
+	if (row.detail === detail) return row;
+	const { subject, alerting, since, lastNotifiedAt, reminders } = row;
+	return {
+		subject,
+		alerting,
+		since,
+		lastNotifiedAt,
+		reminders,
+		...detail !== void 0 ? { detail } : {}
+	};
+}
 function decideAlert(input) {
 	const previous = input.previous;
 	if (previous === void 0) return input.alerting ? { kind: "raise" } : { kind: "seeded" };
@@ -8405,6 +8418,12 @@ var NC_ALERTS_COLUMNS = [
 	{
 		name: "deviceId",
 		type: "INTEGER"
+	}),
+	(
+	/** What the open episode is — a tank's band (D647 review M6). Nullable, added in place. */
+	{
+		name: "detail",
+		type: "TEXT"
 	})
 ];
 var NC_ALERTS_INDEXES = [{
@@ -8427,7 +8446,8 @@ var NC_ALERTS_SPEC = {
 		since: row.since,
 		lastNotifiedAt: row.lastNotifiedAt,
 		reminders: row.reminders,
-		...deviceIdOf(row.subject) !== void 0 ? { deviceId: deviceIdOf(row.subject) } : {}
+		...deviceIdOf(row.subject) !== void 0 ? { deviceId: deviceIdOf(row.subject) } : {},
+		...row.detail !== void 0 ? { detail: row.detail } : {}
 	}),
 	fromRecord: (key, data) => {
 		const since = data["since"];
@@ -8436,12 +8456,14 @@ var NC_ALERTS_SPEC = {
 		if (typeof since !== "number") return null;
 		if (typeof lastNotifiedAt !== "number") return null;
 		if (typeof reminders !== "number") return null;
+		const detail = data["detail"];
 		return {
 			subject: key,
 			alerting: data["alerting"] === 1 || data["alerting"] === true,
 			since,
 			lastNotifiedAt,
-			reminders
+			reminders,
+			...typeof detail === "string" ? { detail } : {}
 		};
 	},
 	equalFact: (held, incoming) => held.alerting === incoming.alerting,
@@ -8474,7 +8496,8 @@ var NcAlertStore = class {
 				this.ledger.put(row).catch(() => void 0);
 			},
 			all: () => this.ledger.snapshot(),
-			remove: (subject) => this.ledger.forget(subject)
+			remove: (subject) => this.ledger.forget(subject),
+			answered: () => this.ledger.hasAnswered()
 		};
 	}
 };
@@ -11922,6 +11945,80 @@ function vacuumTanksOf(data) {
 	};
 }
 //#endregion
+//#region src/notification-center/alerts/open-alert.ts
+/**
+* The raise of an episode whose reading has not arrived since the restart —
+* worded with what the row KNOWS: no invented percentage (the binary battery
+* sentence), the item key as its name, and a tank kind that only the filters
+* read (the summary words an unmeasured tank without a band).
+*/
+function unmeasuredEpisode(input) {
+	const deviceId = alertSubjectDeviceId(input.subject);
+	if (deviceId === void 0) return null;
+	const identity = input.lookup(deviceId);
+	const facts = input.facts;
+	if (input.family === "battery") return incomingFromBatteryBand({
+		facts,
+		deviceId,
+		band: "low",
+		reading: {
+			percentage: 0,
+			lastUpdated: 0,
+			binary: true
+		},
+		identity
+	});
+	const parts = parseConsumableSubject(input.subject);
+	if (input.family === "consumable" && parts !== null) return incomingFromConsumableBand({
+		facts,
+		deviceId,
+		band: "low",
+		item: {
+			key: parts.key,
+			label: parts.key,
+			level: null,
+			status: "replace"
+		},
+		thresholdPercent: parts.thresholdPercent,
+		identity
+	});
+	const tank = NC_TANK_KEYS.find((key) => input.subject === `tank:${String(deviceId)}:${key}`);
+	if (tank === void 0) return null;
+	return incomingFromTankBand({
+		facts,
+		deviceId,
+		band: input.detail === "full" ? "full" : "low",
+		tank,
+		identity
+	});
+}
+/**
+* One alerting row as an open episode, or `null` when it cannot be worded (the
+* caller logs it). A legacy consumable row is skipped: it is adopted or
+* retired first. A tank whose band the row remembers is worded by it
+* (review M6), even without a reading.
+*/
+function openAlertOf(row, input) {
+	const parts = parseConsumableSubject(row.subject);
+	if (parts?.legacy === true) return null;
+	const family = parts !== null ? "consumable" : row.subject.startsWith("tank:") ? "tank" : "battery";
+	const subject = (input.restated ?? unmeasuredEpisode({
+		subject: row.subject,
+		family,
+		facts: input.facts,
+		lookup: input.lookup,
+		...row.detail !== void 0 ? { detail: row.detail } : {}
+	}))?.subject.systemEvent;
+	if (subject === void 0) return null;
+	const measured = input.restated !== null || family === "tank" && row.detail !== void 0;
+	return {
+		family,
+		since: row.since,
+		subject,
+		measured
+	};
+}
+//#endregion
 //#region src/notification-center/alerts/battery-band.ts
 /**
 * The stand-in a provider writes for a binary NORMAL. Anything below it, on a
@@ -12129,7 +12226,7 @@ var NcDeviceAlerts = class {
 			band: alerting ? band : "normal",
 			tank: tank.key,
 			identity: this.deps.lookup(deviceId)
-		}));
+		}), band === "normal" ? void 0 : band);
 	}
 	/**
 	* Has this tank band held long enough to move its episode? A band that
@@ -12247,6 +12344,37 @@ var NcDeviceAlerts = class {
 		}
 	}
 	/**
+	* Every OPEN episode, restated (D647). `null` while the rows have not been
+	* read. A legacy consumable row is skipped (it is adopted or retired first),
+	* and so is a tank whose band is unknown and whose device the summary could
+	* not word — never silently: each skip is a line.
+	*/
+	openEpisodes() {
+		if (this.deps.rows.answered?.() === false) return null;
+		const facts = {
+			eventId: "state-summary",
+			timestamp: this.now(),
+			category: "state-summary",
+			data: {}
+		};
+		const out = [];
+		for (const row of this.deps.rows.all()) {
+			if (!row.alerting) continue;
+			const restated = this.restatementOf(row.subject);
+			const open = openAlertOf(row, {
+				facts,
+				restated: restated === null ? null : restated(facts),
+				lookup: this.deps.lookup
+			});
+			if (open !== null) out.push(open);
+			else this.logger()?.debug("open alert left out of the state summary — it cannot be worded", {
+				...tagsOf(row.subject),
+				meta: { subject: row.subject }
+			});
+		}
+		return out;
+	}
+	/**
 	* Every device that holds an alert row — what the deleted-device reconcile
 	* must look at besides the devices a rule names (a battery device no rule
 	* names still has a row).
@@ -12388,7 +12516,7 @@ var NcDeviceAlerts = class {
 	* a state we never recorded leaving is a state we can never announce
 	* entering again.
 	*/
-	apply(subject, alerting, settings, build) {
+	apply(subject, alerting, settings, build, detail) {
 		const nowMs = this.now();
 		const previous = this.deps.rows.get(subject);
 		const verdict = decideAlert({
@@ -12398,7 +12526,7 @@ var NcDeviceAlerts = class {
 			renotifyMs: settings.renotifyMinutes * 6e4,
 			notifyRecovery: settings.notifyRecovery
 		});
-		const next = nextAlertRow(subject, previous, alerting, verdict, nowMs);
+		const next = withAlertDetail(nextAlertRow(subject, previous, alerting, verdict, nowMs), alerting ? detail ?? previous?.detail : void 0);
 		if (next !== previous) this.deps.rows.put(next);
 		if (!speaks(verdict)) {
 			this.report(subject, verdict, alerting);
@@ -13033,7 +13161,31 @@ var en_default = {
 	},
 	"summary.body.detections": "{{detectionSummary}}",
 	"summary.body.truncated": "showing the {{shown}} most relevant of {{total}}",
-	"summary.body.empty": "nothing was seen in this window"
+	"summary.body.empty": "nothing was seen in this window",
+	"system.state-summary.title": "{{rule}}",
+	"system.state-summary.body": "{{summaryText}}",
+	"summary.section.device-state": "Devices offline or switched off",
+	"summary.section.streams": "Streams offline",
+	"summary.section.battery": "Low batteries",
+	"summary.section.consumables": "Consumables to replace",
+	"summary.section.tanks": "Tanks",
+	"summary.section.detection-blind": "Cameras detecting nothing",
+	"summary.section.nodes": "Nodes",
+	"summary.section.addons": "Addons",
+	"summary.section.updates": "Server and container updates",
+	"summary.section.unavailable": "{{section}}: unavailable — the state could not be read",
+	"summary.line.device-offline": "{{deviceName}} — offline (since {{since}})",
+	"summary.line.device-disabled": "{{deviceName}} — switched off (since {{since}})",
+	"summary.line.stream-offline": "{{deviceName}} — stream offline (since {{since}})",
+	"summary.line.stream-offline.profiled": "{{deviceName}} — {{profile}} stream offline (since {{since}})",
+	"summary.line.detection-blind": "{{deviceName}} — detecting nothing (since {{since}})",
+	"summary.line.node-offline": "{{nodeId}} — offline (since {{since}})",
+	"summary.line.node-inference-unavailable": "{{nodeId}} — cannot run inference (since {{since}})",
+	"summary.line.addon-crash-loop": "{{nodeId}} — {{addons}} stopped after repeated crashes (since {{since}})",
+	"summary.line.update": "{{packageName}} {{currentVersion}} → {{latestVersion}}",
+	"summary.line.update.onNode": "{{packageName}} {{currentVersion}} → {{latestVersion}} on {{nodeId}}",
+	"summary.line.wrapper-update": "Container {{currentVersion}} → {{latestVersion}}",
+	"summary.line.tank-unread": "{{deviceName}} — the {{tank}} tank needs attention"
 };
 //#endregion
 //#region src/notification-center/texts/it.json
@@ -13337,7 +13489,31 @@ var it_default = {
 	},
 	"summary.body.detections": "{{detectionSummary}}",
 	"summary.body.truncated": "mostrati i {{shown}} più rilevanti su {{total}}",
-	"summary.body.empty": "nessun evento in questa finestra"
+	"summary.body.empty": "nessun evento in questa finestra",
+	"system.state-summary.title": "{{rule}}",
+	"system.state-summary.body": "{{summaryText}}",
+	"summary.section.device-state": "Dispositivi offline o spenti",
+	"summary.section.streams": "Stream offline",
+	"summary.section.battery": "Batterie scariche",
+	"summary.section.consumables": "Consumabili da sostituire",
+	"summary.section.tanks": "Serbatoi",
+	"summary.section.detection-blind": "Camere che non rilevano nulla",
+	"summary.section.nodes": "Nodi",
+	"summary.section.addons": "Addon",
+	"summary.section.updates": "Aggiornamenti di server e container",
+	"summary.section.unavailable": "{{section}}: non disponibile — lo stato non è leggibile",
+	"summary.line.device-offline": "{{deviceName}} — offline (da {{since}})",
+	"summary.line.device-disabled": "{{deviceName}} — spento (da {{since}})",
+	"summary.line.stream-offline": "{{deviceName}} — stream offline (da {{since}})",
+	"summary.line.stream-offline.profiled": "{{deviceName}} — stream {{profile}} offline (da {{since}})",
+	"summary.line.detection-blind": "{{deviceName}} — non rileva nulla (da {{since}})",
+	"summary.line.node-offline": "{{nodeId}} — offline (da {{since}})",
+	"summary.line.node-inference-unavailable": "{{nodeId}} — non può eseguire l'inferenza (da {{since}})",
+	"summary.line.addon-crash-loop": "{{nodeId}} — {{addons}} fermati dopo crash ripetuti (da {{since}})",
+	"summary.line.update": "{{packageName}} {{currentVersion}} → {{latestVersion}}",
+	"summary.line.update.onNode": "{{packageName}} {{currentVersion}} → {{latestVersion}} su {{nodeId}}",
+	"summary.line.wrapper-update": "Container {{currentVersion}} → {{latestVersion}}",
+	"summary.line.tank-unread": "{{deviceName}} — il serbatoio {{tank}} richiede attenzione"
 };
 //#endregion
 //#region src/notification-center/text-catalog.ts
@@ -13755,7 +13931,7 @@ function assertPatchKeepsFamily(existing, patch) {
 * the offending kind or filter). Then rethrow. A refused save is dropped work,
 * and dropped work is never silent. Any other error passes through unlogged.
 */
-function logRefusal$2(check, ctx) {
+function logRefusal$3(check, ctx) {
 	try {
 		check();
 	} catch (err) {
@@ -13771,11 +13947,11 @@ function logRefusal$2(check, ctx) {
 }
 /** {@link assertRuleFamily}, logged. The create path of both routes. */
 function guardRuleFamily(rule, ctx) {
-	logRefusal$2(() => assertRuleFamily(rule), ctx);
+	logRefusal$3(() => assertRuleFamily(rule), ctx);
 }
 /** {@link assertPatchKeepsFamily}, logged. The update path of both routes. */
 function guardPatchFamily(existing, patch, ctx) {
-	logRefusal$2(() => assertPatchKeepsFamily(existing, patch), ctx);
+	logRefusal$3(() => assertPatchKeepsFamily(existing, patch), ctx);
 }
 //#endregion
 //#region src/notification-center/device-scope-guard.ts
@@ -13800,7 +13976,7 @@ function assertDevicesExcludeDelivery(rule) {
 	throw new NcDevicesExcludeRefusal(rule.delivery, excluded);
 }
 /** Run the check; a refusal is dropped work, so it is logged before it is rethrown. */
-function logRefusal$1(check, ctx) {
+function logRefusal$2(check, ctx) {
 	try {
 		check();
 	} catch (err) {
@@ -13818,7 +13994,7 @@ function warnRefusal$1(logger, err, ctx) {
 }
 /** The create path of both routes. */
 function guardRuleDevicesExclude(rule, ctx) {
-	logRefusal$1(() => assertDevicesExcludeDelivery(rule), ctx);
+	logRefusal$2(() => assertDevicesExcludeDelivery(rule), ctx);
 }
 /**
 * The update path of both routes: the MERGED rule is judged, and only when the
@@ -13828,7 +14004,86 @@ function guardPatchDevicesExclude(existing, patch, ctx) {
 	if (existing === null) return;
 	const merged = mergedFamilySubject(existing, patch);
 	if (merged === null) return;
-	logRefusal$1(() => assertDevicesExcludeDelivery(merged), ctx);
+	logRefusal$2(() => assertDevicesExcludeDelivery(merged), ctx);
+}
+//#endregion
+//#region src/notification-center/rule-summary-guard.ts
+/**
+* The hub's half of D647: `systemEventDelivery: { mode: 'summary' }` belongs to
+* a `device-events` or `system` rule, and nowhere else — the alarm stays
+* instant. Refused, loudly, on both save routes (the cap provider and the
+* `nc.*Rule` bridge), beside the D637 family guard.
+*
+* The rule is judged by `systemEventDeliveryProblems` (`@camstack/types`), the
+* one statement both editors read too. On an update it is the MERGED rule —
+* merged the way the store merges it, `clear` included — and only when the
+* patch changes something the verdict reads: a rename of a stored rule is
+* never refused for what it already was.
+*
+* Not in Zod, for the reason `rule-family-guard.ts` gives: a cross-field refine
+* would also run when the store LOADS a rule.
+*/
+var NcSystemEventDeliveryRefusal = class extends Error {
+	problems;
+	constructor(problems) {
+		super(`rule refused: ${problems.map(require_dist.describeSystemEventDeliveryProblem).join("; ")}`);
+		this.name = "NcSystemEventDeliveryRefusal";
+		this.problems = problems;
+	}
+};
+function assertSystemEventDelivery(rule) {
+	const problems = require_dist.systemEventDeliveryProblems(rule);
+	if (problems.length > 0) throw new NcSystemEventDeliveryRefusal(problems);
+}
+var JUDGED_KEYS = [
+	"delivery",
+	"conditions",
+	"systemEventDelivery",
+	"schedule",
+	"actions"
+];
+/**
+* The rule the patch WOULD produce, or `null` when it changes nothing the
+* verdict reads. `clear` removes `schedule` / `actions` before the merge, as
+* the store does.
+*/
+function mergedDeliverySubject(existing, patch, clear) {
+	const merged = {
+		delivery: existing.delivery,
+		conditions: existing.conditions,
+		...existing.systemEventDelivery !== void 0 ? { systemEventDelivery: existing.systemEventDelivery } : {},
+		...existing.schedule !== void 0 && !clear.includes("schedule") ? { schedule: existing.schedule } : {},
+		...existing.actions !== void 0 && !clear.includes("actions") ? { actions: existing.actions } : {},
+		...patch.delivery !== void 0 ? { delivery: patch.delivery } : {},
+		...patch.conditions !== void 0 ? { conditions: patch.conditions } : {},
+		...patch.systemEventDelivery !== void 0 ? { systemEventDelivery: patch.systemEventDelivery } : {},
+		...patch.schedule !== void 0 ? { schedule: patch.schedule } : {},
+		...patch.actions !== void 0 ? { actions: patch.actions } : {}
+	};
+	return JUDGED_KEYS.some((key) => require_dist.canonicalHash(merged[key] ?? null) !== require_dist.canonicalHash(existing[key] ?? null)) ? merged : null;
+}
+function logRefusal$1(check, ctx) {
+	try {
+		check();
+	} catch (err) {
+		if (err instanceof NcSystemEventDeliveryRefusal) ctx.logger.warn("nc rule refused: summary delivery not allowed here", { meta: {
+			...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
+			by: ctx.by,
+			problems: err.problems.map(require_dist.describeSystemEventDeliveryProblem)
+		} });
+		throw err;
+	}
+}
+/** The create path of both routes. */
+function guardRuleSystemEventDelivery(rule, ctx) {
+	logRefusal$1(() => assertSystemEventDelivery(rule), ctx);
+}
+/** The update path of both routes: the MERGED rule, when the patch changes what is judged. */
+function guardPatchSystemEventDelivery(existing, patch, clear, ctx) {
+	if (existing === null) return;
+	const merged = mergedDeliverySubject(existing, patch, clear);
+	if (merged === null) return;
+	logRefusal$1(() => assertSystemEventDelivery(merged), ctx);
 }
 //#endregion
 //#region src/notification-center/sensor-transition-guard.ts
@@ -16636,6 +16891,10 @@ function makeNcActionHandlers(deps) {
 				logger: deps.logger,
 				by: c.userId
 			});
+			guardRuleSystemEventDelivery(parsed, {
+				logger: deps.logger,
+				by: c.userId
+			});
 			await assertTargetsOwned(parsed.targets.map((t) => t.targetId), c);
 			const rule = await deps.ruleStore.create({
 				...parsed,
@@ -16669,6 +16928,11 @@ function makeNcActionHandlers(deps) {
 				by: c.userId,
 				ruleId: input.ruleId
 			});
+			guardPatchSystemEventDelivery(existing, patch, clear, {
+				logger: deps.logger,
+				by: c.userId,
+				ruleId: input.ruleId
+			});
 			if (patch.targets !== void 0) await assertTargetsOwned(patch.targets.map((t) => t.targetId), c);
 			const { ownerUserId: _owner, disabledTargetIds: _optOut, ...safe } = patch;
 			const rule = await deps.ruleStore.update(input.ruleId, safe, clear);
@@ -17094,6 +17358,87 @@ function makeNcActionHandlers(deps) {
 	};
 }
 //#endregion
+//#region src/notification-center/state-summary/state-summary-delivery.ts
+/**
+* A state summary as an ORDINARY system-event subject (D647), so it reaches the
+* phone the way every system rule does: `buildEntries` → the durable outbox →
+* the drain's snooze gate, retries and per-target history → the dispatcher,
+* which renders the rule's own template with the summary's variables.
+*
+* - `recordId` is `state-summary:<ruleId>:<windowEndMs>` — the outbox dedup
+*   key, so a restart can never enqueue one window twice.
+* - The row files under the system device (0): a summary spans devices.
+*   `targetUsers` therefore reach admins only — a user whose grant is
+*   narrower than the whole installation must not be sent the names of
+*   devices they cannot open.
+* - The words are FROZEN at enqueue (`textParams`), like the digest's: the
+*   state is the state at the window's end, not at a retry hours later. The
+*   LANGUAGE is frozen with them.
+* - `kind` is the rule's first kind: the history row needs one, and no kind
+*   is "the" event of a summary — `data.stateSummary` says what the row is,
+*   and `{{eventKind}}` renders empty on it.
+*/
+var NC_STATE_SUMMARY_TITLE_KEY = "system.state-summary.title";
+var NC_STATE_SUMMARY_BODY_KEY = "system.state-summary.body";
+function stateSummaryRecordId(ruleId, windowEndMs) {
+	return `state-summary:${ruleId}:${String(windowEndMs)}`;
+}
+/** Is this system-event data the data of a state-summary row? */
+function isStateSummaryData(data) {
+	return data["stateSummary"] === true;
+}
+/** `null` when the rule has no system-event condition (the guard refuses that). */
+function stateSummarySubject(input) {
+	const kind = input.rule.conditions.systemEvent?.kinds[0];
+	if (kind === void 0) return null;
+	return {
+		kind: "system-event",
+		recordId: stateSummaryRecordId(input.rule.id, input.window.endMs),
+		deviceId: 0,
+		timestamp: input.window.endMs,
+		classNames: [],
+		zones: [],
+		systemEvent: {
+			kind,
+			subject: `state-summary:${input.rule.id}`,
+			titleKey: NC_STATE_SUMMARY_TITLE_KEY,
+			bodyKey: NC_STATE_SUMMARY_BODY_KEY,
+			textParams: {
+				summaryText: input.text.text,
+				summaryCount: String(input.text.count),
+				...input.text.sectionVars
+			},
+			textCount: input.text.count,
+			data: {
+				stateSummary: true,
+				windowStartMs: input.window.startMs,
+				windowEndMs: input.window.endMs,
+				sections: input.summary.sections.map((section) => ({
+					id: section.id,
+					status: section.status,
+					items: section.items.length
+				}))
+			}
+		}
+	};
+}
+/**
+* The rule as its summary is ENQUEUED: a custom body that carries none of the
+* summary's content gets `{{summaryText}}` appended on its own line, so an
+* operator's body never sends an empty summary (review M3). `null` = unchanged.
+*/
+function withSummaryBody(rule) {
+	const body = rule.template?.body;
+	if (require_dist.templateCarriesSummary(body)) return null;
+	return {
+		...rule,
+		template: {
+			...rule.template,
+			body: `${body ?? ""}\n{{summaryText}}`
+		}
+	};
+}
+//#endregion
 //#region src/notification-center/system-event-tap-url.ts
 /** The admin UI's own routes, as `packages/addon-admin-ui/src/App.tsx` declares them. */
 var ADMIN_ADDONS_PATH = "/system/addons";
@@ -17520,6 +17865,32 @@ function selectTriggerZoneCandidates(input) {
 //#endregion
 //#region src/notification-center/dispatcher.ts
 /**
+* NcDispatcher — turns a durable outbox entry into ONE canonical
+* `notification-output.send` RPC.
+*
+* Deps are injected tRPC-shaped closures (the wiring in
+* pipeline-analytics binds them to `ctx.api` / the media store), so the
+* dispatcher is unit-testable with fakes and stays extractable.
+*
+* Responsibilities:
+*  - resolve the outbox entry's `targetId` against the live
+*    `notification-output` target catalog (TTL-cached; the send call is
+*    routed to the owning provider by the target's `addonId`);
+*  - resolve the media attachment per the rule's policy from the media
+*    store BY OWNER at SEND time — D-3 "best media AVAILABLE at the
+*    moment": the drain runs after the persist moment, so late-landing
+*    crops are picked up without ever delaying delivery;
+*  - render the `{{var}}` template (title/body) over the frozen subject;
+*  - map recognized per-target passthrough params onto canonical
+*    Notification fields (level/sound/clickUrl/ttl) — everything else is
+*    the degrade engine's job.
+*
+* Failure semantics: an UNKNOWN target (no longer in the catalog) ⇒ PERMANENT
+* failure (the outbox dead-letters the row — genuine misconfig); a globally
+* DISABLED target (operator kill-switch) ⇒ benign skip (no send, no dead row);
+* transport/backend errors ⇒ transient (retried with backoff).
+*/
+/**
 * Where the model's sentence goes.
 *
 * Three cases, and the third is the one that would otherwise be reported as a
@@ -19087,7 +19458,7 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels, timeZone) {
 		count: occupancy !== void 0 ? `${occupancy.count}` : group !== void 0 && group.members.length > 1 ? `${group.members.length}` : "",
 		capacity: occupancy !== void 0 ? `${occupancy.capacity}` : "",
 		op: occupancy !== void 0 ? ncOccupancyOp(texts, occupancy.occupied) : "",
-		eventKind: systemEvent?.kind ?? "",
+		eventKind: systemEvent === void 0 || isStateSummaryData(systemEvent.data) ? "" : systemEvent.kind,
 		node: systemEvent?.nodeId ?? "",
 		package: systemEvent?.packageName ?? "",
 		currentVersion: typeof systemEvent?.data["currentVersion"] === "string" ? systemEvent.data["currentVersion"] : "",
@@ -22108,6 +22479,10 @@ var NcLivenessLedger = class {
 	async load() {
 		return (await this.ledger.load()).length;
 	}
+	/** Has a load READ the store once? Until then the mirror is not the truth (D647 reads it). */
+	hasAnswered() {
+		return this.ledger.hasAnswered();
+	}
 	/**
 	* Boot seed from the DEVICE DIRECTORY — the second half of the reseed, and
 	* the fix for the outage this ledger used to swallow.
@@ -28434,6 +28809,1328 @@ var AddonUpdateCoalescer = class {
 	}
 };
 //#endregion
+//#region src/notification-center/state-summary/state-sources.ts
+/**
+* Where each section of a STATE SUMMARY reads its state (D647) — the same
+* mirrors the instant raises read, and nothing else:
+*
+* | section | mirror |
+* | --- | --- |
+* | battery, consumables, tanks | the open alert episodes (`NcDeviceAlerts`, durable rows) |
+* | device-state | the liveness ledger (offline) + the system-state ledger (switched off) |
+* | streams, detection-blind, addons, updates | the system-state ledger |
+* | nodes | the liveness ledger (offline) + the system-state ledger (cannot infer) |
+*
+* Every source is RAM. A source that has not answered (its durable store never
+* read) makes the section UNAVAILABLE — never empty (D49/D315).
+*
+* A device offline for less than the liveness hold-off is left out: the instant
+* path would not have announced it yet either, and a summary must not report a
+* blip the rule itself would have stayed silent about.
+*/
+var UNREAD_ALERTS = "the battery / consumable ledger has not been read yet";
+var UNREAD_LIVENESS = "the liveness ledger has not been read yet";
+var UNREAD_STATE = "the system-state ledger has not been read yet";
+var UNREAD_DEVICES = "the device directory has not answered yet";
+var UNREAD_NODES = "the node directory did not answer completely";
+/** Sections whose items name a node: the node directory must have answered. */
+var NODE_SECTIONS = [
+	"nodes",
+	"addons",
+	"updates"
+];
+function deviceParams(deviceId, identity) {
+	const name = identity?.name ?? "";
+	return {
+		deviceId: String(deviceId),
+		deviceName: name.length > 0 ? name : String(deviceId)
+	};
+}
+function alertItem(section, open) {
+	const params = open.subject.textParams ?? {};
+	const unreadTank = open.family === "tank" && !open.measured;
+	return {
+		section,
+		subject: open.subject,
+		lineKey: unreadTank ? "summary.line.tank-unread" : open.subject.bodyKey ?? "",
+		params,
+		since: open.since
+	};
+}
+function livenessItem(row, lookup) {
+	if (row.subject.startsWith("node:")) {
+		const nodeId = row.subject.slice(5);
+		return {
+			section: "nodes",
+			subject: {
+				kind: "node-offline",
+				subject: row.subject,
+				nodeId,
+				textParams: { nodeId },
+				data: {}
+			},
+			lineKey: "summary.line.node-offline",
+			params: { nodeId },
+			since: row.updatedAt
+		};
+	}
+	if (row.deviceId === void 0) return null;
+	const identity = lookup(row.deviceId);
+	const params = deviceParams(row.deviceId, identity);
+	return {
+		section: "device-state",
+		subject: {
+			kind: "device-offline",
+			subject: row.subject,
+			deviceId: row.deviceId,
+			...identity !== void 0 ? { deviceType: identity.type } : {},
+			textParams: params,
+			data: {}
+		},
+		lineKey: "summary.line.device-offline",
+		params,
+		since: row.updatedAt
+	};
+}
+/** The section and the line of an open system-state row. */
+function stateLine(row) {
+	switch (row.kind) {
+		case "device-disabled": return {
+			section: "device-state",
+			lineKey: "summary.line.device-disabled"
+		};
+		case "stream-offline": return {
+			section: "streams",
+			lineKey: row.params["profile"] !== void 0 ? "summary.line.stream-offline.profiled" : "summary.line.stream-offline"
+		};
+		case "detection-blind": return {
+			section: "detection-blind",
+			lineKey: "summary.line.detection-blind"
+		};
+		case "node-inference-unavailable": return {
+			section: "nodes",
+			lineKey: "summary.line.node-inference-unavailable"
+		};
+		case "addon-crash-loop": return {
+			section: "addons",
+			lineKey: "summary.line.addon-crash-loop"
+		};
+		case "wrapper-update-available": return {
+			section: "updates",
+			lineKey: "summary.line.wrapper-update"
+		};
+		default: {
+			const onNode = row.params["nodeId"] !== void 0;
+			return {
+				section: row.kind === "addon-update-available" ? "addons" : "updates",
+				lineKey: onNode ? "summary.line.update.onNode" : "summary.line.update"
+			};
+		}
+	}
+}
+function stateItem(row, lookup) {
+	const identity = row.deviceId !== void 0 ? lookup(row.deviceId) : void 0;
+	const params = row.deviceId !== void 0 ? {
+		...row.params,
+		...deviceParams(row.deviceId, identity)
+	} : row.params;
+	const deviceType = identity?.type ?? row.deviceType;
+	const subject = {
+		kind: row.kind,
+		subject: row.key,
+		...row.deviceId !== void 0 ? { deviceId: row.deviceId } : {},
+		...deviceType !== void 0 ? { deviceType } : {},
+		...row.nodeId !== void 0 ? { nodeId: row.nodeId } : {},
+		...row.packageName !== void 0 ? {
+			packageName: row.packageName,
+			packageNames: [row.packageName]
+		} : {},
+		textParams: params,
+		data: {}
+	};
+	return {
+		...stateLine(row),
+		subject,
+		params,
+		since: row.since
+	};
+}
+/**
+* THE RECONCILE (D647 review I2, D8): a ledger row is a memory, never the
+* truth. A device item is listed only while the device EXISTS in the directory
+* and is not an accessory — and an "offline" one only while the device
+* manager does not call it online. A node item only while the node is known
+* to a complete node directory (a forgotten node is gone), and an "offline"
+* one only while the directory does not call it online.
+*/
+function stillTrue(item, ports) {
+	const deviceId = item.subject.deviceId;
+	if (deviceId !== void 0) {
+		const identity = ports.lookup(deviceId);
+		if (identity === void 0 || isAccessoryIdentity(identity)) return false;
+		if (item.subject.kind === "device-offline" && identity.online === true) return false;
+	}
+	const nodeId = item.subject.nodeId;
+	if (nodeId !== void 0 && ports.nodes !== null) {
+		const online = ports.nodes.online(nodeId);
+		if (online === void 0) return false;
+		if (item.subject.kind === "node-offline" && online) return false;
+	}
+	return true;
+}
+/** Why a section cannot be reconciled right now, or `null` when it can. */
+function unreconcilable(section, ports) {
+	if (NODE_SECTIONS.includes(section) && (ports.nodes === null || !ports.nodes.complete)) return UNREAD_NODES;
+	if (!NODE_SECTIONS.includes(section) && !ports.devicesAnswered()) return UNREAD_DEVICES;
+	return null;
+}
+/** The section, read and reconciled. */
+function readSection(section, ports, nowMs) {
+	const blocked = unreconcilable(section, ports);
+	if (blocked !== null) return {
+		answered: false,
+		reason: blocked
+	};
+	const read = readRaw(section, ports, nowMs);
+	if (!read.answered) return read;
+	return {
+		answered: true,
+		items: read.items.filter((item) => stillTrue(item, ports))
+	};
+}
+/** Which ports a section needs, and why each one is unavailable. */
+function readRaw(section, ports, nowMs) {
+	if (section === "battery" || section === "consumables" || section === "tanks") {
+		const alerts = ports.alerts();
+		if (alerts === null) return {
+			answered: false,
+			reason: UNREAD_ALERTS
+		};
+		const family = section === "battery" ? "battery" : section === "tanks" ? "tank" : "consumable";
+		return {
+			answered: true,
+			items: alerts.filter((open) => open.family === family).map((open) => alertItem(section, open))
+		};
+	}
+	const state = ports.state();
+	if (state === null) return {
+		answered: false,
+		reason: UNREAD_STATE
+	};
+	const items = [];
+	if (section === "device-state" || section === "nodes") {
+		const liveness = ports.liveness();
+		if (liveness === null) return {
+			answered: false,
+			reason: UNREAD_LIVENESS
+		};
+		for (const row of liveness) {
+			if (row.state !== "offline" || nowMs - row.updatedAt < ports.livenessHoldoffMs) continue;
+			const item = livenessItem(row, ports.lookup);
+			if (item !== null && item.section === section) items.push(item);
+		}
+	}
+	for (const row of state) {
+		const item = stateItem(row, ports.lookup);
+		if (item.section === section) items.push(item);
+	}
+	return {
+		answered: true,
+		items
+	};
+}
+function stateSources(ports) {
+	return { read: (section, nowMs) => readSection(section, ports, nowMs) };
+}
+//#endregion
+//#region src/notification-center/state-summary/state-model.ts
+/**
+* The STATE SUMMARY's vocabulary (D647): its sections, and what one reported
+* item is.
+*
+* A section is one of the D637 kind GROUPS (`NC_SYSTEM_EVENT_KIND_GROUP_SPECS`)
+* — the same grouping both editors list kinds under — so "the rule selected a
+* battery kind" and "the summary has a battery section" are the same fact.
+* `backups-exports` is the one group with no section: a backup or an export is
+* a job that COMPLETED, and the state it leaves behind is not a condition that
+* is still true. The ADR records why it is excluded rather than approximated.
+*/
+var NC_STATE_SUMMARY_SECTION_IDS = [
+	"device-state",
+	"streams",
+	"battery",
+	"consumables",
+	"tanks",
+	"detection-blind",
+	"nodes",
+	"addons",
+	"updates"
+];
+/** The kind groups that have no section, and why — said on the preview. */
+var NC_STATE_SUMMARY_EXCLUDED_GROUPS = { "backups-exports": "a backup or an export is a completed job, not a state that is still true" };
+/** The template variable that carries one section's lines (`template-vars.ts`). */
+var NC_STATE_SECTION_VAR = {
+	"device-state": "summaryDevices",
+	streams: "summaryStreams",
+	battery: "summaryBattery",
+	consumables: "summaryConsumables",
+	tanks: "summaryTanks",
+	"detection-blind": "summaryDetection",
+	nodes: "summaryNodes",
+	addons: "summaryAddons",
+	updates: "summaryUpdates"
+};
+/** The kinds of a section — its kind group. */
+function sectionKinds(section) {
+	return require_dist.NC_SYSTEM_EVENT_KIND_GROUP_SPECS.find((group) => group.id === section)?.kinds ?? [];
+}
+/**
+* The sections a rule reports, in section order: every section whose kind
+* group shares a kind with the rule. A rule that selected only
+* `device-battery-low` still reports the battery STATE — the state has no
+* direction, only the event did.
+*/
+function sectionsOfRule(condition) {
+	return NC_STATE_SUMMARY_SECTION_IDS.filter((section) => sectionKinds(section).some((kind) => condition.kinds.includes(kind)));
+}
+/** The kind groups the rule selected that have no section. */
+function excludedGroupsOfRule(condition) {
+	return require_dist.NC_SYSTEM_EVENT_KIND_GROUP_SPECS.filter((group) => NC_STATE_SUMMARY_EXCLUDED_GROUPS[group.id] !== void 0 && group.kinds.some((kind) => condition.kinds.includes(kind))).map((group) => group.id);
+}
+/**
+* The condition the summary judges its items with: the rule's own, with its
+* kinds widened to every kind of every section it reports — so a rule that
+* named the raise is not told "not my kind" about the state the raise left
+* behind. Every FILTER is the rule's, untouched.
+*/
+function summaryCondition(condition) {
+	const kinds = sectionsOfRule(condition).flatMap((section) => sectionKinds(section));
+	return {
+		...condition,
+		kinds: [...new Set([...condition.kinds, ...kinds])]
+	};
+}
+//#endregion
+//#region src/notification-center/state-summary/state-summary.ts
+/** Nothing to say: no item, and every section READ. Such a summary is not sent. */
+function isEmptyStateSummary(summary) {
+	return summary.itemCount === 0 && summary.unavailableCount === 0;
+}
+function collectStateSummary(input) {
+	const condition = input.rule.conditions.systemEvent;
+	if (condition === void 0) return {
+		sections: [],
+		itemCount: 0,
+		unavailableCount: 0,
+		dropped: {},
+		excludedGroups: []
+	};
+	const judge = {
+		...input.rule,
+		conditions: {
+			...input.rule.conditions,
+			systemEvent: summaryCondition(condition)
+		},
+		schedule: void 0,
+		systemEventDelivery: void 0
+	};
+	const dropped = {};
+	const drop = (reason) => {
+		dropped[reason] = (dropped[reason] ?? 0) + 1;
+	};
+	const sections = [];
+	for (const id of sectionsOfRule(condition)) {
+		const read = input.sources.read(id, input.nowMs);
+		if (!read.answered) {
+			sections.push({
+				id,
+				status: "unavailable",
+				items: [],
+				reason: read.reason
+			});
+			continue;
+		}
+		const items = read.items.filter((item) => {
+			const deviceId = item.subject.deviceId;
+			if (deviceId !== void 0 && input.isMuted(deviceId)) {
+				drop("muted");
+				return false;
+			}
+			const verdict = evaluateRule(judge, ruleSubjectOf(item, input.nowMs));
+			if (verdict.matched) return true;
+			drop(verdict.excludedBySystemEventFilter ?? verdict.failedCondition ?? "unknown");
+			return false;
+		});
+		sections.push({
+			id,
+			status: "read",
+			items: items.toSorted(bySince)
+		});
+	}
+	return {
+		sections,
+		itemCount: sections.reduce((sum, section) => sum + section.items.length, 0),
+		unavailableCount: sections.filter((section) => section.status === "unavailable").length,
+		dropped,
+		excludedGroups: excludedGroupsOfRule(condition)
+	};
+}
+function bySince(a, b) {
+	return (a.since ?? 0) - (b.since ?? 0);
+}
+function ruleSubjectOf(item, nowMs) {
+	return {
+		kind: "system-event",
+		recordId: `state:${item.subject.subject}`,
+		deviceId: item.subject.deviceId ?? 0,
+		timestamp: nowMs,
+		classNames: [],
+		zones: [],
+		systemEvent: item.subject
+	};
+}
+var DAY_MS$3 = 864e5;
+/** "07:12" when it began in the last day, "25 Sep, 07:12" before that. */
+function sinceText(texts, sinceMs, nowMs, timeZone) {
+	if (nowMs - sinceMs < DAY_MS$3) return ncClockText(texts.language, sinceMs, timeZone);
+	return new Intl.DateTimeFormat(texts.language, {
+		day: "numeric",
+		month: "short",
+		hour: "2-digit",
+		minute: "2-digit",
+		...timeZone !== void 0 ? { timeZone } : {}
+	}).format(new Date(sinceMs));
+}
+function lineOf(input, item) {
+	const since = item.since !== void 0 ? sinceText(input.texts, item.since, input.nowMs, input.timeZone) : "";
+	return input.texts.text({
+		key: item.lineKey,
+		vars: {
+			...item.params,
+			since
+		}
+	});
+}
+function blockOf(input, section) {
+	const title = input.texts.text({ key: `summary.section.${section.id}` });
+	if (section.status === "unavailable") return input.texts.text({
+		key: "summary.section.unavailable",
+		vars: { section: title }
+	});
+	if (section.items.length === 0) return null;
+	const lines = section.items.map((item) => `• ${lineOf(input, item)}`);
+	return [`${title}:`, ...lines].join("\n");
+}
+function stateSummaryText(input) {
+	const sectionVars = {};
+	const blocks = [];
+	for (const section of input.summary.sections) {
+		const block = blockOf(input, section);
+		sectionVars[NC_STATE_SECTION_VAR[section.id]] = block ?? "";
+		if (block !== null) blocks.push(block);
+	}
+	return {
+		text: blocks.join("\n"),
+		count: input.summary.itemCount,
+		sectionVars
+	};
+}
+//#endregion
+//#region src/notification-center/state-summary/zoned-clock.ts
+var WEEKDAYS = {
+	Sun: 0,
+	Mon: 1,
+	Tue: 2,
+	Wed: 3,
+	Thu: 4,
+	Fri: 5,
+	Sat: 6
+};
+var FORMATTERS = /* @__PURE__ */ new Map();
+function formatterFor(timezone) {
+	const held = FORMATTERS.get(timezone);
+	if (held !== void 0) return held;
+	let made;
+	try {
+		made = new Intl.DateTimeFormat("en-US", {
+			timeZone: timezone,
+			year: "numeric",
+			month: "numeric",
+			day: "numeric",
+			weekday: "short",
+			hour: "numeric",
+			minute: "numeric",
+			hourCycle: "h23"
+		});
+	} catch {
+		made = null;
+	}
+	FORMATTERS.set(timezone, made);
+	return made;
+}
+function wallOf(atMs, timezone) {
+	const date = new Date(atMs);
+	const formatter = timezone !== void 0 ? formatterFor(timezone) : null;
+	if (formatter !== null) {
+		const parts = new Map(formatter.formatToParts(date).map((p) => [p.type, p.value]));
+		const weekday = WEEKDAYS[parts.get("weekday") ?? ""];
+		const wall = {
+			year: Number(parts.get("year")),
+			month: Number(parts.get("month")),
+			day: Number(parts.get("day")),
+			hour: Number(parts.get("hour")),
+			minute: Number(parts.get("minute"))
+		};
+		if (weekday !== void 0 && Object.values(wall).every(Number.isFinite)) return {
+			...wall,
+			weekday
+		};
+	}
+	return {
+		year: date.getFullYear(),
+		month: date.getMonth() + 1,
+		day: date.getDate(),
+		weekday: date.getDay(),
+		hour: date.getHours(),
+		minute: date.getMinutes()
+	};
+}
+/** The calendar day `atMs` falls on, in the timezone. */
+function zonedDayOf(atMs, timezone) {
+	const { year, month, day, weekday } = wallOf(atMs, timezone);
+	return {
+		year,
+		month,
+		day,
+		weekday
+	};
+}
+/** The day `offset` calendar days after `day`. Pure calendar arithmetic. */
+function addDays(day, offset) {
+	const shifted = new Date(Date.UTC(day.year, day.month - 1, day.day + offset));
+	return {
+		year: shifted.getUTCFullYear(),
+		month: shifted.getUTCMonth() + 1,
+		day: shifted.getUTCDate(),
+		weekday: ((day.weekday + offset) % 7 + 7) % 7
+	};
+}
+/**
+* The instant of `minuteOfDay` on `day`, in the timezone. Two passes of the
+* offset read settle a DST change; a wall time that does not exist (the spring
+* gap) lands next to it, and the caller verifies every instant it produces.
+*/
+function zonedInstant(day, minuteOfDay, timezone) {
+	const hour = Math.floor(minuteOfDay / 60);
+	const minute = minuteOfDay % 60;
+	if (timezone === void 0 || formatterFor(timezone) === null) return new Date(day.year, day.month - 1, day.day, hour, minute).getTime();
+	const asUtc = Date.UTC(day.year, day.month - 1, day.day, hour, minute);
+	const offsetAt = (atMs) => {
+		const wall = wallOf(atMs, timezone);
+		return Date.UTC(wall.year, wall.month - 1, wall.day, wall.hour, wall.minute) - atMs;
+	};
+	return asUtc - offsetAt(asUtc - offsetAt(asUtc));
+}
+/** The widest look back: a weekly schedule closes at least once in eight days. */
+var NC_STATE_SUMMARY_MAX_LOOKBACK_MS = 8 * 864e5;
+/** A close found by the tick right after it is on time; later than this is `late`. */
+var ON_TIME_MS = 2 * 6e4;
+var MINUTE_MS = 6e4;
+var DAY_MS$2 = 864e5;
+/**
+* Every verified transition of `kind` in `(fromMs, toMs]`, ascending.
+* Candidates are each window's start and end minute on each day of the range
+* (the day before `fromMs` included, for a window crossing midnight).
+*/
+function scheduleTransitions(schedule, fromMs, toMs, kind, probe = require_dist.isScheduleActive) {
+	if (toMs <= fromMs) return [];
+	const first = zonedDayOf(fromMs - DAY_MS$2, schedule.timezone);
+	const days = Math.ceil((toMs - fromMs) / DAY_MS$2) + 2;
+	const minutes = /* @__PURE__ */ new Set();
+	for (const window of schedule.windows) {
+		minutes.add(window.startMinute);
+		minutes.add(window.endMinute);
+	}
+	const found = /* @__PURE__ */ new Set();
+	for (let offset = 0; offset <= days; offset += 1) {
+		const day = addDays(first, offset);
+		for (const minute of minutes) {
+			const at = zonedInstant(day, minute, schedule.timezone);
+			if (at <= fromMs || at > toMs || found.has(at)) continue;
+			const before = probe(schedule, at - MINUTE_MS);
+			const after = probe(schedule, at);
+			if (kind === "close" ? before && !after : !before && after) found.add(at);
+		}
+	}
+	return [...found].toSorted((a, b) => a - b);
+}
+/** The first window close after `afterMs`, within `horizonMs`, or `null`. */
+function nextStateSummaryClose(schedule, afterMs, horizonMs = NC_STATE_SUMMARY_MAX_LOOKBACK_MS, probe) {
+	return scheduleTransitions(schedule, afterMs, afterMs + horizonMs, "close", probe)[0] ?? null;
+}
+function decideStateSummary(input) {
+	const from = Math.max(input.floorMs, input.nowMs - NC_STATE_SUMMARY_MAX_LOOKBACK_MS);
+	const endMs = scheduleTransitions(input.schedule, from, input.nowMs, "close", input.probe).at(-1);
+	if (endMs === void 0) return { kind: "idle" };
+	const window = {
+		startMs: scheduleTransitions(input.schedule, endMs - DAY_MS$2, endMs, "open", input.probe).at(-1) ?? endMs,
+		endMs
+	};
+	const overdueMs = input.nowMs - endMs;
+	if (overdueMs > (input.graceMs ?? 108e5)) return {
+		kind: "missed",
+		window
+	};
+	return {
+		kind: "send",
+		window,
+		late: overdueMs > ON_TIME_MS
+	};
+}
+//#endregion
+//#region src/notification-center/state-summary/state-summary-scheduler.ts
+/**
+* The STATE SUMMARY's tick (D647): for every enabled summary rule, is a
+* window owed, and if so collect → word → enqueue → stamp.
+*
+* Driven by the centre's existing rule-reload tick — no timer of its own — and
+* single-flight. It reads RAM only: the rule mirror, the stamps and the state
+* mirrors (D447: nothing on this schedule queries SQLite).
+*
+* Every branch that sends nothing SAYS so: an empty state (INFO), a missed
+* window (WARN), a stamp ledger that has not been read (WARN — nothing is sent
+* until it has, because without it a restart could send a window twice), a
+* delivery that failed (WARN, retried on the next tick inside the grace).
+*
+* The stamp is LAST, as in the digest: a window whose enqueue failed stays owed.
+*/
+var NcStateSummaryScheduler = class {
+	deps;
+	inFlight = false;
+	/** Per rule: the next window close, valid for one floor and one schedule. */
+	nextClose = /* @__PURE__ */ new Map();
+	/** One WARN per hold, not one per tick. */
+	holdReported = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async tick() {
+		const report = {
+			decisions: 0,
+			sent: 0,
+			empty: 0,
+			missed: 0,
+			failed: 0,
+			held: false
+		};
+		if (this.inFlight) return report;
+		this.inFlight = true;
+		try {
+			const rules = this.deps.rules().filter((rule) => require_dist.systemEventSummaryScheduleOf(rule) !== null);
+			if (rules.length === 0) return report;
+			if (!this.deps.stamps.answered()) {
+				report.held = true;
+				if (!this.holdReported) {
+					this.holdReported = true;
+					this.deps.logger.warn("state summaries held — the send ledger has not been read yet", { meta: { rules: rules.map((rule) => rule.id) } });
+				}
+				return report;
+			}
+			this.holdReported = false;
+			const nowMs = this.deps.now();
+			for (const rule of rules) {
+				const schedule = require_dist.systemEventSummaryScheduleOf(rule);
+				if (schedule !== null) await this.tickRule(rule, schedule, nowMs, report);
+			}
+			return report;
+		} finally {
+			this.inFlight = false;
+		}
+	}
+	async tickRule(rule, schedule, nowMs, report) {
+		const stamp = await this.armed(rule, schedule, nowMs);
+		if (stamp === null) return;
+		const floorMs = Math.max(stamp.armedAt, stamp.lastWindowEnd);
+		const cached = this.nextClose.get(rule.id);
+		if (cached !== void 0 && cached.floorMs === floorMs && cached.scheduleKey === stamp.scheduleKey && nowMs < cached.atMs) return;
+		report.decisions += 1;
+		const decision = decideStateSummary({
+			schedule,
+			nowMs,
+			floorMs,
+			...this.deps.graceMs !== void 0 ? { graceMs: this.deps.graceMs } : {}
+		});
+		if (decision.kind === "idle") {
+			const next = nextStateSummaryClose(schedule, nowMs);
+			this.nextClose.set(rule.id, {
+				floorMs,
+				scheduleKey: stamp.scheduleKey,
+				atMs: next ?? nowMs + 6912e5
+			});
+			return;
+		}
+		this.nextClose.delete(rule.id);
+		const meta = {
+			ruleId: rule.id,
+			rule: rule.name,
+			windowStart: decision.window.startMs,
+			windowEnd: decision.window.endMs
+		};
+		if (decision.kind === "missed") {
+			report.missed += 1;
+			this.deps.logger.warn("state summary window MISSED — closed too long ago to send now", { meta: {
+				...meta,
+				overdueMs: nowMs - decision.window.endMs
+			} });
+			await this.stamp(stamp, decision.window.endMs);
+			return;
+		}
+		const summary = await this.deps.collect(rule, nowMs);
+		if (isEmptyStateSummary(summary)) {
+			report.empty += 1;
+			this.deps.logger.info("state summary has nothing to report — not sent", { meta: {
+				...meta,
+				dropped: summary.dropped
+			} });
+			await this.stamp(stamp, decision.window.endMs);
+			return;
+		}
+		let inserted;
+		try {
+			inserted = await this.deps.deliver(rule, summary, decision.window);
+		} catch (err) {
+			report.failed += 1;
+			this.deps.logger.warn("state summary could not be enqueued — retried on the next tick", { meta: {
+				...meta,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			return;
+		}
+		report.sent += 1;
+		this.deps.logger.info("state summary enqueued", { meta: {
+			...meta,
+			late: decision.late,
+			items: summary.itemCount,
+			unavailable: summary.unavailableCount,
+			sections: summary.sections.map((section) => `${section.id}:${section.status}`),
+			dropped: summary.dropped,
+			inserted
+		} });
+		await this.stamp(stamp, decision.window.endMs);
+	}
+	/**
+	* The rule's stamp, armed NOW when the rule is new to summary mode or its
+	* schedule changed. `null` when arming could not be written — nothing is
+	* sent on an unarmed rule.
+	*/
+	async armed(rule, schedule, nowMs) {
+		const scheduleKey = require_dist.canonicalHash(schedule);
+		const held = this.deps.stamps.get(rule.id);
+		if (held !== void 0 && held.scheduleKey === scheduleKey) return held;
+		const armed = {
+			ruleId: rule.id,
+			armedAt: nowMs,
+			lastWindowEnd: held?.lastWindowEnd ?? 0,
+			scheduleKey
+		};
+		try {
+			await this.deps.stamps.put(armed);
+		} catch (err) {
+			this.deps.logger.warn("state summary rule could not be armed — nothing is sent until it is", { meta: {
+				ruleId: rule.id,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			return null;
+		}
+		this.deps.logger.info("state summary rule armed — windows closing from now on are sent", { meta: {
+			ruleId: rule.id,
+			rule: rule.name,
+			rearmed: held !== void 0
+		} });
+		return armed;
+	}
+	async stamp(held, windowEndMs) {
+		try {
+			await this.deps.stamps.put({
+				...held,
+				lastWindowEnd: Math.max(held.lastWindowEnd, windowEndMs)
+			});
+		} catch (err) {
+			this.deps.logger.warn("state summary stamp did not land — the outbox dedup still holds", { meta: {
+				ruleId: held.ruleId,
+				windowEnd: windowEndMs,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+	}
+};
+var SPEC = {
+	collection: "notification-center:state-summary-stamps",
+	columns: [
+		{
+			name: "ruleId",
+			type: "TEXT",
+			primaryKey: true,
+			notNull: true
+		},
+		{
+			name: "armedAt",
+			type: "INTEGER",
+			notNull: true
+		},
+		{
+			name: "lastWindowEnd",
+			type: "INTEGER",
+			notNull: true
+		},
+		{
+			name: "scheduleKey",
+			type: "TEXT",
+			notNull: true
+		}
+	],
+	writeMode: "write-through",
+	keyOf: (row) => row.ruleId,
+	toValue: (row) => ({
+		armedAt: row.armedAt,
+		lastWindowEnd: row.lastWindowEnd,
+		scheduleKey: row.scheduleKey
+	}),
+	fromRecord: (key, data) => {
+		const armedAt = data["armedAt"];
+		const lastWindowEnd = data["lastWindowEnd"];
+		const scheduleKey = data["scheduleKey"];
+		if (typeof armedAt !== "number" || typeof lastWindowEnd !== "number") return null;
+		if (typeof scheduleKey !== "string") return null;
+		return {
+			ruleId: key,
+			armedAt,
+			lastWindowEnd,
+			scheduleKey
+		};
+	},
+	loadLimit: 1e4
+};
+var NcStateSummaryStampStore = class {
+	ledger;
+	constructor(deps) {
+		this.ledger = new DurableLedger({
+			spec: SPEC,
+			store: deps.store,
+			logger: deps.logger
+		});
+	}
+	static declare(store) {
+		return DurableLedger.declare(store, SPEC);
+	}
+	async load() {
+		return (await this.ledger.load()).length;
+	}
+	port() {
+		return {
+			get: (ruleId) => this.ledger.get(ruleId),
+			put: (row) => this.ledger.put(row),
+			answered: () => this.ledger.hasAnswered()
+		};
+	}
+};
+//#endregion
+//#region src/notification-center/state-summary/system-state-ledger.ts
+/**
+* @durable class=ledger owner=notification-center
+*   write="a system state the centre accepted OPENING (a stream offline, a device switched off, a camera detecting nothing, an update available, a node that cannot infer, a crash-looped runner); its closing event deletes the row"
+*   retention="none — a row lives exactly as long as its state is open. Bounded by the installation: streams, devices, nodes and installed packages."
+*/
+var NC_SYSTEM_STATE_COLLECTION = "notification-center:system-state";
+var NC_SYSTEM_STATE_COLUMNS = [
+	(
+	/** The state's subject (`stream:<id>`, `device-switch:<id>`,
+	*  `update:addon:<node>:<package>`, ...). */
+	{
+		name: "key",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	}),
+	(
+	/** The OPENING kind. */
+	{
+		name: "kind",
+		type: "TEXT",
+		notNull: true
+	}),
+	{
+		name: "since",
+		type: "INTEGER",
+		notNull: true
+	},
+	(
+	/** Indexed: every question about a device is asked per device. */
+	{
+		name: "deviceId",
+		type: "INTEGER"
+	}),
+	{
+		name: "nodeId",
+		type: "TEXT"
+	},
+	{
+		name: "packageName",
+		type: "TEXT"
+	},
+	(
+	/** The words' facts (device name, profile, versions, addons). */
+	{
+		name: "params",
+		type: "JSON",
+		notNull: true
+	})
+];
+var NC_SYSTEM_STATE_INDEXES = [{
+	name: "idx_nc_system_state_device",
+	columns: ["deviceId"]
+}];
+/** The kinds that OPEN a row. */
+var NC_SYSTEM_STATE_OPENING_KINDS = [
+	"stream-offline",
+	"device-disabled",
+	"detection-blind",
+	"node-inference-unavailable",
+	"addon-crash-loop",
+	"addon-update-available",
+	"server-update-available",
+	"wrapper-update-available"
+];
+function isOpeningKind(value) {
+	return NC_SYSTEM_STATE_OPENING_KINDS.some((kind) => kind === value);
+}
+function stringRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) if (typeof entry === "string") out[key] = entry;
+	return out;
+}
+var NC_SYSTEM_STATE_SPEC = {
+	collection: NC_SYSTEM_STATE_COLLECTION,
+	columns: NC_SYSTEM_STATE_COLUMNS,
+	indexes: NC_SYSTEM_STATE_INDEXES,
+	writeMode: "write-behind",
+	keyOf: (row) => row.key,
+	toValue: (row) => ({
+		kind: row.kind,
+		since: row.since,
+		...row.deviceId !== void 0 ? { deviceId: row.deviceId } : {},
+		...row.nodeId !== void 0 ? { nodeId: row.nodeId } : {},
+		...row.packageName !== void 0 ? { packageName: row.packageName } : {},
+		params: {
+			...row.params,
+			...row.deviceType !== void 0 ? { deviceType: row.deviceType } : {}
+		}
+	}),
+	fromRecord: (key, data) => {
+		const kind = data["kind"];
+		const since = data["since"];
+		const params = stringRecord(data["params"]);
+		if (!isOpeningKind(kind) || typeof since !== "number" || params === null) return null;
+		const deviceId = data["deviceId"];
+		const nodeId = data["nodeId"];
+		const packageName = data["packageName"];
+		const { deviceType, ...words } = params;
+		return {
+			key,
+			kind,
+			since,
+			...typeof deviceId === "number" ? { deviceId } : {},
+			...deviceType !== void 0 ? { deviceType } : {},
+			...typeof nodeId === "string" ? { nodeId } : {},
+			...typeof packageName === "string" ? { packageName } : {},
+			params: words
+		};
+	},
+	deviceIdOf: (row) => row.deviceId
+};
+function isUpdateTarget(value) {
+	return value === "addon" || value === "server" || value === "wrapper";
+}
+function updateKind(target) {
+	return target === "addon" ? "addon-update-available" : target === "server" ? "server-update-available" : "wrapper-update-available";
+}
+function updateStateKey(target, nodeId, packageName) {
+	return `update:${target}:${nodeId ?? "hub"}:${packageName}`;
+}
+var NcSystemStateLedger = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** The open rows, or `null` while the store has never answered. */
+	openRows() {
+		return this.deps.rows.answered() ? this.deps.rows.all() : null;
+	}
+	/**
+	* One system subject the intake accepted. The update-available kinds are
+	* not read here: {@link observeUpdateList} replaces them from the raw event.
+	*/
+	observe(system, atMs) {
+		switch (system.kind) {
+			case "stream-offline":
+			case "device-disabled":
+			case "detection-blind":
+			case "node-inference-unavailable":
+			case "addon-crash-loop":
+				this.open(system, atMs);
+				return;
+			case "stream-online":
+			case "device-enabled":
+				this.close(system.subject, system.kind);
+				return;
+			case "node-online":
+			case "node-offline":
+				if (system.nodeId !== void 0) this.closeNodeFaults(system.nodeId, system.kind);
+				return;
+			case "server-updated":
+				if (system.nodeId !== void 0) this.closeServerUpdate(system.nodeId);
+				return;
+			default: return;
+		}
+	}
+	/** A detection on a camera: it is not blind. Called for every detection — a Map lookup. */
+	observeDetection(deviceId) {
+		const key = `detection-blind:${String(deviceId)}`;
+		if (this.deps.rows.get(key) === void 0) return;
+		this.close(key, "detection");
+	}
+	/**
+	* Any `stream.online`, whatever its reason (D647 review I1). The intake gate
+	* drops a `first-packet` online — a recreated broker's — because it is not
+	* a recovery worth a notification; it is still proof the stream is up.
+	*/
+	observeStreamOnline(camStreamId) {
+		this.close(`stream:${camStreamId}`, "stream-online");
+	}
+	/** One `update.available` list: REPLACE the rows of every node it names. */
+	observeUpdateList(list, atMs) {
+		const keep = new Set(list.rows.map((pkg) => updateStateKey(list.target, pkg.nodeId, pkg.packageName)));
+		for (const nodeId of list.nodeIds) {
+			const prefix = `update:${list.target}:${nodeId}:`;
+			for (const row of this.deps.rows.all()) if (row.key.startsWith(prefix) && !keep.has(row.key)) this.close(row.key, "update-list");
+		}
+		for (const pkg of list.rows) this.openUpdate(list.target, pkg, atMs);
+	}
+	/**
+	* An addon STARTED on `nodeId` (D647 review I5): the runner hosting it is
+	* up again, so a crash-loop row naming it on THAT node is over — and only
+	* on that node.
+	*/
+	observeAddonStarted(addonId, nodeId) {
+		for (const row of this.deps.rows.all()) {
+			if (row.kind !== "addon-crash-loop") continue;
+			if (row.nodeId !== nodeId) continue;
+			if ((row.params["addons"] ?? "").split(",").map((id) => id.trim()).includes(addonId)) this.close(row.key, "addon-started");
+		}
+	}
+	/**
+	* The balancer placed a camera on a node (not pinned): placement skips a
+	* node that cannot infer, so the node can infer again (D647 review I5).
+	*/
+	observeCameraPlaced(nodeId) {
+		this.close(`node-inference:${nodeId}`, "camera-placed");
+	}
+	/** `addon.updated` — the package is current on that node. */
+	observeAddonUpdated(update) {
+		this.close(updateStateKey("addon", update.nodeId, update.packageName), "addon-updated");
+	}
+	/** Every device that holds an open state — the deleted-device reconcile reads it. */
+	deviceIds() {
+		const ids = /* @__PURE__ */ new Set();
+		for (const row of this.deps.rows.all()) if (row.deviceId !== void 0) ids.add(row.deviceId);
+		return [...ids];
+	}
+	/** A deleted device leaves (D633). Returns how many rows went. */
+	forgetDevice(deviceId) {
+		const keys = this.deps.rows.all().filter((row) => row.deviceId === deviceId).map((row) => row.key);
+		for (const key of keys) this.deps.rows.remove(key);
+		return keys.length;
+	}
+	open(system, atMs) {
+		const held = this.deps.rows.get(system.subject);
+		const since = held !== void 0 && held.kind === system.kind ? held.since : atMs;
+		this.deps.rows.put({
+			key: system.subject,
+			kind: system.kind,
+			since,
+			...system.deviceId !== void 0 ? { deviceId: system.deviceId } : {},
+			...system.deviceType !== void 0 ? { deviceType: system.deviceType } : {},
+			...system.nodeId !== void 0 ? { nodeId: system.nodeId } : {},
+			params: system.textParams ?? {}
+		});
+	}
+	openUpdate(target, pkg, atMs) {
+		const key = updateStateKey(target, pkg.nodeId, pkg.packageName);
+		const held = this.deps.rows.get(key);
+		const kind = updateKind(target);
+		this.deps.rows.put({
+			key,
+			kind,
+			since: held?.since ?? atMs,
+			...pkg.nodeId !== void 0 ? { nodeId: pkg.nodeId } : {},
+			packageName: pkg.packageName,
+			params: {
+				packageName: pkg.packageName,
+				currentVersion: pkg.currentVersion,
+				latestVersion: pkg.latestVersion,
+				...pkg.nodeId !== void 0 ? { nodeId: pkg.nodeId } : {}
+			}
+		});
+	}
+	close(key, by) {
+		const held = this.deps.rows.get(key);
+		if (held === void 0) return;
+		this.deps.rows.remove(key);
+		this.deps.logger?.debug("system state closed", {
+			...held.deviceId !== void 0 ? { tags: { deviceId: held.deviceId } } : {},
+			meta: {
+				key,
+				kind: held.kind,
+				by,
+				since: held.since
+			}
+		});
+	}
+	closeNodeFaults(nodeId, by) {
+		for (const row of this.deps.rows.all()) {
+			if (row.nodeId !== nodeId) continue;
+			if (row.kind === "node-inference-unavailable" || row.kind === "addon-crash-loop") this.close(row.key, by);
+		}
+	}
+	closeServerUpdate(nodeId) {
+		for (const row of this.deps.rows.all()) {
+			if ((row.nodeId ?? "hub") !== nodeId) continue;
+			if (row.kind === "server-update-available" || row.kind === "wrapper-update-available" || row.kind === "addon-crash-loop" || row.kind === "node-inference-unavailable") this.close(row.key, "server-updated");
+		}
+	}
+};
+/** The durable home of the rows. */
+var NcSystemStateStore = class {
+	ledger;
+	constructor(deps) {
+		this.ledger = new DurableLedger({
+			spec: NC_SYSTEM_STATE_SPEC,
+			store: deps.store,
+			logger: deps.logger
+		});
+	}
+	static declare(store) {
+		return DurableLedger.declare(store, NC_SYSTEM_STATE_SPEC);
+	}
+	/** Boot reseed. A failed load keeps the mirror and leaves `answered` false. */
+	async load() {
+		return (await this.ledger.load()).length;
+	}
+	port() {
+		return {
+			get: (key) => this.ledger.get(key),
+			put: (row) => {
+				this.ledger.put(row).catch(() => void 0);
+			},
+			remove: (key) => {
+				this.ledger.forget(key);
+			},
+			all: () => this.ledger.snapshot(),
+			answered: () => this.ledger.hasAnswered()
+		};
+	}
+};
+//#endregion
+//#region src/notification-center/state-summary/state-summary-service.ts
+function stringOf(data, key) {
+	const value = data[key];
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/**
+* The full list an `update.available` event carries, and the nodes it speaks
+* for: every node a row names, plus the event's own `nodeId`. The emitter
+* never sends an empty list (it emits only when a `latestVersion` changes), so
+* the empty case is defensive, not a path that clears anything today — see
+* {@link NcUpdateList} for the limit that leaves.
+*/
+function updateListOf(data) {
+	const target = data["target"];
+	if (!isUpdateTarget(target)) return null;
+	const rows = updatePackages(data);
+	const eventNode = stringOf(data, "nodeId");
+	const nodes = new Set(rows.map((row) => row.nodeId ?? eventNode ?? "hub"));
+	if (eventNode !== void 0) nodes.add(eventNode);
+	const withNode = rows.map((row) => row.nodeId === void 0 && eventNode !== void 0 ? {
+		...row,
+		nodeId: eventNode
+	} : row);
+	return {
+		target,
+		nodeIds: [...nodes],
+		rows: withNode
+	};
+}
+var NcStateSummaryService = class {
+	deps;
+	stateStore;
+	stampStore;
+	ledger;
+	scheduler;
+	constructor(deps) {
+		this.deps = deps;
+		this.stateStore = new NcSystemStateStore({
+			store: deps.store,
+			logger: deps.logger
+		});
+		this.stampStore = new NcStateSummaryStampStore({
+			store: deps.store,
+			logger: deps.logger
+		});
+		this.ledger = new NcSystemStateLedger({
+			rows: this.stateStore.port(),
+			logger: deps.logger
+		});
+		this.scheduler = new NcStateSummaryScheduler({
+			rules: deps.rules,
+			stamps: this.stampStore.port(),
+			collect: (rule, nowMs) => this.collect(rule, nowMs),
+			deliver: (rule, summary, window) => this.deliver(rule, summary, window),
+			now: deps.now,
+			logger: deps.logger
+		});
+	}
+	static async declare(store) {
+		await NcSystemStateStore.declare(store);
+		await NcStateSummaryStampStore.declare(store);
+	}
+	/** Boot back-fill. Each load that fails leaves its mirror unanswered — the summary then says so. */
+	async load() {
+		return {
+			states: await this.stateStore.load(),
+			stamps: await this.stampStore.load()
+		};
+	}
+	/** One system subject the intake accepted. */
+	observeSystem(system, atMs) {
+		this.ledger.observe(system, atMs);
+	}
+	/**
+	* The RAW bus event, before the intake's gates (D647 review I1/I3/I5): the
+	* facts that close or replace a state even when no notification is owed —
+	* any `stream.online`, the full `update.available` list of a node, an addon
+	* that started, a camera the balancer placed.
+	*/
+	observeRawEvent(category, data, atMs, sourceNodeId) {
+		switch (category) {
+			case "stream.online": {
+				const camStreamId = stringOf(data, "camStreamId");
+				if (camStreamId !== void 0) this.ledger.observeStreamOnline(camStreamId);
+				return;
+			}
+			case "update.available": {
+				const list = updateListOf(data);
+				if (list !== null) this.ledger.observeUpdateList(list, atMs);
+				return;
+			}
+			case "addon.started":
+			case "addon.restarted": {
+				const addonId = stringOf(data, "addonId");
+				if (addonId !== void 0) this.ledger.observeAddonStarted(addonId, sourceNodeId ?? "hub");
+				return;
+			}
+			case "pipeline.camera-assigned": {
+				const nodeId = stringOf(data, "agentNodeId");
+				const placed = data["pinned"] === false && data["reason"] !== "unassigned";
+				if (nodeId !== void 0 && placed) this.ledger.observeCameraPlaced(nodeId);
+				return;
+			}
+			default: return;
+		}
+	}
+	observeDetection(deviceId) {
+		this.ledger.observeDetection(deviceId);
+	}
+	observeAddonUpdated(update) {
+		this.ledger.observeAddonUpdated(update);
+	}
+	tick() {
+		return this.scheduler.tick();
+	}
+	/** The summary this rule would send NOW (`previewStateSummary`) — sends nothing, stamps nothing. */
+	async preview(rule) {
+		const nowMs = this.deps.now();
+		const summary = await this.collect(rule, nowMs);
+		const text = this.word(summary, nowMs);
+		return {
+			empty: summary.itemCount === 0 && summary.unavailableCount === 0,
+			count: text.count,
+			text: text.text,
+			sections: summary.sections.map((section) => ({
+				id: section.id,
+				status: section.status,
+				items: section.items.length,
+				...section.reason !== void 0 ? { reason: section.reason } : {}
+			})),
+			dropped: { ...summary.dropped },
+			excludedGroups: [...summary.excludedGroups]
+		};
+	}
+	async collect(rule, nowMs) {
+		const nodes = await this.nodeView();
+		return collectStateSummary({
+			rule,
+			nowMs,
+			isMuted: this.deps.isMuted,
+			sources: stateSources({
+				alerts: this.deps.alerts,
+				liveness: this.deps.liveness,
+				state: () => this.ledger.openRows(),
+				lookup: this.deps.lookup,
+				devicesAnswered: this.deps.devicesAnswered,
+				nodes,
+				livenessHoldoffMs: this.deps.livenessHoldoffMs
+			})
+		});
+	}
+	/** The node directory for one summary, or `null` (logged) when it did not answer. */
+	async nodeView() {
+		const read = this.deps.readNodes;
+		if (read === void 0) return null;
+		try {
+			const answer = await read();
+			const online = new Map(answer.nodes.map((node) => [node.id, node.isOnline]));
+			return {
+				complete: answer.complete,
+				online: (nodeId) => online.get(nodeId)
+			};
+		} catch (err) {
+			this.deps.logger.warn("state summary: the node directory did not answer — node sections unavailable", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return null;
+		}
+	}
+	word(summary, nowMs) {
+		return stateSummaryText({
+			texts: this.deps.texts(),
+			summary,
+			nowMs
+		});
+	}
+	async deliver(rule, summary, window) {
+		const subject = stateSummarySubject({
+			rule,
+			summary,
+			text: this.word(summary, window.endMs),
+			window
+		});
+		if (subject === null) {
+			this.deps.logger.warn("state summary rule has no system-event condition — not sent", { meta: { ruleId: rule.id } });
+			return 0;
+		}
+		return this.deps.enqueue(rule, subject);
+	}
+};
+//#endregion
 //#region src/notification-center/zone-owner-cache.ts
 var NcZoneOwnershipCache = class {
 	deps;
@@ -28991,6 +30688,8 @@ var NotificationCenter = class NotificationCenter {
 	alertStore;
 	/** Battery band → notification, and the reminder sweep. */
 	deviceAlerts;
+	/** The scheduled STATE SUMMARY of system rules (D647): its ledgers and its tick. */
+	stateSummary;
 	/** States the `deviceState` rule gate reads. Refreshed on the reload tick;
 	*  read with no I/O on the persist hook. */
 	deviceStates;
@@ -29884,6 +31583,21 @@ var NotificationCenter = class NotificationCenter {
 			logger: this.logger.child("device-alerts"),
 			...deps.now !== void 0 ? { now: deps.now } : {}
 		});
+		this.stateSummary = new NcStateSummaryService({
+			store: deps.store,
+			logger: this.logger.child("state-summary"),
+			now: () => this.now(),
+			rules: () => this.rules.listEnabled("system-event"),
+			alerts: () => this.deviceAlerts.openEpisodes(),
+			liveness: () => this.liveness.hasAnswered() ? this.liveness.snapshot() : null,
+			lookup: (deviceId) => this.deviceDirectory.get(deviceId),
+			devicesAnswered: () => this.deviceDirectory.isWarm(),
+			...deps.readNodeDirectory !== void 0 ? { readNodes: deps.readNodeDirectory } : {},
+			livenessHoldoffMs: deps.livenessHoldoffMs ?? 3e5,
+			isMuted: (deviceId) => this.deviceMutes.isMuted(deviceId),
+			texts: () => this.texts,
+			enqueue: (rule, subject) => this.enqueueStateSummary(rule, subject)
+		});
 		this.confirmGate = deps.generateVision !== void 0 ? new NcConfirmGate({
 			logger: this.logger.child("confirm"),
 			generateVision: deps.generateVision,
@@ -29981,7 +31695,10 @@ var NotificationCenter = class NotificationCenter {
 			summary: this.summaryRules,
 			mutes: this.deviceMutes,
 			alarm: () => this.alarmPanel,
-			alerts: this.deviceAlerts,
+			alerts: {
+				deviceIds: () => [...new Set([...this.deviceAlerts.deviceIds(), ...this.stateSummary.ledger.deviceIds()])],
+				forget: async (deviceId) => await this.deviceAlerts.forget(deviceId) + this.stateSummary.ledger.forgetDevice(deviceId)
+			},
 			directory: this.deviceDirectory,
 			isDeviceDeleted: deps.isDeviceDeleted,
 			targetCatalog: () => this.dispatcher.catalogSnapshot()
@@ -30092,6 +31809,7 @@ var NotificationCenter = class NotificationCenter {
 		await OccupancyStore.declare(store);
 		await NcLivenessLedger.declare(store);
 		await NcAlertStore.declare(store);
+		await NcStateSummaryService.declare(store);
 		await NcSnoozeStore.declare(store);
 		await NcDeviceMuteStore.declare(store);
 		await TimelapseStore.declare(store);
@@ -30285,6 +32003,10 @@ var NotificationCenter = class NotificationCenter {
 			const rows = await this.alertStore.load();
 			this.logger.info("device alert ledger reseeded", { meta: { rows } });
 		})) return;
+		if (!await phase("stateSummary", async () => {
+			const loaded = await this.stateSummary.load();
+			this.logger.info("state summary ledgers reseeded", { meta: loaded });
+		})) return;
 		if (!await phase("occupancy", () => this.hydrateOccupancy())) return;
 		if (!await phase("outbox", () => this.outbox.load())) return;
 		if (!await phase("cooldowns", () => this.seedCooldowns())) return;
@@ -30590,6 +32312,7 @@ var NotificationCenter = class NotificationCenter {
 			atMs: event.timestamp,
 			...event.trackId !== void 0 ? { trackId: event.trackId } : {}
 		});
+		if (this.evaluationActive) this.stateSummary.observeDetection(event.deviceId);
 		this.consumeEvent(incomingFromObjectEvent(event));
 	}
 	/**
@@ -30973,9 +32696,15 @@ var NotificationCenter = class NotificationCenter {
 		if (!this.evaluationActive) return;
 		if (event.category === "addon.updated") {
 			const update = parseAddonUpdateComplete(event.data);
-			if (update !== null) this.addonUpdates.observe(update);
+			if (update !== null) {
+				this.addonUpdates.observe(update);
+				this.stateSummary.observeAddonUpdated(update);
+			}
 			return;
 		}
+		this.stateSummary.observeRawEvent(event.category, event.data, this.now(), event.source.nodeId);
+		if (event.category === "addon.started" || event.category === "addon.restarted") return;
+		if (event.category === "pipeline.camera-assigned") return;
 		const battery = batterySliceOf(event);
 		if (battery !== null) {
 			this.deviceAlerts.observeBattery(battery.deviceId, battery.reading);
@@ -31005,6 +32734,7 @@ var NotificationCenter = class NotificationCenter {
 			return;
 		}
 		const system = incoming.subject.systemEvent;
+		if (system !== void 0) this.stateSummary.observeSystem(system, this.now());
 		const observation = system !== void 0 ? ledgeredLiveness(system) : null;
 		if (observation !== null) {
 			const previous = this.liveness.stateOf(observation.subject);
@@ -31059,6 +32789,10 @@ var NotificationCenter = class NotificationCenter {
 					logger: this.logger,
 					by: caller.userId
 				});
+				guardRuleSystemEventDelivery(rule, {
+					logger: this.logger,
+					by: caller.userId
+				});
 				await this.validateTargetRefs(rule.targets.map((t) => t.targetId));
 				const created = await this.rules.create(rule, caller.userId);
 				this.logger.info("notification rule created", { meta: {
@@ -31087,6 +32821,11 @@ var NotificationCenter = class NotificationCenter {
 					by: caller.userId,
 					ruleId
 				});
+				guardPatchSystemEventDelivery(existing, patch, clear ?? [], {
+					logger: this.logger,
+					by: caller.userId,
+					ruleId
+				});
 				const { disabledTargetIds: _optOut, ...safePatch } = patch;
 				const updated = await this.rules.update(ruleId, safePatch, clear ?? []);
 				this.logger.info("notification rule updated", { meta: {
@@ -31105,6 +32844,7 @@ var NotificationCenter = class NotificationCenter {
 				return { success: true };
 			},
 			testRule: async ({ rule, lookbackMinutes }) => ({ results: [...await this.dryRun(rule, lookbackMinutes)] }),
+			previewStateSummary: async ({ rule }) => this.stateSummary.preview(rule),
 			getConditionCatalog: async () => ({
 				catalog: [...require_dist.NC_CONDITION_CATALOG],
 				taxonomy: require_dist.NC_TAXONOMY
@@ -31986,6 +33726,29 @@ var NotificationCenter = class NotificationCenter {
 				});
 				continue;
 			}
+			if (require_dist.isSystemEventSummaryRule(rule)) {
+				this.logger.debug("rule matched — held for its scheduled state summary", {
+					tags: { deviceId: subject.deviceId },
+					meta: {
+						ruleId: rule.id,
+						rule: rule.name,
+						kind: subject.systemEvent?.kind,
+						eventId: subject.recordId
+					}
+				});
+				outcomes.push({
+					ruleId: rule.id,
+					ruleName: rule.name,
+					matched: true,
+					...evaluation.matchedOn !== void 0 ? { matchedOn: [...evaluation.matchedOn] } : {},
+					cooldown: "n/a",
+					enqueued: 0,
+					targetIds: [],
+					heldForSummary: true
+				});
+				anyMatched = true;
+				continue;
+			}
 			this.sceneGateReported.delete(rule.id);
 			this.runRuleActions(rule, subject, kind, controls);
 			const admission = this.admitToGroup(rule, subject, now);
@@ -32177,6 +33940,31 @@ var NotificationCenter = class NotificationCenter {
 		return report({ candidates: candidates.length });
 	}
 	/**
+	* Enqueue ONE state summary (D647) through the rule's ordinary rows: its
+	* targets, its users (admins only — the row files under the system device),
+	* its template, and the drain's snooze gate and retries. The record id is
+	* the dedup key, so a window is enqueued once whatever the restarts.
+	*/
+	async enqueueStateSummary(rule, subject) {
+		const appended = withSummaryBody(rule);
+		if (appended !== null) this.logger.warn("state summary rule body names no summary content — {{summaryText}} appended", { meta: {
+			ruleId: rule.id,
+			rule: rule.name
+		} });
+		const sent = appended ?? rule;
+		const userTargets = await this.resolveUserTargets(sent, subject.deviceId);
+		const entries = this.buildEntries(sent, subject, "system-event", ["systemEvent"], userTargets, "system");
+		if (entries.length === 0) {
+			this.logger.warn("state summary reached NO target — its users are not admins, and it has no targets", { meta: {
+				ruleId: rule.id,
+				rule: rule.name,
+				targetUsers: rule.targetUsers ?? []
+			} });
+			return 0;
+		}
+		return this.outbox.enqueue(entries);
+	}
+	/**
 	* The rules a trigger may fire, which is `listEnabled(delivery)` plus and
 	* minus exactly one thing: `waitForEnhancement`.
 	*
@@ -32919,6 +34707,9 @@ var NotificationCenter = class NotificationCenter {
 	async reloadRules() {
 		await this.rules.load();
 		if (this.evaluationActive) this.deviceAlerts.tick();
+		if (this.evaluationActive) this.stateSummary.tick().catch((err) => {
+			this.logger.warn("state summary tick failed", { meta: { error: String(err) } });
+		});
 		await this.timelapseRules.load();
 		await this.summaryRules.load();
 		await this.ruleAi.load();
@@ -47279,6 +49070,16 @@ var FrameProcessor = class {
 		};
 	}
 };
+//#endregion
+//#region src/pipeline-analytics/pipeline/track-provenance.ts
+function trackProvenanceOf(frame) {
+	if (!(frame.width > 0 && frame.height > 0)) return void 0;
+	return {
+		...frame.rootModelId !== void 0 && frame.rootModelId.length > 0 ? { modelId: frame.rootModelId } : {},
+		frameWidth: frame.width,
+		frameHeight: frame.height
+	};
+}
 /** Bounded trackId → pending-upgrade map. Insertion-ordered, so the cap
 *  evicts the oldest record. */
 var PendingPreviewUpgrades = class {
@@ -50100,51 +51901,6 @@ var PlateGalleryProvider = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/replay/frame-processor-pass.ts
-/**
-* Run a FRESH `FrameProcessor` over a fixed, ordered sequence of frames and
-* return the tracks it produced.
-*
-* No `TrackStore`, no bus, no media — a track here is a summary built
-* ENTIRELY from `FrameProcessor.process()`'s in-memory return value.
-*/
-function runFrameProcessorPass(input) {
-	const processor = new FrameProcessor(input.deviceId, {}, {}, {}, input.source);
-	if (input.zones !== void 0) processor.setZones(input.zones);
-	if (input.detectionRules !== void 0) processor.setDetectionRules(input.detectionRules);
-	if (input.zoneMembershipMinOverlap !== void 0) processor.setZoneMembershipMinOverlap(input.zoneMembershipMinOverlap);
-	const accum = /* @__PURE__ */ new Map();
-	for (const { timestamp, frame } of input.frames) {
-		const result = processor.process({
-			timestamp,
-			frame
-		});
-		for (const td of result.tracked) {
-			const existing = accum.get(td.trackId);
-			const matched = td.matchedThisFrame ? 1 : 0;
-			if (existing === void 0) accum.set(td.trackId, {
-				className: td.className,
-				firstSeenMs: timestamp,
-				lastSeenMs: timestamp,
-				bbox: { ...td.bbox },
-				framesMatched: matched
-			});
-			else {
-				existing.className = td.className;
-				existing.lastSeenMs = timestamp;
-				existing.framesMatched += matched;
-			}
-		}
-	}
-	return { tracks: [...accum.values()].map((t) => ({
-		className: t.className,
-		firstSeenMs: t.firstSeenMs,
-		lastSeenMs: t.lastSeenMs,
-		bbox: t.bbox,
-		framesMatched: t.framesMatched
-	})) };
-}
-//#endregion
 //#region src/pipeline-analytics/retention/disk-reconcile.ts
 /** Is this an event-owned media row — `motion` / `object` / `audio` (D476;
 *  `event` used to cover all three under one owner kind). */
@@ -52415,6 +54171,10 @@ var TRACKS_COLUMNS = [
 		name: "frameHeight",
 		type: "INTEGER"
 	},
+	{
+		name: "modelId",
+		type: "TEXT"
+	},
 	{
 		name: "closedReason",
 		type: "TEXT"
@@ -52579,7 +54339,12 @@ function cloneTrack(t) {
 		...t.hasFace !== void 0 ? { hasFace: t.hasFace } : {},
 		...t.hasEmbeddedFace !== void 0 ? { hasEmbeddedFace: t.hasEmbeddedFace } : {},
 		...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
-		...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {}
+		...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {},
+		...t.provenance?.modelId !== void 0 ? { modelId: t.provenance.modelId } : {},
+		...t.provenance !== void 0 ? {
+			frameWidth: t.provenance.frameWidth,
+			frameHeight: t.provenance.frameHeight
+		} : {}
 	};
 }
 var TrackStore = class {
@@ -52676,7 +54441,8 @@ var TrackStore = class {
 			totalDistance: 0,
 			state: params.state,
 			active: true,
-			lastSnapshotAt: 0
+			lastSnapshotAt: 0,
+			...params.provenance !== void 0 ? { provenance: params.provenance } : {}
 		};
 		this.active.set(params.trackId, fresh);
 		return fresh;
@@ -54137,7 +55903,10 @@ var TrackStore = class {
 		});
 	}
 	async persistCompleted(t) {
-		const dims = this.frameDims?.(t.deviceId);
+		const dims = t.frameWidth !== void 0 && t.frameHeight !== void 0 ? {
+			w: t.frameWidth,
+			h: t.frameHeight
+		} : this.frameDims?.(t.deviceId);
 		const envelope = computeTrackEnvelope(t.positions, dims?.w, dims?.h);
 		await this.store.set.mutate({
 			collection: TRACKS_COLLECTION,
@@ -54173,14 +55942,17 @@ var TrackStore = class {
 				...t.hasEmbeddedFace !== void 0 ? { hasEmbeddedFace: t.hasEmbeddedFace } : {},
 				...t.hasRider !== void 0 ? { hasRider: t.hasRider } : {},
 				...t.closedReason !== void 0 ? { closedReason: t.closedReason } : {},
-				...envelope !== null && dims !== void 0 ? {
+				...envelope !== null ? {
 					envMinX: envelope.minX,
 					envMinY: envelope.minY,
 					envMaxX: envelope.maxX,
-					envMaxY: envelope.maxY,
+					envMaxY: envelope.maxY
+				} : {},
+				...dims !== void 0 ? {
 					frameWidth: dims.w,
 					frameHeight: dims.h
-				} : {}
+				} : {},
+				...t.modelId !== void 0 ? { modelId: t.modelId } : {}
 			}
 		});
 	}
@@ -54240,6 +56012,9 @@ var TrackStore = class {
 		/** Free-form composed token line (see `composePreviewMissReason`) — a
 		*  string read, absent stays absent. */
 		const previewMissReason = data["previewMissReason"];
+		const modelId = data["modelId"];
+		const frameWidth = data["frameWidth"];
+		const frameHeight = data["frameHeight"];
 		const envMinX = data["envMinX"];
 		const envMinY = data["envMinY"];
 		const envMaxX = data["envMaxX"];
@@ -54283,7 +56058,12 @@ var TrackStore = class {
 			...closedReason !== void 0 ? { closedReason } : {},
 			...typeof previewMissReason === "string" && previewMissReason.length > 0 ? { previewMissReason } : {},
 			...observations !== void 0 ? { observations } : {},
-			...envelope !== null ? { envelope } : {}
+			...envelope !== null ? { envelope } : {},
+			...typeof modelId === "string" && modelId.length > 0 ? { modelId } : {},
+			...typeof frameWidth === "number" && typeof frameHeight === "number" ? {
+				frameWidth,
+				frameHeight
+			} : {}
 		});
 	}
 };
@@ -59736,7 +61516,6 @@ var DEFAULT_EMBEDDING_CONFIG = {
 	enabled: true,
 	modelId: "clip-vit-b32",
 	agentId: "local",
-	runtime: "node",
 	backend: "cpu",
 	classes: [],
 	minConfidence: .5,
@@ -77674,6 +79453,9 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_dist.EventCategory.PipelineNodeInferenceUnavailable,
 	require_dist.EventCategory.PipelineDetectionBlind,
 	require_dist.EventCategory.AddonRunnerFailed,
+	require_dist.EventCategory.AddonStarted,
+	require_dist.EventCategory.AddonRestarted,
+	require_dist.EventCategory.PipelineCameraAssigned,
 	require_dist.EventCategory.UpdateAvailable,
 	require_dist.EventCategory.AddonUpdated,
 	require_dist.EventCategory.SystemRestartCompleted,
@@ -87296,6 +89078,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				};
 			},
 			isDeviceDeleted: async (deviceId) => await api.deviceManager.getDevice.query({ deviceId }) === null,
+			readNodeDirectory: () => api.nodes.directory.query(),
 			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
 			...buildLinkedSnapshotReads(api.snapshot),
 			identityIdsByName: async () => {
@@ -88022,21 +89805,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			...input.nodeId !== void 0 ? { nodeId: input.nodeId } : {}
 		});
 	}
-	/**
-	* The FrameProcessor pass of a replay run — see the cap doc on
-	* `runReplayFrameProcessor` for why this is not the `processFrame` method
-	* this addon deliberately does not have.
-	*
-	* `runFrameProcessorPass` is pure w.r.t. this addon's own state: it
-	* constructs a FRESH `FrameProcessor` and does not touch `this.trackStore`,
-	* `this.stationaryRegistry` or any other instance field — unlike
-	* `getOrCreateProcessor` (the production path), which wires both.
-	* `scripts/check-replay-isolation.ts` holds that boundary on the
-	* `replay/` directory this delegates into.
-	*/
-	async runReplayFrameProcessor(input) {
-		return runFrameProcessorPass(input);
-	}
 	async listRetrainAnnotations(input) {
 		return this.requireRetrain().listAnnotations(input.trackId);
 	}
@@ -89142,6 +90910,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		});
 		const currentTrackIds = /* @__PURE__ */ new Set();
 		const positionsCountById = /* @__PURE__ */ new Map();
+		const provenance = trackProvenanceOf(frame);
 		for (const t of result.tracked) {
 			currentTrackIds.add(t.trackId);
 			if (this.suppressedBirths.isRejected(key, t.trackId)) continue;
@@ -89165,7 +90934,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					score: t.confidence
 				},
 				zones: t.zones,
-				state: t.state
+				state: t.state,
+				...provenance !== void 0 ? { provenance } : {}
 			});
 			positionsCountById.set(t.trackId, upserted.positions.length);
 		}