@camstack/addon-post-analysis 1.2.607 → 1.2.609

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-VgOXFRFr.js");
+const require_clip_model_registry = require("../clip-model-registry-B11yS32V.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -10281,6 +10281,7 @@ var NC_SYSTEM_STATE_LEGACY = "notification-center:system-state";
 var NC_OCCUPANCY_LEGACY = "notification-center:occupancy";
 var NC_DEVICE_PRUNES_LEGACY = "notification-center:device-prunes";
 var NC_STATE_SUMMARY_STAMPS_LEGACY = "notification-center:state-summary-stamps";
+var NC_ALERT_EPISODES_LEGACY = "notification-center:alert-episodes";
 var NC_META_LEGACY = "notification-center:meta";
 var NC_SNOOZES_LEGACY = "notification-center:snoozes";
 var NC_SNOOZE_SUPPRESSED_LEGACY = "notification-center:snooze-suppressed";
@@ -10301,6 +10302,7 @@ var ncDurableRecordKinds = require_clip_model_registry.defineRecordKinds({
 	liveness: ledger(NC_LIVENESS_LEGACY, "a liveness state TRANSITION the centre accepted (seed or flip); a no-flip writes nothing"),
 	"device-alerts": ledger(NC_DEVICE_ALERTS_LEGACY, "a sustained device alert episode the centre confirmed or cleared"),
 	"system-state": ledger(NC_SYSTEM_STATE_LEGACY, "a system-state subject flip the state summary accepted"),
+	"alert-episodes": ledger(NC_ALERT_EPISODES_LEGACY, "an alert episode the centre notified (critical or error); its resolution deletes the row"),
 	occupancy: ledger(NC_OCCUPANCY_LEGACY, "a confirmed occupancy level write-through after the watcher decided an edge"),
 	"device-prunes": ledger(NC_DEVICE_PRUNES_LEGACY, "one row recording what a deleted-device prune removed"),
 	"state-summary-stamps": ledger(NC_STATE_SUMMARY_STAMPS_LEGACY, "digest delivery stamps per rule kind"),
@@ -10320,6 +10322,7 @@ var NC_PHASE3_RECORD_BACKED_LEGACY_COLLECTIONS = [
 	NC_LIVENESS_LEGACY,
 	NC_DEVICE_ALERTS_LEGACY,
 	NC_SYSTEM_STATE_LEGACY,
+	NC_ALERT_EPISODES_LEGACY,
 	NC_OCCUPANCY_LEGACY,
 	NC_DEVICE_PRUNES_LEGACY,
 	NC_STATE_SUMMARY_STAMPS_LEGACY,
@@ -10741,6 +10744,120 @@ var NcAlertStore = class {
 	}
 };
 //#endregion
+//#region src/notification-center/alert-episode-ledger.ts
+/**
+* @durable class=ledger owner=notification-center
+*   write="an alert episode the centre notified (alert-critical / alert-error); its resolution deletes the row"
+*   retention="a row lives while its episode is open. A row whose alert was pruned by the alert centre's own retention is dropped after NC_ALERT_EPISODE_MAX_AGE_MS by the reconcile, never on absence alone (D49)."
+*/
+var NC_ALERT_EPISODES_COLLECTION = "notification-center:alert-episodes";
+var NC_ALERT_EPISODES_COLUMNS = [
+	{
+		name: "episodeId",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	(
+	/** The kind that was notified: `alert-critical` or `alert-error`. */
+	{
+		name: "kind",
+		type: "TEXT",
+		notNull: true
+	}),
+	{
+		name: "alertId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "since",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+/** Longer than the alert centre's maximum retention (365 days). */
+var NC_ALERT_EPISODE_MAX_AGE_MS = 400 * 24 * 60 * 60 * 1e3;
+function isEpisodeKind(value) {
+	return value === "alert-critical" || value === "alert-error";
+}
+var NC_ALERT_EPISODES_SPEC = {
+	collection: NC_ALERT_EPISODES_COLLECTION,
+	columns: NC_ALERT_EPISODES_COLUMNS,
+	writeMode: "write-behind",
+	keyOf: (row) => row.episodeId,
+	toValue: (row) => ({
+		kind: row.kind,
+		alertId: row.alertId,
+		since: row.since
+	}),
+	fromRecord: (key, data) => {
+		const kind = data["kind"];
+		const alertId = data["alertId"];
+		const since = data["since"];
+		if (!isEpisodeKind(kind) || typeof alertId !== "string" || typeof since !== "number") return null;
+		return {
+			episodeId: key,
+			kind,
+			alertId,
+			since
+		};
+	}
+};
+NC_ALERT_EPISODES_SPEC.fromRecord, NC_ALERT_EPISODES_SPEC.toValue;
+var NcAlertEpisodeLedger = class {
+	ledger;
+	constructor(deps) {
+		this.ledger = new DurableLedger({
+			spec: NC_ALERT_EPISODES_SPEC,
+			kind: resolveDurableKind(NC_ALERT_EPISODES_SPEC, ncDurableRecordKinds["alert-episodes"], deps),
+			logger: deps.logger
+		});
+	}
+	static declare(store) {
+		return declareDurableSpecLegacy(store, NC_ALERT_EPISODES_SPEC);
+	}
+	async load() {
+		return (await this.ledger.load()).length;
+	}
+	/** Has a load READ the store once? Until then the mirror is not the truth. */
+	hasAnswered() {
+		return this.ledger.hasAnswered();
+	}
+	has(episodeId) {
+		return this.ledger.has(episodeId);
+	}
+	snapshot() {
+		return this.ledger.snapshot();
+	}
+	/**
+	* Judge one announced edge and advance the ledger. Synchronous: the verdict
+	* is a function of the mirror (D49); the durable write trails it.
+	*/
+	admit(edge, now) {
+		const held = this.ledger.get(edge.episodeId);
+		if (edge.phase === "raised") {
+			if (edge.kind !== "alert-critical" && edge.kind !== "alert-error") return "duplicate";
+			if (held !== void 0 && (held.kind === "alert-critical" || edge.kind === "alert-error")) return "duplicate";
+			this.ledger.put({
+				episodeId: edge.episodeId,
+				kind: edge.kind,
+				alertId: edge.alertId,
+				since: held?.since ?? now
+			});
+			return "notify";
+		}
+		if (held === void 0) return "unknown-episode";
+		this.ledger.forget(edge.episodeId);
+		return held.kind === "alert-critical" && edge.kind === "alert-critical-resolved" ? "notify" : "closed-silently";
+	}
+	/** Drop rows older than the alert centre could still hold the alert. */
+	async pruneOlderThan(cutoffMs) {
+		const keep = new Set(this.ledger.snapshot().filter((row) => row.since >= cutoffMs).map((row) => row.episodeId));
+		return this.ledger.pruneExcept(keep);
+	}
+};
+//#endregion
 //#region src/notification-center/device-prune-ledger.ts
 /**
 * @durable class=ledger owner=notification-center
@@ -16026,6 +16143,34 @@ function bestMatchingKindPreference(signal, ownerKind) {
 }
 //#endregion
 //#region src/notification-center/event-intake.ts
+/**
+* The notification path's INTAKE SEAM — one event in, no knowledge of who
+* produced it.
+*
+* Why this file exists at all: until now every producer reached the centre
+* through its own record-shaped door (`onObjectEventPersisted(ObjectEvent)`,
+* `onSensorEventPersisted(SensorEvent)`, …). The doors did nothing but build a
+* subject and schedule an evaluation, yet their SIGNATURES made the notification
+* path look like a function of the pipeline's row types — so "notify about this"
+* was not expressible without first having a persisted row to hand.
+*
+* The split this file draws is between PRODUCING an event and CONSUMING one:
+*
+*   - The producer owns persistence. The tracker persists its tracks, the sensor
+*     ingest persists its rows, and a synthetic producer (the rule tester)
+*     persists NOTHING. Whether a row exists is the producer's business and
+*     never the consumer's.
+*   - The consumer owns match → media → delivery. It receives an
+*     {@link NcIncomingEvent} and cannot tell which producer built it, because
+*     the only thing the matcher can read is `subject`, and `subject` carries no
+*     provenance beyond the detection `source` a real record would carry anyway.
+*
+* {@link NcIncomingEvent.origin} exists for LOGS, and for the outbox row's
+* marker. It is deliberately NOT part of `NcRuleSubject`: a condition cannot
+* reach it, so no rule can be authored that behaves differently for a test. That
+* is the property the tester is worth nothing without — a test that takes a
+* different branch is a test of the branch, not of the rule.
+*/
 /** Object-event insert (movement-state transitions + zone crossings). */
 function incomingFromObjectEvent(event) {
 	return {
@@ -16869,9 +17014,45 @@ function incomingFromSystemEvent(event, lookup) {
 		case "system.restarting": return incomingFromNodeRestarting(facts, data);
 		case "recording.export.completed": return incomingFromExportCompleted(facts, data);
 		case "backup.run-completed": return incomingFromBackupCompleted(facts, data);
+		case "alert.episode": return incomingFromAlertEpisode(facts);
 		default: return null;
 	}
 }
+/**
+* An alert episode edge (`alert-critical`, `alert-error`, `alert-critical-resolved`).
+*
+* The WORDS are the alert's own: the alert centre composed the title and the
+* message when it opened the alert, and a rule's template may reword them with
+* `{{title}}`, `{{message}}`, `{{severity}}`, `{{category}}`, `{{source}}`,
+* `{{node}}` and `{{actionUrl}}`. The subject is the EPISODE, so the dedup slot
+* of a new episode is never the one a previous, resolved, episode held.
+*
+* Whether an edge is notified at all (once per episode, reconciled from the
+* alerts store) is decided before this point, by `NcAlertEpisodeLedger`.
+*/
+function incomingFromAlertEpisode(facts) {
+	const payload = require_clip_model_registry.parseAlertEpisodePayload(facts.data);
+	if (payload === null) return null;
+	const kind = require_clip_model_registry.alertEpisodeKind(payload.severity, payload.phase);
+	if (kind === null) return null;
+	return systemSubject({
+		facts,
+		kind,
+		subject: `alert:${payload.episodeId}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body`,
+		textParams: {
+			title: payload.title,
+			message: payload.message,
+			severity: payload.severity,
+			category: payload.category,
+			source: payload.sourceId ?? "",
+			nodeId: payload.nodeId ?? "",
+			actionUrl: payload.actionUrl ?? ""
+		},
+		...payload.nodeId !== void 0 ? { nodeId: payload.nodeId } : {}
+	});
+}
 /** The shells whose update has its own sentence. Anything else gets the plain
 *  one: a body that names a shell nobody observed is worse than a vague body. */
 var WRAPPER_BODY_KINDS = new Set([
@@ -19354,6 +19535,7 @@ async function declareNcPhase3SettingsStoreLegacyCollections(store) {
 async function declareNcPhase3RecordBackedLegacyCollections(store) {
 	await OccupancyStore.declare(store);
 	await NcLivenessLedger.declare(store);
+	await NcAlertEpisodeLedger.declare(store);
 	await NcAlertStore.declare(store);
 	await NcStateSummaryService.declare(store);
 	await NcSnoozeStore.declare(store);
@@ -22165,6 +22347,41 @@ function audioDbfsByBucket(events, since, bucketMs) {
 	}
 	return out;
 }
+/**
+* PEAK dBFS per bucket index from device-history points (D431 follow-up).
+*
+* The bar answers "was it loud here", so a bucket reports the loudest window
+* in it. A raw point has `max === value`; a rollup row's `max` is the loudest
+* point it covers, which a mean would flatten. A bucket with no point is
+* absent — never zero. A rollup row also credits a held value across a quiet
+* gap, so its max can echo an earlier measured peak.
+*/
+function audioPeakByBucket(points, since, bucketMs) {
+	const out = /* @__PURE__ */ new Map();
+	if (bucketMs <= 0) return out;
+	for (const p of points) {
+		if (!Number.isFinite(p.max)) continue;
+		const idx = Math.floor((p.t - since) / bucketMs);
+		if (idx < 0) continue;
+		const prev = out.get(idx);
+		if (prev === void 0 || p.max > prev) out.set(idx, p.max);
+	}
+	return out;
+}
+//#endregion
+//#region src/pipeline-analytics/store/analytics-history-keys.ts
+/** Declared addon series keys (D850). */
+var ANALYTICS_HISTORY_BUCKET_SERIES = {
+	motion: "addon:pipeline-analytics/motion",
+	"audio-dbfs": "addon:pipeline-analytics/audio-dbfs",
+	occupancy: "addon:pipeline-analytics/occupancy"
+};
+var ANALYTICS_AUDIO_LEVEL_KEY = "addon:pipeline-analytics/audio-level";
+/** Map the public cap enum to the device-history key (read path). */
+function historyKeyForLtsSeries(series) {
+	if (series === "battery") return "cap:battery.percentage";
+	return ANALYTICS_HISTORY_BUCKET_SERIES[series];
+}
 //#endregion
 //#region src/pipeline-analytics/store/event-store.ts
 /**
@@ -22537,6 +22754,24 @@ function eventRowId(logger, operation, deviceId, key) {
 	});
 	return null;
 }
+var RAW_RETENTION_MS = 7 * 864e5;
+var FIVE_MIN_RETENTION_MS = 14 * 864e5;
+var FIVE_MIN_MS = 3e5;
+var HOUR_MS$2 = 36e5;
+/** The producer writes one raw point per window of this length. */
+var AUDIO_LEVEL_POINT_MS = 1e4;
+var HISTORY_MAX_POINTS = 5e3;
+/**
+* Pick the device-history tier for a density window: raw while the buckets are
+* finer than the 5m rollup, the window is inside raw retention and its points
+* fit one query; the 5m rollup while inside its retention; else 1h.
+*/
+function audioLevelResolution(q, now) {
+	const rawFits = Math.ceil((q.until - q.since) / AUDIO_LEVEL_POINT_MS) <= HISTORY_MAX_POINTS;
+	if (q.bucketMs < FIVE_MIN_MS && rawFits && q.since >= now - RAW_RETENTION_MS) return "raw";
+	if (q.bucketMs < HOUR_MS$2 && q.since >= now - FIVE_MIN_RETENTION_MS) return "5m";
+	return "1h";
+}
 var EventStore = class EventStore {
 	store;
 	logger;
@@ -22544,6 +22779,10 @@ var EventStore = class EventStore {
 	audioLedger;
 	media;
 	onMotionSample;
+	audioLevelHistory;
+	nowFn;
+	/** Cameras whose history read already failed once (log once per camera, D315). */
+	levelFallbackLogged = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.store = deps.store;
 		this.logger = deps.logger;
@@ -22552,6 +22791,8 @@ var EventStore = class EventStore {
 		this.audioLedger = deps.audioLedger ?? wireAudioEventLedger(wiring);
 		this.media = deps.media;
 		this.onMotionSample = deps.onMotionSample;
+		this.audioLevelHistory = deps.audioLevelHistory;
+		this.nowFn = deps.now ?? (() => Date.now());
 	}
 	static async declareTracklessEventCollections(store) {
 		await store.declareCollection.mutate({
@@ -23280,8 +23521,8 @@ var EventStore = class EventStore {
 			const m = motionMap.get(i) ?? 0;
 			const o = objectMap.get(i) ?? 0;
 			const a = audioMap.get(i) ?? 0;
-			if (m + o + a === 0) continue;
 			const dbfs = audioDbfsMap.get(i);
+			if (m + o + a === 0 && dbfs === void 0) continue;
 			out.push({
 				bucketStart: q.since + i * q.bucketMs,
 				motion: m,
@@ -23302,6 +23543,28 @@ var EventStore = class EventStore {
 	* missing bar is the honest rendering of "not measured" (D431).
 	*/
 	async audioDbfsPerBucket(q) {
+		const history = this.audioLevelHistory;
+		if (history !== void 0) try {
+			const resolution = audioLevelResolution(q, this.nowFn());
+			const points = (await history({
+				deviceId: q.deviceId,
+				key: ANALYTICS_AUDIO_LEVEL_KEY,
+				scope: "",
+				from: q.since,
+				to: q.until,
+				resolution,
+				maxPoints: HISTORY_MAX_POINTS
+			})).series.flatMap((s) => s.points);
+			if (points.length > 0) return audioPeakByBucket(points, q.since, q.bucketMs);
+		} catch (err) {
+			if (!this.levelFallbackLogged.has(q.deviceId)) {
+				this.levelFallbackLogged.add(q.deviceId);
+				this.logger.warn("density: audio level history unreadable — falling back to audio events", {
+					tags: { deviceId: q.deviceId },
+					meta: { error: String(err) }
+				});
+			}
+		}
 		try {
 			return audioDbfsByBucket((await this.queryAudio({
 				deviceId: q.deviceId,
@@ -32881,6 +33144,12 @@ var en_default = {
 	"system.backup-completed.title": "Backup completed",
 	"system.backup-completed.body": "Backup saved to {{destinationsOk}} of {{destinationsTotal}} destinations ({{sizeMB}} MB)",
 	"system.backup-completed.body.partial": "Backup saved to {{destinationsOk}} of {{destinationsTotal}} destinations — {{destinationsFailed}} failed",
+	"system.alert-critical.title": "{{title}}",
+	"system.alert-critical.body": "{{message}}",
+	"system.alert-error.title": "{{title}}",
+	"system.alert-error.body": "{{message}}",
+	"system.alert-critical-resolved.title": "Resolved: {{title}}",
+	"system.alert-critical-resolved.body": "{{message}}",
 	"system.device-consumable-low.title": "Consumable low — {{deviceName}}",
 	"system.device-consumable-low.body": "{{item}} on {{deviceName}} is at {{percentage}}%",
 	"system.device-consumable-low.body.unmeasured": "{{item}} on {{deviceName}} needs replacing",
@@ -33261,6 +33530,12 @@ var it_default = {
 	"system.backup-completed.title": "Backup completato",
 	"system.backup-completed.body": "Backup salvato su {{destinationsOk}} destinazioni su {{destinationsTotal}} ({{sizeMB}} MB)",
 	"system.backup-completed.body.partial": "Backup salvato su {{destinationsOk}} destinazioni su {{destinationsTotal}} — {{destinationsFailed}} fallite",
+	"system.alert-critical.title": "{{title}}",
+	"system.alert-critical.body": "{{message}}",
+	"system.alert-error.title": "{{title}}",
+	"system.alert-error.body": "{{message}}",
+	"system.alert-critical-resolved.title": "Risolto: {{title}}",
+	"system.alert-critical-resolved.body": "{{message}}",
 	"system.device-consumable-low.title": "Consumabile basso — {{deviceName}}",
 	"system.device-consumable-low.body": "{{item}} su {{deviceName}} è al {{percentage}}%",
 	"system.device-consumable-low.body.unmeasured": "{{item}} su {{deviceName}} va sostituito",
@@ -35236,6 +35511,7 @@ function systemEventSubject(kind, scope) {
 	if (kind === "node-updating") return `node-updating:${scope.nodeId ?? "hub"}:1.0.1`;
 	if (kind === "export-completed") return `export:${scope.deviceId ?? 0}`;
 	if (kind === "backup-completed") return "backup:test";
+	if (kind.startsWith("alert-")) return "alert:test";
 	return `alarm:${scope.deviceId ?? 0}`;
 }
 /**
@@ -35376,7 +35652,12 @@ function planRuleTest(input) {
 					nodes: "hub",
 					fromVersion: "1.0.0",
 					toVersion: "1.0.1",
-					title: "Export",
+					title: systemEventKind.startsWith("alert-") ? "Recording location full" : "Export",
+					message: "No free space left on the recording location",
+					severity: systemEventKind === "alert-error" ? "error" : "critical",
+					category: "recorder.placement",
+					source: "recorder",
+					actionUrl: "/system/addons",
 					count: "1"
 				},
 				...systemScope.deviceId !== void 0 ? { deviceId: systemScope.deviceId } : {},
@@ -51962,6 +52243,10 @@ function groupedAlarmPhaseKey(ruleId, trackId) {
 var NO_MATCH_REPORT_INTERVAL_MS = 6e4;
 var DEFAULT_DRAIN_INTERVAL_MS = 2e3;
 var DEFAULT_RULE_RELOAD_INTERVAL_MS = 3e4;
+/** How often open critical/error alerts are reconciled against the notified episodes. */
+var NC_ALERT_RECONCILE_INTERVAL_MS = 5 * 6e4;
+/** The most alerts one reconcile reads (the alert centre's own ceiling). */
+var NC_ALERT_RECONCILE_LIMIT = 5e3;
 var DEFAULT_RECONCILE_WINDOW_MS = 15 * 6e4;
 /** Overlap subtracted from the watermark on boot (idempotent, cheap). */
 var RECONCILE_OVERLAP_MS = 6e4;
@@ -52534,6 +52819,15 @@ var NotificationCenter = class {
 	* seeds, only a real flip notifies.
 	*/
 	liveness;
+	/**
+	* Which alert episodes were already notified (`alert-episode-ledger.ts`): the
+	* alert centre sends nothing of its own, so this is what makes its bus
+	* announcements and the reconcile from the alerts store safe to run together.
+	*/
+	alertEpisodes;
+	/** The boot load of {@link alertEpisodes} has been ATTEMPTED (bus edges before it are the reconcile's). */
+	alertEpisodesLoaded = false;
+	alertReconcileTimer = null;
 	/** Batches `addon.updated` (version-bearing) into one notification per 30 s. */
 	addonUpdates;
 	/** Trailing 5 min hold-off for camera liveness flaps (plugin restart). */
@@ -53235,6 +53529,10 @@ var NotificationCenter = class {
 			...durableStore,
 			logger: this.logger.child("liveness")
 		});
+		this.alertEpisodes = new NcAlertEpisodeLedger({
+			...durableStore,
+			logger: this.logger.child("alert-episodes")
+		});
 		this.addonUpdates = new AddonUpdateCoalescer((updates) => {
 			const incoming = incomingFromAddonUpdates({
 				eventId: `addon-updated:${updates.map((u) => u.packageName).join(",")}`,
@@ -53631,6 +53929,10 @@ var NotificationCenter = class {
 		this.reloadTimer = setInterval(() => {
 			this.reloadRules();
 		}, this.deps.ruleReloadIntervalMs ?? DEFAULT_RULE_RELOAD_INTERVAL_MS);
+		this.alertReconcileTimer = setInterval(() => {
+			this.reconcileAlertEpisodes();
+		}, this.deps.alertReconcileIntervalMs ?? NC_ALERT_RECONCILE_INTERVAL_MS);
+		this.alertReconcileTimer.unref?.();
 		const timelapseScheduler = this.timelapseScheduler;
 		if (timelapseScheduler !== null) await timed("timelapseProducer", () => timelapseScheduler.start()).catch((err) => {
 			this.logger.warn("timelapse producer did not start", { meta: { error: String(err) } });
@@ -53746,6 +54048,7 @@ var NotificationCenter = class {
 			await this.deviceDirectory.refresh();
 		})) return;
 		if (!await phase("liveness", () => this.hydrateLiveness())) return;
+		if (!await phase("alertEpisodes", () => this.hydrateAlertEpisodes())) return;
 		if (!await phase("deviceAlerts", async () => {
 			const rows = await this.alertStore.load();
 			this.logger.info("device alert ledger reseeded", { meta: { rows } });
@@ -53788,6 +54091,10 @@ var NotificationCenter = class {
 			clearInterval(this.reloadTimer);
 			this.reloadTimer = null;
 		}
+		if (this.alertReconcileTimer !== null) {
+			clearInterval(this.alertReconcileTimer);
+			this.alertReconcileTimer = null;
+		}
 		this.timelapseScheduler?.stop();
 		this.summaryProducer?.stop();
 		await this.closeGroupedWindowsOnStop();
@@ -54799,6 +55106,10 @@ var NotificationCenter = class {
 			return;
 		}
 		this.stateSummary.observeRawEvent(event.category, event.data, this.now(), event.source.nodeId);
+		if (event.category === "alert.episode") {
+			if (this.alertEpisodesLoaded) this.admitAlertEpisode(event, "bus");
+			return;
+		}
 		if (event.category === "addon.started" || event.category === "addon.restarted") return;
 		if (event.category === "pipeline.camera-assigned") return;
 		const battery = batterySliceOf(event);
@@ -54832,10 +55143,6 @@ var NotificationCenter = class {
 		const system = incoming.subject.systemEvent;
 		if (system !== void 0) this.stateSummary.observeSystem(system, this.now());
 		if (system !== void 0) this.updateLandings.observe(system, this.now());
-		if (system !== void 0 && system.kind === "addon-crash-loop") {
-			this.logger.debug("addon-crash-loop is pushed by the hub alert centre, not by a rule", { meta: { subject: system.subject } });
-			return;
-		}
 		const observation = system !== void 0 ? ledgeredLiveness(system) : null;
 		if (observation !== null) {
 			const previous = this.liveness.stateOf(observation.subject);
@@ -57487,6 +57794,89 @@ var NotificationCenter = class {
 		await this.occupancyStore.pruneExcept(this.activeOccupancyKeys());
 	}
 	/**
+	* One edge of an alert episode, from the bus or from the reconcile. The
+	* ledger decides whether it is news; only news reaches the rules.
+	*/
+	admitAlertEpisode(event, via) {
+		const payload = require_clip_model_registry.parseAlertEpisodePayload(event.data);
+		if (payload === null) {
+			this.logger.warn("alert episode event with an unreadable payload ignored", { meta: {
+				via,
+				eventId: event.id
+			} });
+			return false;
+		}
+		const verdict = this.alertEpisodes.admit({
+			kind: require_clip_model_registry.alertEpisodeKind(payload.severity, payload.phase),
+			phase: payload.phase,
+			episodeId: payload.episodeId,
+			alertId: payload.alertId
+		}, this.now());
+		const meta = {
+			via,
+			alertId: payload.alertId,
+			episodeId: payload.episodeId,
+			phase: payload.phase,
+			severity: payload.severity,
+			verdict
+		};
+		if (verdict !== "notify") {
+			this.logger.debug("alert episode edge not notified", { meta });
+			return false;
+		}
+		const incoming = incomingFromSystemEvent(event, this.deviceDirectory.lookup());
+		if (incoming === null) return false;
+		this.logger.info("alert episode notified to the rules", { meta });
+		this.consumeEvent(incoming);
+		return true;
+	}
+	async hydrateAlertEpisodes() {
+		try {
+			const rows = await this.alertEpisodes.load();
+			this.logger.info("alert episode ledger reseeded", { meta: { rows } });
+		} finally {
+			this.alertEpisodesLoaded = true;
+		}
+		await this.reconcileAlertEpisodes();
+	}
+	/**
+	* The alerts store against the notified episodes (D11, D49): every OPEN
+	* critical/error alert not yet notified is notified, and every notified
+	* episode whose alert is CLOSED gets its resolution. Never runs on a ledger
+	* the store has not answered — an empty, unread mirror would re-notify every
+	* open alert — and never reads absence as closure: an alert that is not in
+	* the answer is left alone (rows age out by {@link NC_ALERT_EPISODE_MAX_AGE_MS}).
+	*/
+	async reconcileAlertEpisodes() {
+		const read = this.deps.readAlerts;
+		if (read === void 0 || !this.evaluationActive || !this.alertEpisodes.hasAnswered()) return;
+		let alerts;
+		try {
+			alerts = await read();
+		} catch (err) {
+			this.logger.warn("alert episode reconcile could not read the alerts", { meta: { error: require_clip_model_registry.errMsg(err) } });
+			return;
+		}
+		let notified = 0;
+		for (const alert of alerts) {
+			const episodeId = require_clip_model_registry.alertEpisodeId(alert);
+			const open = require_clip_model_registry.isAlertEpisodeOpen(alert.status);
+			if (open && !require_clip_model_registry.isAlertEpisodeSeverity(alert.severity)) continue;
+			if (!open && !this.alertEpisodes.has(episodeId)) continue;
+			const phase = open ? "raised" : "resolved";
+			if (this.admitAlertEpisode(require_clip_model_registry.createEvent(require_clip_model_registry.EventCategory.AlertEpisode, {
+				type: "addon",
+				id: "notification-center"
+			}, require_clip_model_registry.alertEpisodePayload(alert, phase, this.now())), "reconcile")) notified += 1;
+		}
+		const pruned = alerts.length < NC_ALERT_RECONCILE_LIMIT ? await this.alertEpisodes.pruneOlderThan(this.now() - NC_ALERT_EPISODE_MAX_AGE_MS) : 0;
+		if (notified > 0 || pruned > 0) this.logger.info("alert episodes reconciled", { meta: {
+			alerts: alerts.length,
+			notified,
+			pruned
+		} });
+	}
+	/**
 	* Boot reseed of the durable liveness ledger.
 	*
 	* The count is said OUT LOUD at info, because it is the one line that
@@ -94641,6 +95031,62 @@ function pickWritableMediaLocation(locations, stickyId) {
 	return writable.toSorted((a, b) => b.headroomBytes - a.headroomBytes || a.id.localeCompare(b.id))[0]?.id ?? null;
 }
 //#endregion
+//#region src/pipeline-analytics/event-media-write-location.ts
+var EventMediaWriteLocator = class {
+	deps;
+	cached = null;
+	/**
+	* The last location actually picked. Survives {@link invalidate}, so a ring
+	* keeps writing where it was writing while that stays writable — the
+	* stickiness the class default used to provide (D383).
+	*/
+	lastPick = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Drop the cached pick: the next write re-reads the location set. */
+	invalidate() {
+		this.cached = null;
+	}
+	async resolve(logger, deviceId) {
+		if (this.cached !== null) return this.cached;
+		let locations;
+		try {
+			locations = await this.deps.list();
+		} catch (err) {
+			logger.debug("pipeline-analytics: eventMedia location list unavailable — writing through the default ref", { meta: { error: require_clip_model_registry.errMsg(err) } });
+			this.cached = DEFAULT_MEDIA_LOCATION;
+			return DEFAULT_MEDIA_LOCATION;
+		}
+		const picked = pickWritableMediaLocation(locations.map((l) => ({
+			id: l.id,
+			mode: require_clip_model_registry.resolveLocationMode(l),
+			headroomBytes: l.capacity?.availableBytes ?? 0
+		})), this.lastPick ?? void 0);
+		if (picked === null) {
+			const seen = locations.length > 0 ? locations.map((l) => l.id).join(", ") : "(none registered)";
+			logger.error("pipeline-analytics: no writable eventMedia storage location — refusing the write instead of failing far downstream as a filesystem error", {
+				tags: { deviceId },
+				meta: { locationsSeen: seen }
+			});
+			throw new Error(`no writable eventMedia storage location (seen: ${seen})`);
+		}
+		this.cached = picked;
+		this.lastPick = picked;
+		return picked;
+	}
+};
+/**
+* Ring the locator from the location-set doorbell. `onRing` lets the caller drop
+* its other location-derived caches in the same breath.
+*/
+function subscribeEventMediaWriteLocator(eventBus, locator, onRing) {
+	return eventBus.subscribe({ category: require_clip_model_registry.EventCategory.StorageLocationsChanged }, () => {
+		locator.invalidate();
+		onRing();
+	});
+}
+//#endregion
 //#region src/pipeline-analytics/media-relocate-engine.ts
 /**
 * Event-media relocation engine (entity-routing spec, Phase 4) — the
@@ -104634,7 +105080,8 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_clip_model_registry.EventCategory.SystemRestartCompleted,
 	require_clip_model_registry.EventCategory.SystemRestarting,
 	require_clip_model_registry.EventCategory.RecordingExportCompleted,
-	require_clip_model_registry.EventCategory.BackupRunCompleted
+	require_clip_model_registry.EventCategory.BackupRunCompleted,
+	require_clip_model_registry.EventCategory.AlertEpisode
 ];
 /**
 * Install the addon's bus subscriptions. Identical set + relative order to the
@@ -107522,6 +107969,15 @@ Object.freeze({
 		"valueType": "boolean"
 	}],
 	"dishwasher": [
+		{
+			"path": "availability",
+			"valueType": "enum",
+			"enumValues": [
+				"available",
+				"offline",
+				"description-missing"
+			]
+		},
 		{
 			"path": "state",
 			"valueType": "enum",
@@ -107534,12 +107990,35 @@ Object.freeze({
 				"unavailable"
 			]
 		},
+		{
+			"path": "operationState",
+			"valueType": "enum",
+			"enumValues": [
+				"Inactive",
+				"Ready",
+				"DelayedStart",
+				"Run",
+				"Pause",
+				"ActionRequired",
+				"Finished",
+				"Error",
+				"Aborting"
+			]
+		},
 		{
 			"path": "program",
 			"valueType": "string"
 		},
 		{
-			"path": "remainingMinutes",
+			"path": "selectedProgram",
+			"valueType": "string"
+		},
+		{
+			"path": "remainingSeconds",
+			"valueType": "number"
+		},
+		{
+			"path": "delayedStartSeconds",
 			"valueType": "number"
 		},
 		{
@@ -107550,14 +108029,30 @@ Object.freeze({
 			"path": "doorOpen",
 			"valueType": "boolean"
 		},
+		{
+			"path": "doorLocked",
+			"valueType": "boolean"
+		},
 		{
 			"path": "remoteStartAllowed",
 			"valueType": "boolean"
 		},
+		{
+			"path": "remoteControlActive",
+			"valueType": "boolean"
+		},
+		{
+			"path": "localControlActive",
+			"valueType": "boolean"
+		},
 		{
 			"path": "powerOn",
 			"valueType": "boolean"
 		},
+		{
+			"path": "powerState",
+			"valueType": "string"
+		},
 		{
 			"path": "saltLevel",
 			"valueType": "enum",
@@ -111141,20 +111636,6 @@ var MigrationMarkerStore = class MigrationMarkerStore {
 	};
 };
 //#endregion
-//#region src/pipeline-analytics/store/analytics-history-keys.ts
-/** Declared addon series keys (D850). */
-var ANALYTICS_HISTORY_BUCKET_SERIES = {
-	motion: "addon:pipeline-analytics/motion",
-	"audio-dbfs": "addon:pipeline-analytics/audio-dbfs",
-	occupancy: "addon:pipeline-analytics/occupancy"
-};
-var ANALYTICS_AUDIO_LEVEL_KEY = "addon:pipeline-analytics/audio-level";
-/** Map the public cap enum to the device-history key (read path). */
-function historyKeyForLtsSeries(series) {
-	if (series === "battery") return "cap:battery.percentage";
-	return ANALYTICS_HISTORY_BUCKET_SERIES[series];
-}
-//#endregion
 //#region src/pipeline-analytics/store/analytics-history-producer.ts
 var BUCKET_SERIES_META = [
 	{
@@ -111176,6 +111657,10 @@ var AUDIO_LEVEL_SERIES = {
 	displayName: "Audio level (dBFS)",
 	unit: "dBFS"
 };
+/** One audio level point per window; equals device-history's 1 point / 10 s record bound. */
+var AUDIO_LEVEL_WINDOW_MS = 1e4;
+/** Stored for a measured-silent window (−∞ dBFS cannot be a history value). */
+var AUDIO_LEVEL_SILENT_DBFS = -120;
 function refusalCounts(result) {
 	const counts = {};
 	for (const r of result.refused) counts[r.reason] = (counts[r.reason] ?? 0) + r.count;
@@ -111187,6 +111672,7 @@ var AnalyticsHistoryProducer = class {
 	logger;
 	nowFn;
 	declared = false;
+	levelWindows = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deviceHistory = deps.deviceHistory;
 		this.logger = deps.logger;
@@ -111219,6 +111705,43 @@ var AnalyticsHistoryProducer = class {
 			deviceId
 		}, scope ?? "", value, at ?? this.nowFn());
 	}
+	/**
+	* Feed EVERY analysed audio sample. One point per window of
+	* {@link AUDIO_LEVEL_WINDOW_MS} is written, stamped at the window's first
+	* sample, carrying the window's PEAK dBFS: a 2 s spike inside a stable window
+	* is not averaged away, and stable audio still yields a point each window
+	* (continuity over dedup — the level bar draws a continuous line).
+	*
+	* Measured silence (−∞) is stored at {@link AUDIO_LEVEL_SILENT_DBFS}: it is a
+	* measurement, not an absence (D431); NaN carries no claim and is dropped.
+	* A window closes on the first sample past its end, so no timer is needed and
+	* points are always at least a window apart (the history's 1 point / 10 s
+	* bound).
+	*/
+	observeAudioLevel(deviceId, dbfs, at) {
+		if (Number.isNaN(dbfs)) return;
+		const value = Number.isFinite(dbfs) ? dbfs : AUDIO_LEVEL_SILENT_DBFS;
+		const win = this.levelWindows.get(deviceId);
+		if (win === void 0) {
+			this.levelWindows.set(deviceId, {
+				start: at,
+				peak: value
+			});
+			return;
+		}
+		if (at - win.start < AUDIO_LEVEL_WINDOW_MS) {
+			if (value > win.peak) this.levelWindows.set(deviceId, {
+				start: win.start,
+				peak: value
+			});
+			return;
+		}
+		this.levelWindows.set(deviceId, {
+			start: at,
+			peak: value
+		});
+		this.recordAudioLevel(deviceId, win.peak, win.start);
+	}
 	recordAudioLevel(deviceId, dbfs, at) {
 		const record = this.deviceHistory.record;
 		if (record === void 0) return;
@@ -113879,20 +114402,13 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	mediaRelocate = null;
 	mediaLocationStorage = null;
 	/**
-	* Cached pick for NEW `eventMedia` writes (`pickWritableMediaLocation`).
-	* Resolved once, never per blob (no-RPC-per-blob, same discipline as
-	* `mediaLocationStorage`'s own root cache) — dropped together with it by
-	* `refreshStorageLocationsForMigration`, since a location's `readOnly` /
-	* `enabled` flags only change via operator reconfig.
-	*/
-	eventMediaWriteLocationCache = null;
-	/**
-	* The last location this process actually picked for an `eventMedia` write.
-	* Survives the cache invalidation a migration performs, so a refresh keeps
-	* writing where it was writing while that stays writable — the stickiness the
-	* class default used to provide before it was deleted (D383).
+	* Where NEW `eventMedia` writes land. Its pick is cached per location-set
+	* generation and dropped by the `StorageLocationsChanged` doorbell (D387) and
+	* by `refreshStorageLocationsForMigration`, so a mode change or a repoint takes
+	* effect without a restart.
 	*/
-	lastEventMediaWritePick = null;
+	eventMediaWriteLocator = null;
+	eventMediaLocationDoorbellUnsub = null;
 	mediaWriteGate = new MediaWriteGate();
 	storageMigrationLeaseId = null;
 	/** Per-camera history of LINKED-device sensor state changes (Part B). */
@@ -115932,33 +116448,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	}
 	/** One line per process: this repeats on every occupancy refresh otherwise. */
 	mediaOccupancyUnattributedLogged = false;
-	async resolveEventMediaWriteLocation(api, logger, deviceId) {
-		const cached = this.eventMediaWriteLocationCache;
-		if (cached !== null) return cached;
-		let locations;
-		try {
-			locations = await api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION });
-		} catch (err) {
-			logger.debug("pipeline-analytics: eventMedia location list unavailable — writing through the default ref", { meta: { error: require_clip_model_registry.errMsg(err) } });
-			this.eventMediaWriteLocationCache = DEFAULT_MEDIA_LOCATION;
-			return DEFAULT_MEDIA_LOCATION;
-		}
-		const picked = pickWritableMediaLocation(locations.map((l) => ({
-			id: l.id,
-			mode: require_clip_model_registry.resolveLocationMode(l),
-			headroomBytes: l.capacity?.availableBytes ?? 0
-		})), this.lastEventMediaWritePick ?? void 0);
-		if (picked === null) {
-			const seen = locations.length > 0 ? locations.map((l) => l.id).join(", ") : "(none registered)";
-			logger.error("pipeline-analytics: no writable eventMedia storage location — refusing the write instead of failing far downstream as a filesystem error", {
-				tags: { deviceId },
-				meta: { locationsSeen: seen }
-			});
-			throw new Error(`no writable eventMedia storage location (seen: ${seen})`);
-		}
-		this.eventMediaWriteLocationCache = picked;
-		this.lastEventMediaWritePick = picked;
-		return picked;
+	resolveEventMediaWriteLocation(api, logger, deviceId) {
+		this.eventMediaWriteLocator ??= new EventMediaWriteLocator({ list: () => api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION }) });
+		return this.eventMediaWriteLocator.resolve(logger, deviceId);
 	}
 	/** Constructs every SQLite-backed store plus the stationary/package-drop/
 	*  sensor plumbing, in the exact pre-S7 order. Returns the non-null bundle
@@ -116059,6 +116551,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			resolveEventMediaLocation: (deviceId) => this.resolveEventMediaWriteLocation(api, logger, deviceId)
 		});
 		this.mediaStore = mediaStore;
+		this.eventMediaWriteLocator ??= new EventMediaWriteLocator({ list: () => api.storage.listLocations.query({ type: DEFAULT_MEDIA_LOCATION }) });
+		this.eventMediaLocationDoorbellUnsub?.();
+		this.eventMediaLocationDoorbellUnsub = subscribeEventMediaWriteLocator(this.ctx.eventBus, this.eventMediaWriteLocator, () => this.mediaLocationStorage?.invalidateRoots());
 		const eventLedgerWiring = this.eventLedgerWiring(api.settingsStore);
 		const retrainFrames = new RetrainFrameStore({
 			store: api.settingsStore,
@@ -116209,6 +116704,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		const eventStore = new EventStore({
 			store: api.settingsStore,
 			logger: logger.child("EventStore"),
+			audioLevelHistory: (input) => api.deviceHistory.query.query(input),
 			motionLedger: wireMotionEventLedger(eventLedgerWiring),
 			audioLedger: wireAudioEventLedger(eventLedgerWiring),
 			onMotionSample: (deviceId, regionCount, at) => lts.note("motion", deviceId, regionCount, at),
@@ -116641,6 +117137,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				coreBlocks: async () => (await api.coreBlocks.list.query({})).blocks,
 				nodeAddons: (nodeId) => api.nodes.getNodeAddons.query({ nodeId })
 			},
+			readAlerts: () => api.alerts.list.query({ limit: 5e3 }),
 			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
 			recognitionOutlook: ({ deviceId, trackId, className, labelKind, now }) => recognitionOutlook({
 				className,
@@ -118654,6 +119151,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		this.alarmPanelConvergence?.stop();
 		this.alarmPanelConvergence = null;
 		for (const unsub of this.subscriptionUnsubs) unsub();
+		this.eventMediaLocationDoorbellUnsub?.();
+		this.eventMediaLocationDoorbellUnsub = null;
 		this.subscriptionUnsubs = [];
 		await Promise.all([this.drainSensorHandlers(), this.motionEpisodes?.closeAll("addon-shutdown")]);
 		await this.settleTrackFusions();
@@ -121681,6 +122180,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				score: topClassification.score
 			} : {}
 		}, this.audioMarkerConfig(settings));
+		if (level !== void 0) this.lts?.observeAudioLevel(deviceId, level.dbfs, timestamp);
 		this.notificationCenter?.observeAudio(deviceId, ncAudioSampleFromFrame(frame, timestamp, settings));
 		const route = classifyAudioFrame(topClassification ? {
 			className: topClassification.macroClass,
@@ -121756,8 +122256,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 		this.levelStateByDevice.set(deviceId, res.nextState);
 		if (!res.emit) return;
-		const dbfs = level?.dbfs ?? Number.NEGATIVE_INFINITY;
-		this.lts?.recordAudioLevel(deviceId, dbfs, timestamp);
 	}
 	/**
 	* Persist motion-analysis bus events into the EPISODE tracker (D475): a
@@ -125908,7 +126406,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async refreshStorageLocationsForMigration(input) {
 		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
 		this.mediaLocationStorage?.invalidateRoots();
-		this.eventMediaWriteLocationCache = null;
+		this.eventMediaWriteLocator?.invalidate();
 		return { refreshed: true };
 	}
 	/**
@@ -126271,7 +126769,24 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async startStorageMigrationMove(input) {
 		if (!this.mediaRelocate) throw new Error("media relocation unavailable");
 		if (this.storageMigrationLeaseId !== input.leaseId) throw new Error("event-media storage migration lease does not match");
-		return { jobId: this.mediaRelocate.start(input) };
+		return { jobId: await this.startMediaMover(input) };
+	}
+	/**
+	* Start a media move only while no single-location repoint holds an overlapping
+	* physical root (the storage orchestrator owns that claim). A shared recordings
+	* root is the case: a repoint of another class there must not run beside us.
+	*/
+	startMediaMover(input) {
+		const engine = this.mediaRelocate;
+		if (!engine) throw new Error("media relocation unavailable");
+		return require_clip_model_registry.startMoverUnderClearance({
+			clearance: (locationIds) => this.ctx.api.storageMigration.moverClearance.query({ locationIds }),
+			start: () => engine.start(input),
+			cancel: (jobId) => {
+				engine.cancel(jobId);
+			},
+			locationIds: [input.fromLocationId ?? "*", input.toLocationId]
+		});
 	}
 	async getStorageMigrationMoveStatus(input) {
 		return this.mediaRelocate?.list().find((job) => job.jobId === input.jobId) ?? null;
@@ -126289,7 +126804,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	*/
 	async relocateMedia(input) {
 		if (!this.mediaRelocate) throw new Error("media relocation unavailable");
-		const jobId = this.mediaRelocate.start(input);
+		const jobId = await this.startMediaMover(input);
 		this.ctx.logger.info("pipeline-analytics: media relocate job enqueued", { meta: {
 			jobId,
 			mode: input.mode ?? "move",