@camstack/addon-post-analysis 1.2.621 → 1.2.623

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-CcgzpELQ.js");
+const require_clip_model_registry = require("../clip-model-registry-KKT83z9U.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -5402,40 +5402,118 @@ async function notificationLinkEndpoints(api, logger) {
 */
 var NC_TRACKS_AT_INSTANT_LIMIT = 25;
 /**
-* Every source track with a position within `toleranceMs` of `timestamp`, its
-* nearest box normalised, deduplicated by track id (a live copy and a
-* persisted copy of one track are one track). Pure.
+* How far outside its own life a track may still be drawn: one detection tick.
+*
+* The box TOLERANCE (`toleranceMs`, 750 ms) is about how sparse a trail is —
+* a live track keeps a position every few frames — and it must never stretch
+* a LIFE. A track born after the frame was not on it: on 2026-10-22 the
+* tracker split a dog on camera 615 and the second piece, born 676 ms after
+* the key frame, was drawn at its first box as a second box on the dog. One
+* tick (~110–150 ms at that camera's detection rate, rounded up) absorbs the
+* gap between a frame and the detection that confirmed it, and nothing more.
+*/
+var NC_TRACK_LIFE_SLACK_MS = 200;
+/**
+* A position this close to the instant is drawn as it is: one detection tick,
+* the same notion as {@link NC_TRACK_LIFE_SLACK_MS}. Anything farther is a
+* position of a MOVED subject, so it is either interpolated (a position on
+* each side inside the tolerance) or the track is left out — never drawn at a
+* later place than it was at the picture's instant.
+*/
+var NC_BOX_EXACT_MS = NC_TRACK_LIFE_SLACK_MS;
+/** The box at `timestamp`: a near position as is, else the bracketing pair interpolated. */
+function boxAt(positions, timestamp, toleranceMs) {
+	let nearest = null;
+	let before = null;
+	let after = null;
+	for (const p of positions) {
+		const d = p.timestamp - timestamp;
+		if (nearest === null || Math.abs(d) < Math.abs(nearest.timestamp - timestamp)) nearest = p;
+		if (d <= 0 && (before === null || p.timestamp > before.timestamp)) before = p;
+		if (d >= 0 && (after === null || p.timestamp < after.timestamp)) after = p;
+	}
+	if (nearest === null) return null;
+	const dt = nearest.timestamp - timestamp;
+	if (Math.abs(dt) <= NC_BOX_EXACT_MS) return {
+		bbox: nearest.bbox,
+		score: nearest.score,
+		dtMs: dt,
+		interpolated: false
+	};
+	if (before === null || after === null || timestamp - before.timestamp > toleranceMs || after.timestamp - timestamp > toleranceMs) return null;
+	const span = after.timestamp - before.timestamp;
+	const f = span === 0 ? 0 : (timestamp - before.timestamp) / span;
+	const lerp = (a, b) => a + (b - a) * f;
+	return {
+		bbox: {
+			x: lerp(before.bbox.x, after.bbox.x),
+			y: lerp(before.bbox.y, after.bbox.y),
+			w: lerp(before.bbox.w, after.bbox.w),
+			h: lerp(before.bbox.h, after.bbox.h)
+		},
+		score: nearest.score,
+		dtMs: dt,
+		interpolated: true
+	};
+}
+/**
+* Every source track ALIVE at `timestamp` (± {@link NC_TRACK_LIFE_SLACK_MS})
+* with a box AT that instant: a trail position within {@link NC_BOX_EXACT_MS},
+* else the linear interpolation of the positions bracketing it (each within
+* `toleranceMs`). A track with neither is not drawn — `onDrop` names it.
+* Deduplicated by track id (a live copy and a persisted copy are one track).
+* Pure.
 */
-function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims) {
+function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims, onDrop) {
 	const out = /* @__PURE__ */ new Map();
 	for (const track of sources) {
 		if (out.has(track.trackId)) continue;
-		if (track.firstSeen > timestamp + toleranceMs || track.lastSeen < timestamp - toleranceMs) continue;
+		if (track.firstSeen > timestamp + NC_TRACK_LIFE_SLACK_MS || track.lastSeen < timestamp - NC_TRACK_LIFE_SLACK_MS) {
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "outside-life"
+			});
+			continue;
+		}
 		const w = track.frameWidth ?? fallbackDims?.w ?? 0;
 		const h = track.frameHeight ?? fallbackDims?.h ?? 0;
-		if (w <= 0 || h <= 0) continue;
-		let best = null;
-		let bestDelta = Number.POSITIVE_INFINITY;
-		for (const p of track.positions) {
-			const delta = Math.abs(p.timestamp - timestamp);
-			if (delta < bestDelta) {
-				bestDelta = delta;
-				best = p;
-			}
+		if (w <= 0 || h <= 0) {
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "no-frame-dims"
+			});
+			continue;
+		}
+		const at = boxAt(track.positions, timestamp, toleranceMs);
+		if (at === null) {
+			const nearestDtMs = track.positions.reduce((best, p) => {
+				const d = p.timestamp - timestamp;
+				return best === void 0 || Math.abs(d) < Math.abs(best) ? d : best;
+			}, void 0);
+			onDrop?.({
+				trackId: track.trackId,
+				className: track.className,
+				reason: "no-position-near-instant",
+				...nearestDtMs !== void 0 ? { nearestDtMs } : {}
+			});
+			continue;
 		}
-		if (best === null || bestDelta > toleranceMs) continue;
 		const label = track.subLabel ?? track.label;
 		out.set(track.trackId, {
 			trackId: track.trackId,
 			className: track.className,
 			...label !== void 0 && label !== track.className ? { label } : {},
-			...best.score !== void 0 ? { confidence: best.score } : {},
+			...at.score !== void 0 ? { confidence: at.score } : {},
 			bbox: {
-				x: best.bbox.x / w,
-				y: best.bbox.y / h,
-				w: best.bbox.w / w,
-				h: best.bbox.h / h
-			}
+				x: at.bbox.x / w,
+				y: at.bbox.y / h,
+				w: at.bbox.w / w,
+				h: at.bbox.h / h
+			},
+			dtMs: at.dtMs,
+			interpolated: at.interpolated
 		});
 	}
 	return [...out.values()];
@@ -19337,11 +19415,16 @@ var DebugNoteArchiveStore = class {
 };
 //#endregion
 //#region src/pipeline-analytics/store/event-ledger-collection.ts
+/**
+* One event ledger (motion, audio, sensor, faces, plates …) over its
+* `ctx.records` kind. Every node has `ctx.records`, so there is no other path.
+*/
 /** Matches {@link EventStore.LEDGER_PAGE_SIZE} — kept local to avoid a circular import. */
 var LEDGER_PAGE_SIZE = 500;
 var EventLedgerCollection = class EventLedgerCollection {
 	collection;
 	kind;
+	records;
 	autoIntegerId;
 	legacyAtField;
 	deviceIdMode;
@@ -19357,6 +19440,7 @@ var EventLedgerCollection = class EventLedgerCollection {
 		this.logger = deps.logger;
 		this.deriveBody = deps.deriveBody;
 		this.indexFields = deps.definition.declaration.indexes.map((i) => i.fields);
+		this.records = deps.records;
 		const handle = deps.records.kind(deps.definition);
 		this.kind = handle;
 	}
@@ -19375,6 +19459,31 @@ var EventLedgerCollection = class EventLedgerCollection {
 		}
 		await this.kind.put(put);
 	}
+	/**
+	* `upsertRow` as an op of {@link EventLedgerCollection.transact}. A row that
+	* cannot be mapped THROWS here: inside a transaction a silently skipped write
+	* would let the rest of the call commit without it.
+	*/
+	async txUpsert(id, value) {
+		const put = this.buildRecordPut(id, value);
+		if (put === null) throw new require_clip_model_registry.InvalidRecordError(`${this.collection}/${id}: the record could not be mapped`);
+		return this.kind.txPut(put);
+	}
+	/** `update` as an op of {@link EventLedgerCollection.transact}. */
+	txUpdate(id, patch) {
+		return this.kind.txPatch(id, this.derived(patch, "patch"));
+	}
+	/** `deleteKey` as an op of {@link EventLedgerCollection.transact}. */
+	txDelete(id) {
+		return this.kind.txDelete(id);
+	}
+	/**
+	* Run ops (built by the `tx*` methods of ledgers whose kinds share a
+	* `transactFamily`) in ONE transaction: all land or none does.
+	*/
+	transact(ops) {
+		return this.records.transact(ops);
+	}
 	async insert(record) {
 		const idNum = this.autoIntegerId ? await this.kind.allocateId() : null;
 		const id = idNum !== null ? String(idNum) : typeof record["id"] === "string" ? record["id"] : null;
@@ -20451,8 +20560,8 @@ var FACE_REF_COLUMNS = ["deviceId"];
 * D312) a predicate that silently matched nothing. The faces ledger therefore derives a
 * boolean `recognized` from every write that touches `recognizedIdentityId`
 * (`face-recognized.ts`), and the views are plain ranges over the `recognized_ts` /
-* `assigned_recognized_ts` indexes. A row written before the field existed lacks it until
-* `scripts/hub/backfill-faces-recognized.ts` has run.
+* `assigned_recognized_ts` indexes. Rows written before the field existed were
+* backfilled offline on the operator hubs on 2026-10-22 (the one-shot script is deleted).
 *
 * `assigned` is `BOOLEAN NOT NULL`; the backend serialises `false` to `0` at
 * the bind (`serializeColumnValue`) and decodes `0` back to `false` on read, so
@@ -22316,8 +22425,9 @@ var RetrainAnnotationStore = class {
 	* The old rows' deletion, the new rows, the frame's `dismissed` set and its
 	* bumped `revision` run under a per-frame commit lock, guarded by
 	* `commit.fromRevision`: a concurrent save in this process leaves one winner
-	* and one `conflict` — never a blend. The steps are separate records writes,
-	* so a crash between them is NOT rolled back.
+	* and one `conflict` — never a blend. The deletion, the new rows and the frame
+	* row are ONE records `transact` (the four retrain kinds share a family): a
+	* failure leaves the frame exactly as it was.
 	*
 	* Returns the persisted rows so the caller renders ids it can address.
 	*/
@@ -22434,21 +22544,14 @@ var RetrainAnnotationStore = class {
 		}
 		return stamped;
 	}
-	/** Remove every annotation of a frame — the operator un-selecting it. */
-	async deleteForFrame(mediaKey) {
-		const rows = await this.listByFrame(mediaKey);
-		for (const row of rows) try {
-			await this.annotations.deleteKey(row.id);
-		} catch (err) {
-			this.logger.warn("retrain annotation delete failed", {
-				tags: { deviceId: row.deviceId },
-				meta: {
-					annotationId: row.id,
-					error: String(err)
-				}
-			});
-		}
-		return rows.length;
+	/**
+	* The delete ops of every annotation of a frame, for ONE transaction with
+	* the frame row and its memberships (RetrainService.removeFrame). A failed
+	* read THROWS: "no annotations" must never be the answer to an unreadable
+	* store, because the frame row would then be deleted over live boxes.
+	*/
+	async deleteOpsForFrame(mediaKey) {
+		return (await this.annotations.query({ where: { mediaKey } })).map((row) => this.annotations.txDelete(row.id));
 	}
 	async replaceForFrameOnRecords(mediaKey, rows, commit, nextRevision) {
 		const frame = await this.frames.get(mediaKey);
@@ -22461,12 +22564,14 @@ var RetrainAnnotationStore = class {
 			kind: "conflict",
 			currentRevision
 		};
-		await this.annotations.deleteWhere({ where: { mediaKey } });
-		for (const row of rows) await this.annotations.upsertRow(row.id, this.toRecord(row));
-		await this.frames.update(mediaKey, {
+		const ops = [];
+		for (const existing of await this.annotations.query({ where: { mediaKey } })) ops.push(this.annotations.txDelete(existing.id));
+		for (const row of rows) ops.push(await this.annotations.txUpsert(row.id, this.toRecord(row)));
+		ops.push(await this.frames.txUpdate(mediaKey, {
 			revision: nextRevision,
 			...commit.dismissed !== void 0 ? { dismissed: [...commit.dismissed] } : {}
-		});
+		}));
+		await this.frames.transact(ops);
 		return {
 			kind: "saved",
 			rows,
@@ -22484,8 +22589,10 @@ var RetrainAnnotationStore = class {
 			kind: "conflict",
 			currentRevision
 		};
-		for (const row of eligible) await this.annotations.update(row.id, { origin: origins.get(row.id) ?? null });
-		await this.frames.update(mediaKey, { revision: nextRevision });
+		const ops = [];
+		for (const row of eligible) ops.push(await this.annotations.txUpdate(row.id, { origin: origins.get(row.id) ?? null }));
+		ops.push(await this.frames.txUpdate(mediaKey, { revision: nextRevision }));
+		await this.frames.transact(ops);
 		return {
 			kind: "updated",
 			updated: eligible.length,
@@ -22656,16 +22763,16 @@ var RetrainCollectionStore = class {
 			}, counts.get(input.id) ?? 0)
 		};
 	}
-	/** Remove the collection and its memberships — members first, so a crash
-	*  never leaves memberships pointing at a name that no longer exists. */
+	/** Remove the collection and its memberships in ONE transaction: a failure
+	*  leaves the collection with all its members, never memberships pointing at
+	*  a name that no longer exists, nor a collection that silently lost some. */
 	async delete(id) {
 		if (await this.readRow(id) === null) return {
 			deleted: false,
 			memberFrameIds: []
 		};
 		const members = await this.memberships.query({ where: { collectionId: id } });
-		for (const m of members) await this.memberships.deleteKey(m.id);
-		await this.collections.deleteKey(id);
+		await this.collections.transact([...members.map((m) => this.memberships.txDelete(m.id)), this.collections.txDelete(id)]);
 		this.logger.info("retrain collection deleted", { meta: {
 			collectionId: id,
 			members: members.length
@@ -22694,11 +22801,29 @@ var RetrainCollectionStore = class {
 		await this.memberships.deleteKey(key);
 		return true;
 	}
-	/** Remove a frame from EVERY collection — the frame itself is leaving. */
-	async forgetFrame(frameId) {
-		const rows = await this.membershipRows({ frameId });
-		for (const r of rows) await this.memberships.deleteKey(r.id);
-		return rows.length;
+	/**
+	* The delete ops of every membership of a frame, for ONE transaction with
+	* the frame row and its annotations (RetrainService.removeFrame). A failed
+	* read THROWS: the frame row must not be deleted over memberships nobody
+	* could list.
+	*/
+	async forgetFrameOps(frameId) {
+		return (await this.memberships.query({ where: { frameId } })).map((r) => this.memberships.txDelete(r.id));
+	}
+	/**
+	* The op that adds a frame to a collection, for ONE transaction with the
+	* frame's own row (a still stored from the recording). `null` when it is
+	* already a member: there is nothing to write.
+	*/
+	async addFrameOp(input) {
+		const key = membershipKey(input.collectionId, input.frameId);
+		if (await this.memberships.get(key) !== null) return null;
+		return this.memberships.txUpsert(key, {
+			collectionId: input.collectionId,
+			frameId: input.frameId,
+			deviceId: input.deviceId,
+			addedAt: this.now()
+		});
 	}
 	/** The frames of a collection, in the order they were added. */
 	async listFrameIds(collectionId) {
@@ -23290,7 +23415,7 @@ var RetrainFrameStore = class {
 	* returned untouched; the blob lands before the row; a refusal is named.
 	* `capturedAt` IS the instant — the camera saw this frame then.
 	*/
-	async storeRecordingStill(input) {
+	async storeRecordingStill(input, withRow = []) {
 		const frameId = recordingFrameId(input.deviceId, input.epochMs);
 		const existing = await this.get(frameId);
 		if (existing !== null) return {
@@ -23337,7 +23462,7 @@ var RetrainFrameStore = class {
 				relativePath: path,
 				data: input.bytes
 			});
-			await this.ledger.upsertRow(frameId, {
+			const row = await this.ledger.txUpsert(frameId, {
 				deviceId: frame.deviceId,
 				trackId: "",
 				sourceMediaId: 0,
@@ -23354,6 +23479,7 @@ var RetrainFrameStore = class {
 				origin: "recording",
 				epochMs: input.epochMs
 			});
+			await this.ledger.transact([row, ...withRow]);
 		};
 		try {
 			if (this.writeGate) await this.writeGate.run(persist);
@@ -23407,22 +23533,33 @@ var RetrainFrameStore = class {
 	/**
 	* Drop a copy and its blob — the operator un-selecting a frame.
 	*
-	* The caller must have removed the frame's annotations first; this store does
-	* not cascade, because a store that deletes rows in another table on a
-	* best-effort write is how a half-deleted annotation set happens.
+	* The ROW goes first, in one transaction with `withRow` (the frame's
+	* annotations and collection memberships, which the caller builds): a failure
+	* leaves the frame, its boxes and its memberships all in place, and throws.
+	* The blob goes after: if that fails the row is already gone and the bytes
+	* are reclaimable junk, logged, never a row pointing at missing media.
 	*/
-	async deleteFrame(frame) {
+	async deleteFrame(frame, withRow = []) {
 		const remove = async () => {
+			try {
+				await this.ledger.transact([...withRow, this.ledger.txDelete(frame.frameId)]);
+			} catch (err) {
+				this.logger.error("retrain frame delete failed; nothing was removed", {
+					tags: { deviceId: frame.deviceId },
+					meta: {
+						frameId: frame.frameId,
+						error: String(err)
+					}
+				});
+				throw err;
+			}
 			try {
 				await this.storage.delete({
 					location: frame.locationId ?? LEGACY_RETRAIN_MEDIA_LOCATION,
 					relativePath: framePath(frame)
 				});
-			} catch {}
-			try {
-				await this.ledger.deleteKey(frame.frameId);
 			} catch (err) {
-				this.logger.warn("RetrainFrameStore.deleteFrame row delete failed", {
+				this.logger.warn("retrain frame removed but its blob could not be deleted", {
 					tags: { deviceId: frame.deviceId },
 					meta: {
 						frameId: frame.frameId,
@@ -28418,7 +28555,9 @@ function incomingFromSystemEvent(event, lookup) {
 			const blindForMs = numberField(data, "blindForMs");
 			if (deviceId === void 0 || blindForMs === void 0) return null;
 			const identity = lookup(deviceId);
-			const minutes = Math.max(1, Math.round(blindForMs / 6e4));
+			const motionMs = numberField(data, "motionMs") ?? blindForMs;
+			const sessions = numberField(data, "sessions") ?? 1;
+			const minutes = Math.max(1, Math.round(motionMs / 6e4));
 			return systemSubject({
 				facts,
 				kind: "detection-blind",
@@ -28427,13 +28566,39 @@ function incomingFromSystemEvent(event, lookup) {
 				bodyKey: "system.detection-blind.body",
 				textParams: {
 					...deviceTextParams(deviceId, identity),
-					minutes: String(minutes)
+					minutes: String(minutes),
+					sessions: String(sessions)
 				},
 				textCount: minutes,
 				deviceId,
 				...identity !== void 0 ? { deviceType: identity.type } : {}
 			});
 		}
+		case "pipeline.motion-noisy":
+		case "pipeline.motion-calm": {
+			const deviceId = numberField(data, "deviceId");
+			const dutyPct = numberField(data, "dutyPct");
+			const sessions = numberField(data, "sessions");
+			const windowMs = numberField(data, "windowMs");
+			if (deviceId === void 0 || dutyPct === void 0 || sessions === void 0 || windowMs === void 0) return null;
+			const noisy = event.category === "pipeline.motion-noisy";
+			const identity = lookup(deviceId);
+			return systemSubject({
+				facts,
+				kind: noisy ? "motion-noisy" : "motion-calm",
+				subject: `motion-noise:${deviceId}`,
+				titleKey: noisy ? "system.motion-noisy.title" : "system.motion-calm.title",
+				bodyKey: noisy ? "system.motion-noisy.body" : "system.motion-calm.body",
+				textParams: {
+					...deviceTextParams(deviceId, identity),
+					minutes: String(Math.max(1, Math.round(windowMs / 6e4))),
+					duty: String(dutyPct),
+					sessions: String(sessions)
+				},
+				deviceId,
+				...identity !== void 0 ? { deviceType: identity.type } : {}
+			});
+		}
 		case "recording.health.stalled": {
 			const deviceId = numberField(data, "deviceId");
 			const idleMs = numberField(data, "idleMs");
@@ -28515,6 +28680,33 @@ function incomingFromSystemEvent(event, lookup) {
 				...nodeId !== void 0 ? { nodeId } : {}
 			});
 		}
+		case "notification.rule-broken":
+		case "notification.rule-repaired": {
+			const ruleId = stringField(data, "ruleId");
+			if (ruleId === void 0) return null;
+			const broken = event.category === "notification.rule-broken";
+			const kind = broken ? "rule-broken" : "rule-repaired";
+			const ruleName = stringField(data, "ruleName") ?? ruleId;
+			const reason = stringField(data, "reason") ?? "unknown";
+			const ids = data["offendingIds"];
+			const offendingIds = Array.isArray(ids) ? ids.filter((id) => typeof id === "string").join(", ") : "";
+			return systemSubject({
+				facts,
+				kind,
+				subject: `rule-health:${ruleId}`,
+				titleKey: `system.${kind}.title`,
+				bodyKey: broken ? `system.rule-broken.body.${reason}` : "system.rule-repaired.body",
+				textParams: broken ? {
+					ruleId,
+					ruleName,
+					brokenReason: reason,
+					offendingIds
+				} : {
+					ruleId,
+					ruleName
+				}
+			});
+		}
 		case "update.available": return incomingFromUpdateAvailable(facts, data);
 		case "addon.updated": {
 			const update = parseAddonUpdateComplete(data);
@@ -28524,7 +28716,7 @@ 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);
+		case "alert.episode": return incomingFromAlertEpisode(facts, lookup);
 		default: return null;
 	}
 }
@@ -28540,9 +28732,11 @@ function incomingFromSystemEvent(event, lookup) {
 * 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) {
+function incomingFromAlertEpisode(facts, lookup) {
 	const payload = require_clip_model_registry.parseAlertEpisodePayload(facts.data);
 	if (payload === null) return null;
+	const attention = incomingFromDeviceAttention(facts, payload, lookup);
+	if (attention !== null) return attention;
 	const kind = require_clip_model_registry.alertEpisodeKind(payload.severity, payload.phase);
 	if (kind === null) return null;
 	return systemSubject({
@@ -28563,6 +28757,38 @@ function incomingFromAlertEpisode(facts) {
 		...payload.nodeId !== void 0 ? { nodeId: payload.nodeId } : {}
 	});
 }
+/**
+* A CRITICAL alert whose source is a DEVICE (D911) is announced in the devices
+* family — `device-attention-required` / `-resolved`, carrying the device id so
+* a rule's device filters apply — and NOT as `alert-critical`, so one alert
+* never notifies twice through two families. A device source whose id is not a
+* device id falls through to the generic alert kinds.
+*/
+function incomingFromDeviceAttention(facts, payload, lookup) {
+	if (payload.sourceType !== "device" || payload.sourceId === void 0) return null;
+	const kind = require_clip_model_registry.deviceAttentionKind(payload.severity, payload.phase);
+	if (kind === null) return null;
+	const deviceId = Number(payload.sourceId);
+	if (!Number.isInteger(deviceId)) return null;
+	const identity = lookup?.(deviceId);
+	return systemSubject({
+		facts,
+		kind,
+		subject: `alert:${payload.episodeId}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body`,
+		textParams: {
+			...deviceTextParams(deviceId, identity),
+			title: payload.title,
+			message: payload.message,
+			category: payload.category,
+			actionUrl: payload.actionUrl ?? ""
+		},
+		deviceId,
+		...identity !== void 0 ? { deviceType: identity.type } : {},
+		...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([
@@ -30520,8 +30746,8 @@ var en_default = {
 	"occupancy.body": "{{scope}} {{op}} ({{count}}/{{capacity}})",
 	"occupancy.op.occupied": "occupied",
 	"occupancy.op.free": "free",
-	"system.device-online.title": "Online — {{deviceName}}",
-	"system.device-online.body": "Device {{deviceName}} is online",
+	"system.device-online.title": "Back online — {{deviceName}}",
+	"system.device-online.body": "Device {{deviceName}} is back online",
 	"system.device-offline.title": "Offline — {{deviceName}}",
 	"system.device-offline.body": "Device {{deviceName}} is offline",
 	"system.device-disabled.title": "Switched off — {{deviceName}}",
@@ -30534,14 +30760,14 @@ var en_default = {
 	"system.device-battery-normal.title": "Battery back to normal — {{deviceName}}",
 	"system.device-battery-normal.body": "{{deviceName}} is back to {{percentage}}% battery",
 	"system.device-battery-normal.body.binary": "{{deviceName}} no longer reports a low battery",
-	"system.stream-online.title": "Stream online — {{deviceName}}",
-	"system.stream-online.body": "Stream for camera {{deviceName}} is online",
-	"system.stream-online.body.profiled": "{{profile}} stream for camera {{deviceName}} is online",
+	"system.stream-online.title": "Stream back online — {{deviceName}}",
+	"system.stream-online.body": "Stream for camera {{deviceName}} is back online",
+	"system.stream-online.body.profiled": "{{profile}} stream for camera {{deviceName}} is back online",
 	"system.stream-offline.title": "Stream offline — {{deviceName}}",
 	"system.stream-offline.body": "Stream for camera {{deviceName}} is offline",
 	"system.stream-offline.body.profiled": "{{profile}} stream for camera {{deviceName}} is offline",
-	"system.node-online.title": "Node online — {{nodeName}}",
-	"system.node-online.body.agent": "Agent {{nodeName}} is online",
+	"system.node-online.title": "Node back online — {{nodeName}}",
+	"system.node-online.body.agent": "Agent {{nodeName}} is back online",
 	"system.node-online.body.agent.after": "Agent {{nodeName}} is back online after {{offlineFor}} offline",
 	"system.node-offline.title": "Node offline — {{nodeName}}",
 	"system.node-offline.body.agent": "Agent {{nodeName}} is offline",
@@ -30553,18 +30779,26 @@ var en_default = {
 	"system.addon-crash-loop.body": "The {{addons}} addon on node {{nodeId}} crashed {{count}} times in a row and will NOT be restarted. Everything it provides is offline until it is repaired.",
 	"system.detection-blind.title": "Detecting nothing — {{deviceName}}",
 	"system.detection-blind.body": {
-		"one": "Camera {{deviceName}} has been analysed for {{minutes}} minute with no detection at all",
-		"other": "Camera {{deviceName}} has been analysed for {{minutes}} minutes with no detection at all"
+		"one": "Camera {{deviceName}} moved for {{minutes}} minute over {{sessions}} sessions and the detector produced nothing at all, not even a weak candidate",
+		"other": "Camera {{deviceName}} moved for {{minutes}} minutes over {{sessions}} sessions and the detector produced nothing at all, not even a weak candidate"
 	},
+	"system.motion-noisy.title": "Constant motion, no subject — {{deviceName}}",
+	"system.motion-noisy.body": "Camera {{deviceName}} has been in motion {{duty}}% of the last {{minutes}} minutes ({{sessions}} sessions) without a single detection. The detector is fine — tune this camera's motion zones or sensitivity.",
+	"system.motion-calm.title": "Motion calm again — {{deviceName}}",
+	"system.motion-calm.body": "Camera {{deviceName}} is no longer in constant motion ({{duty}}% of the last {{minutes}} minutes, {{sessions}} sessions)",
 	"system.recording-stalled.title": "Recording stalled — {{deviceName}}",
 	"system.recording-stalled.body": {
 		"one": "Camera {{deviceName}} has not written a recording segment for {{minutes}} minute",
 		"other": "Camera {{deviceName}} has not written a recording segment for {{minutes}} minutes"
 	},
-	"system.recording-healthy.title": "Recording healthy — {{deviceName}}",
+	"system.recording-healthy.title": "Recording again — {{deviceName}}",
 	"system.recording-healthy.body": "Camera {{deviceName}} is writing recording segments again",
 	"system.recording-degraded.title": "Recording degraded — {{deviceName}}",
 	"system.recording-degraded.body": "Camera {{deviceName}} exhausted its writer restart budget ({{message}})",
+	"system.device-attention-required.title": "{{title}}",
+	"system.device-attention-required.body": "{{message}}",
+	"system.device-attention-resolved.title": "Resolved: {{title}}",
+	"system.device-attention-resolved.body": "{{deviceName}} no longer needs attention",
 	"system.storage-location-low.title": "Storage low — {{locationName}}",
 	"system.storage-location-low.body": "Location {{locationName}} is down to {{freePercent}}% free ({{reason}})",
 	"system.storage-location-critical.title": "Storage critical — {{locationName}}",
@@ -30822,7 +31056,13 @@ var en_default = {
 	"calendar-events.line.timed": "• {{when}} {{title}}{{where}}",
 	"calendar-events.line.allDay": "• All day {{title}}{{where}}",
 	"calendar-events.where": " @ {{location}}",
-	"calendar-events.more": "…and {{count}} more"
+	"calendar-events.more": "…and {{count}} more",
+	"system.rule-broken.title": "Notification rule broken — {{ruleName}}",
+	"system.rule-broken.body.unparseable": "The rule \"{{ruleName}}\" cannot be loaded and sends nothing. Open it and save it again.",
+	"system.rule-broken.body.device-deleted": "The rule \"{{ruleName}}\" still names a deleted device ({{offendingIds}}) and was switched off. Pick the device again.",
+	"system.rule-broken.body.target-deleted": "The rule \"{{ruleName}}\" still sends to a deleted destination ({{offendingIds}}) and was switched off. Pick a destination again.",
+	"system.rule-repaired.title": "Notification rule works again — {{ruleName}}",
+	"system.rule-repaired.body": "The rule \"{{ruleName}}\" loads and names nothing deleted any more."
 };
 //#endregion
 //#region src/notification-center/texts/it.json
@@ -30907,8 +31147,8 @@ var it_default = {
 	"occupancy.body": "{{scope}} {{op}} ({{count}}/{{capacity}})",
 	"occupancy.op.occupied": "occupata",
 	"occupancy.op.free": "libera",
-	"system.device-online.title": "Online — {{deviceName}}",
-	"system.device-online.body": "Il dispositivo {{deviceName}} è online",
+	"system.device-online.title": "Di nuovo online — {{deviceName}}",
+	"system.device-online.body": "Il dispositivo {{deviceName}} è di nuovo online",
 	"system.device-offline.title": "Offline — {{deviceName}}",
 	"system.device-offline.body": "Il dispositivo {{deviceName}} è offline",
 	"system.device-disabled.title": "Spento — {{deviceName}}",
@@ -30921,14 +31161,14 @@ var it_default = {
 	"system.device-battery-normal.title": "Batteria rientrata — {{deviceName}}",
 	"system.device-battery-normal.body": "{{deviceName}} è risalito al {{percentage}}% di batteria",
 	"system.device-battery-normal.body.binary": "{{deviceName}} non segnala più la batteria scarica",
-	"system.stream-online.title": "Stream online — {{deviceName}}",
-	"system.stream-online.body": "Lo stream della camera {{deviceName}} è online",
-	"system.stream-online.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è online",
+	"system.stream-online.title": "Stream di nuovo online — {{deviceName}}",
+	"system.stream-online.body": "Lo stream della camera {{deviceName}} è di nuovo online",
+	"system.stream-online.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è di nuovo online",
 	"system.stream-offline.title": "Stream offline — {{deviceName}}",
 	"system.stream-offline.body": "Lo stream della camera {{deviceName}} è offline",
 	"system.stream-offline.body.profiled": "Lo stream {{profile}} della camera {{deviceName}} è offline",
-	"system.node-online.title": "Nodo online — {{nodeName}}",
-	"system.node-online.body.agent": "L'agent {{nodeName}} è online",
+	"system.node-online.title": "Nodo di nuovo online — {{nodeName}}",
+	"system.node-online.body.agent": "L'agent {{nodeName}} è di nuovo online",
 	"system.node-online.body.agent.after": "L'agent {{nodeName}} è di nuovo online dopo {{offlineFor}} offline",
 	"system.node-offline.title": "Nodo offline — {{nodeName}}",
 	"system.node-offline.body.agent": "L'agent {{nodeName}} è offline",
@@ -30943,10 +31183,14 @@ var it_default = {
 		"one": "La camera {{deviceName}} non scrive un segmento da {{minutes}} minuto",
 		"other": "La camera {{deviceName}} non scrive un segmento da {{minutes}} minuti"
 	},
-	"system.recording-healthy.title": "Registrazione ok — {{deviceName}}",
+	"system.recording-healthy.title": "Registra di nuovo — {{deviceName}}",
 	"system.recording-healthy.body": "La camera {{deviceName}} scrive di nuovo i segmenti",
 	"system.recording-degraded.title": "Registrazione degradata — {{deviceName}}",
 	"system.recording-degraded.body": "La camera {{deviceName}} ha esaurito i riavvii del writer ({{message}})",
+	"system.device-attention-required.title": "{{title}}",
+	"system.device-attention-required.body": "{{message}}",
+	"system.device-attention-resolved.title": "Risolto: {{title}}",
+	"system.device-attention-resolved.body": "{{deviceName}} non richiede più intervento",
 	"system.storage-location-low.title": "Storage basso — {{locationName}}",
 	"system.storage-location-low.body": "La location {{locationName}} è al {{freePercent}}% libero ({{reason}})",
 	"system.storage-location-critical.title": "Storage critico — {{locationName}}",
@@ -30955,9 +31199,13 @@ var it_default = {
 	"system.storage-location-ok.body": "La location {{locationName}} ha recuperato spazio libero",
 	"system.detection-blind.title": "Senza detection — {{deviceName}}",
 	"system.detection-blind.body": {
-		"one": "La camera {{deviceName}} è analizzata da {{minutes}} minuto senza alcun rilevamento",
-		"other": "La camera {{deviceName}} è analizzata da {{minutes}} minuti senza alcun rilevamento"
+		"one": "La camera {{deviceName}} ha avuto movimento per {{minutes}} minuto in {{sessions}} sessioni e il detector non ha prodotto nulla, nemmeno un candidato debole",
+		"other": "La camera {{deviceName}} ha avuto movimento per {{minutes}} minuti in {{sessions}} sessioni e il detector non ha prodotto nulla, nemmeno un candidato debole"
 	},
+	"system.motion-noisy.title": "Movimento continuo senza soggetto — {{deviceName}}",
+	"system.motion-noisy.body": "La camera {{deviceName}} è stata in movimento il {{duty}}% degli ultimi {{minutes}} minuti ({{sessions}} sessioni) senza alcun rilevamento. Il detector funziona — regola le zone di movimento o la sensibilità di questa camera.",
+	"system.motion-calm.title": "Movimento di nuovo calmo — {{deviceName}}",
+	"system.motion-calm.body": "La camera {{deviceName}} non è più in movimento continuo ({{duty}}% degli ultimi {{minutes}} minuti, {{sessions}} sessioni)",
 	"system.addon-update-available.title": {
 		"one": "{{count}} aggiornamento addon disponibile",
 		"other": "{{count}} aggiornamenti addon disponibili"
@@ -31209,7 +31457,13 @@ var it_default = {
 	"calendar-events.line.timed": "• {{when}} {{title}}{{where}}",
 	"calendar-events.line.allDay": "• Tutto il giorno {{title}}{{where}}",
 	"calendar-events.where": " @ {{location}}",
-	"calendar-events.more": "…e altri {{count}}"
+	"calendar-events.more": "…e altri {{count}}",
+	"system.rule-broken.title": "Regola di notifica rotta — {{ruleName}}",
+	"system.rule-broken.body.unparseable": "La regola \"{{ruleName}}\" non si carica e non invia nulla. Aprila e salvala di nuovo.",
+	"system.rule-broken.body.device-deleted": "La regola \"{{ruleName}}\" usa ancora un dispositivo eliminato ({{offendingIds}}) ed è stata disattivata. Scegli di nuovo il dispositivo.",
+	"system.rule-broken.body.target-deleted": "La regola \"{{ruleName}}\" invia ancora a una destinazione eliminata ({{offendingIds}}) ed è stata disattivata. Scegli di nuovo una destinazione.",
+	"system.rule-repaired.title": "Regola di notifica di nuovo funzionante — {{ruleName}}",
+	"system.rule-repaired.body": "La regola \"{{ruleName}}\" si carica e non usa più nulla di eliminato."
 };
 //#endregion
 //#region src/notification-center/text-catalog.ts
@@ -33480,6 +33734,10 @@ function systemEventKeys(kind) {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body.cleanWater`
 	};
+	if (kind === "rule-broken") return {
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.device-deleted`
+	};
 	return {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body`
@@ -33507,6 +33765,7 @@ function systemEventSubject(kind, scope) {
 	if (kind === "node-online" || kind === "node-offline") return `node:${scope.nodeId ?? "hub"}`;
 	if (kind === "node-inference-unavailable") return `node-inference:${scope.nodeId ?? "hub"}`;
 	if (kind === "detection-blind") return `detection-blind:${scope.deviceId ?? 0}`;
+	if (kind === "motion-noisy" || kind === "motion-calm") return `motion-noise:${scope.deviceId ?? 0}`;
 	if (kind === "addon-crash-loop") return `addon-crash:${scope.nodeId ?? "hub"}:${TEST_CRASHED_RUNNER}`;
 	if (kind === "addon-update-available" || kind === "server-update-available") return `package:${scope.packageName ?? "@camstack/server"}`;
 	if (kind === "wrapper-update-available") return `wrapper:${scope.nodeId ?? "hub"}`;
@@ -33652,6 +33911,8 @@ function planRuleTest(input) {
 					seconds: "30",
 					devices: "cuda:0",
 					minutes: "15",
+					duty: "55",
+					sessions: "96",
 					addons: TEST_CRASHED_RUNNER,
 					list: "@camstack/addon-pipeline 1.0.1 (current 1.0.0)",
 					nodes: "hub",
@@ -39735,6 +39996,99 @@ var NcRecordedCutMemo = class {
 	}
 };
 //#endregion
+//#region src/notification-center/notification-label-layout.ts
+/**
+* Where each box's caption goes on a notification picture — pure geometry,
+* rects in, placements out (D897 follow-up, 2026-10-22).
+*
+* A caption drawn INSIDE its box used to cover the subject whole on a small
+* box, and a caption next to a crowd landed on a neighbour's box. The rule:
+*
+*  1. Try, in order: OUTSIDE above the box (inside the picture), OUTSIDE below
+*     it, then INSIDE its top edge — the last only when the box is big enough
+*     that the plate is a thin band of it: plate height ≤
+*     {@link NC_LABEL_INSIDE_MAX_HEIGHT_FRACTION} of the box height and plate
+*     width ≤ the box width. A fifth of the height leaves the head and torso of
+*     an upright person, or most of a vehicle, visible; anything taller is the
+*     caption hiding what it names.
+*  2. A candidate is refused when its plate intersects ANY other box drawn on
+*     the picture, or a plate already placed.
+*  3. The subject is placed first; the other tracks follow by score, highest
+*     first, so a crowd never costs the subject its caption.
+*  4. The font never shrinks to make a plate fit: no fitting candidate means
+*     no caption for that box. A box without its caption still carries its
+*     outline and colour.
+*
+* Coordinates are the picture's own pixels, whatever it is (a scene or a crop).
+*/
+/** The inside placement is allowed only when the plate is at most this fraction of the box height. */
+var NC_LABEL_INSIDE_MAX_HEIGHT_FRACTION = .2;
+/** A caption is never drawn smaller than this, in output pixels. */
+var NC_LABEL_MIN_FONT_PX = 14;
+/** The dark plate a caption sits on, for this text at this font size. */
+function labelPlateSize(label, fontSize) {
+	return {
+		w: Math.round(label.length * fontSize * .62 + fontSize * .8),
+		h: Math.round(fontSize * 1.35)
+	};
+}
+/** Positive-area overlap; rectangles that only touch do not intersect. */
+function intersects(a, b) {
+	return a.x < b.x + b.w && b.x < a.x + a.w && a.y < b.y + b.h && b.y < a.y + a.h;
+}
+function captionOrder(boxes) {
+	const rank = (b) => b.role === "subject" ? 0 : 1;
+	return boxes.map((_, i) => i).sort((i, j) => {
+		const a = boxes[i];
+		const b = boxes[j];
+		if (a === void 0 || b === void 0) return 0;
+		return rank(a) - rank(b) || (b.score ?? 0) - (a.score ?? 0) || i - j;
+	});
+}
+function candidates(box, plate, width, height) {
+	if (plate.w > width) return [];
+	const x = Math.min(box.x, Math.max(0, width - plate.w));
+	const out = [];
+	if (box.y - plate.h >= 0) out.push({
+		x,
+		y: box.y - plate.h,
+		...plate,
+		where: "above"
+	});
+	if (box.y + box.h + plate.h <= height) out.push({
+		x,
+		y: box.y + box.h,
+		...plate,
+		where: "below"
+	});
+	if (plate.h <= box.h * NC_LABEL_INSIDE_MAX_HEIGHT_FRACTION && plate.w <= box.w) out.push({
+		x,
+		y: box.y,
+		...plate,
+		where: "inside"
+	});
+	return out;
+}
+/** Place every caption by the rule above. */
+function layoutBoxLabels(input) {
+	const { width, height, boxes } = input;
+	const fontSize = Math.max(NC_LABEL_MIN_FONT_PX, input.fontSize);
+	const placements = /* @__PURE__ */ new Map();
+	let dropped = 0;
+	for (const i of captionOrder(boxes)) {
+		const box = boxes[i];
+		if (box === void 0 || box.label.length === 0) continue;
+		const chosen = candidates(box, labelPlateSize(box.label, fontSize), width, height).find((c) => !boxes.some((other, j) => j !== i && intersects(c, other)) && ![...placements.values()].some((p) => intersects(c, p)));
+		if (chosen === void 0) dropped += 1;
+		else placements.set(i, chosen);
+	}
+	return {
+		placements: boxes.map((_, i) => placements.get(i) ?? null),
+		placed: placements.size,
+		dropped
+	};
+}
+//#endregion
 //#region src/notification-center/trigger-zone-still.ts
 /**
 * How far a candidate's instant may sit from the nearest trail point before the
@@ -39857,6 +40211,15 @@ var NC_IMAGE_OTHER_COLOR = "#f2f2f2";
 var NC_IMAGE_ZONE_COLOR = "#29b6f6";
 /** Two tracks whose boxes overlap this much at one instant are the same subject (a fused id). */
 var SAME_SUBJECT_IOU = .8;
+/**
+* A box of the SUBJECT'S CLASS overlapping the subject this much at one
+* instant is the subject itself — an unfused piece L2 has not joined yet
+* (D683 fuses 10–20 s later; a push leaves ~6 s after the trigger). The
+* detector's per-class NMS (`NMS_IOU_DEFAULT` 0.45) keeps one of two
+* same-class boxes above 0.45 in a frame, so two REAL subjects of one class
+* cannot overlap past it; 0.5 leaves a margin over that.
+*/
+var NC_IMAGE_SAME_CLASS_SUBJECT_IOU = .5;
 var JPEG_QUALITY = 85;
 /** The caption of a box: class (or label) and confidence — "dog 87%". Language-free. */
 function imageLabelText(name, confidence) {
@@ -39889,15 +40252,21 @@ function toPixels(box, width, height) {
 		h: Math.max(1, Math.min(Math.round(box.h * height), height - y))
 	};
 }
+/** {@link notificationOverlay}'s SVG alone. */
+function notificationOverlaySvg(input) {
+	return notificationOverlay(input).svg;
+}
 /**
-* The SVG drawn over a scene picture of `width` × `height`. The subject is
-* drawn LAST so a crowd never hides it. Captions sit on a dark plate above
-* the box (inside it when the box touches the top edge), white text.
+* The SVG drawn over a picture of `width` × `height`. The subject is drawn
+* LAST so a crowd never hides it. Captions sit on a dark plate, white text,
+* where `layoutBoxLabels` puts them — outside above, outside below, inside a
+* box only when it covers a thin band of it, never on another box or caption,
+* and nowhere at all rather than over the subject.
 */
-function notificationOverlaySvg(input) {
+function notificationOverlay(input) {
 	const { width, height } = input;
 	const strokes = overlayStrokes(width, height);
-	const fontSize = Math.max(14, Math.round(height / 36));
+	const fontSize = Math.max(NC_LABEL_MIN_FONT_PX, Math.round(height / 36));
 	const parts = [];
 	for (const zone of input.zones) {
 		if (zone.length < 3) continue;
@@ -39909,19 +40278,29 @@ function notificationOverlaySvg(input) {
 		parts.push(`<polyline data-role="subject-path" points="${require_clip_model_registry.subjectPathSvgPoints(run, width, height)}" fill="none" stroke="${NC_IMAGE_SUBJECT_COLOR}" stroke-width="${String(strokes.subject)}" stroke-linejoin="round" stroke-linecap="round" stroke-opacity="0.9"/>`);
 	}
 	const ordered = [...input.boxes.filter((b) => b.role === "other"), ...input.boxes.filter((b) => b.role === "subject")];
-	for (const box of ordered) {
+	const layout = layoutBoxLabels({
+		width,
+		height,
+		fontSize,
+		boxes: ordered
+	});
+	const plates = [];
+	ordered.forEach((box, i) => {
 		const subject = box.role === "subject";
 		const color = subject ? NC_IMAGE_SUBJECT_COLOR : NC_IMAGE_OTHER_COLOR;
 		const stroke = subject ? strokes.subject : strokes.other;
 		parts.push(`<rect data-role="${box.role}" x="${String(box.x)}" y="${String(box.y)}" width="${String(box.w)}" height="${String(box.h)}" fill="none" stroke="${color}" stroke-width="${String(stroke)}"/>`);
-		if (box.label.length === 0) continue;
-		const plateH = Math.round(fontSize * 1.35);
-		const plateW = Math.round(box.label.length * fontSize * .62 + fontSize * .8);
-		const plateY = box.y - plateH >= 0 ? box.y - plateH : box.y;
-		const plateX = Math.min(box.x, Math.max(0, width - plateW));
-		parts.push(`<rect data-role="${box.role}-plate" x="${String(plateX)}" y="${String(plateY)}" width="${String(plateW)}" height="${String(plateH)}" fill="#000000" fill-opacity="0.72" stroke="${color}" stroke-width="${String(subject ? 2 : 1)}"/>`, `<text data-role="${box.role}-label" x="${String(plateX + Math.round(fontSize * .4))}" y="${String(plateY + Math.round(plateH * .75))}" font-family="DejaVu Sans, Helvetica, Arial, sans-serif" font-size="${String(fontSize)}" font-weight="${subject ? "700" : "400"}" fill="#ffffff">${escapeXml$2(box.label)}</text>`);
-	}
-	return `<svg xmlns="http://www.w3.org/2000/svg" width="${String(width)}" height="${String(height)}">${parts.join("")}</svg>`;
+		const plate = layout.placements[i];
+		if (plate === null || plate === void 0) return;
+		plates.push(`<rect data-role="${box.role}-plate" x="${String(plate.x)}" y="${String(plate.y)}" width="${String(plate.w)}" height="${String(plate.h)}" fill="#000000" fill-opacity="0.72" stroke="${color}" stroke-width="${String(subject ? 2 : 1)}"/>`, `<text data-role="${box.role}-label" x="${String(plate.x + Math.round(fontSize * .4))}" y="${String(plate.y + Math.round(plate.h * .75))}" font-family="DejaVu Sans, Helvetica, Arial, sans-serif" font-size="${String(fontSize)}" font-weight="${subject ? "700" : "400"}" fill="#ffffff">${escapeXml$2(box.label)}</text>`);
+	});
+	return {
+		svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${String(width)}" height="${String(height)}">${[...parts, ...plates].join("")}</svg>`,
+		labels: {
+			placed: layout.placed,
+			dropped: layout.dropped
+		}
+	};
 }
 /** The pixel rectangle a `crop` cuts from a `width` × `height` frame, or null when too small. */
 function subjectCropRect(box, width, height) {
@@ -39951,11 +40330,18 @@ function iou$4(a, b) {
 }
 /**
 * The tracks to draw thin: every track at the instant except the subject —
-* the same id, or a box that is the subject's (a fused id reads under its
-* survivor's name).
-*/
-function otherTracks(tracks, subjectTrackId, subjectBox) {
-	return tracks.filter((t) => t.trackId !== subjectTrackId && (subjectBox === null || iou$4(t.bbox, subjectBox) < SAME_SUBJECT_IOU));
+* the same id, a box that is the subject's (a fused id reads under its
+* survivor's name), or a box of the subject's class over it past what NMS
+* lets two real subjects share (an unfused piece of the same subject).
+*/
+function otherTracks(tracks, subjectTrackId, subjectBox, subjectClassName) {
+	return tracks.filter((t) => {
+		if (t.trackId === subjectTrackId) return false;
+		if (subjectBox === null) return true;
+		const overlap = iou$4(t.bbox, subjectBox);
+		if (overlap >= SAME_SUBJECT_IOU) return false;
+		return !(t.className === subjectClassName && overlap >= NC_IMAGE_SAME_CLASS_SUBJECT_IOU);
+	});
 }
 /**
 * What picture a ROW asks for. A row written since D897 carries `mediaImage`;
@@ -39972,9 +40358,15 @@ function payloadImageMode(payload) {
 	if (payload.media === "keyFrame") return "clean";
 	return "crop";
 }
-/** The zone ids a row's picture outlines: the zones that fired it, when it asked. */
+/**
+* The zone ids a row's picture outlines: the zone(s) THIS event triggered,
+* when it asked — never every zone the rule lists (a dog in Uscio drew Aiuola
+* too). A row that asked but froze no `matchedZoneIds` (written before the
+* field) draws none: an outline of a zone the subject never entered is a
+* picture that lies about its own reason.
+*/
 function payloadZoneOverlayIds(payload) {
-	if (payload.mediaShowTriggerZone === true) return payload.triggerZoneIds ?? [];
+	if (payload.mediaShowTriggerZone === true) return payload.matchedZoneIds ?? [];
 	if (payload.mediaImage === void 0) return payload.mediaZoneIds ?? [];
 	return [];
 }
@@ -40063,7 +40455,8 @@ async function renderNotificationImage(req) {
 	const boxes = req.mode === "scene-boxes" ? [...req.others.map((o) => ({
 		...toPixels(o, outW, outH),
 		role: "other",
-		label: o.label
+		label: o.label,
+		...o.confidence !== void 0 ? { score: o.confidence } : {}
 	})), ...req.subject !== null ? [{
 		...toPixels(req.subject, outW, outH),
 		role: "subject",
@@ -40081,16 +40474,18 @@ async function renderNotificationImage(req) {
 		height: outH,
 		fit: "fill"
 	});
+	let labels;
 	if (boxes.length > 0 || zones.length > 0 || paths.length > 0) {
-		const svg = notificationOverlaySvg({
+		const overlay = notificationOverlay({
 			width: outW,
 			height: outH,
 			boxes,
 			zones,
 			paths
 		});
+		if (boxes.length > 0) labels = overlay.labels;
 		pipeline = pipeline.composite([{
-			input: Buffer.from(svg),
+			input: Buffer.from(overlay.svg),
 			top: 0,
 			left: 0
 		}]);
@@ -40100,7 +40495,8 @@ async function renderNotificationImage(req) {
 	return {
 		bytes: toArrayBufferBytes(out),
 		name: `${rendered}.jpg`,
-		rendered
+		rendered,
+		...labels !== void 0 ? { labels } : {}
 	};
 }
 var NcNotificationImageStage = class {
@@ -40174,10 +40570,29 @@ var NcNotificationImageStage = class {
 			...subjectBox,
 			label: imageLabelText(payload.subject.label ?? payload.subject.className, payload.subject.confidence)
 		} : null;
-		const others = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox).map((t) => ({
+		const othersDrawn = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox, payload.subject.className) : [];
+		if (mode === "scene-boxes") this.deps.logger.info("scene-boxes: other boxes drawn", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: entry.ruleId,
+				recordId: entry.recordId,
+				instant: source.timestamp,
+				drawn: othersDrawn.map((t) => `${t.trackId}/${t.className}/dt=${t.dtMs ?? "?"}ms/${t.interpolated === true ? "interpolated" : "exact"}`).join(",")
+			}
+		});
+		const others = mode === "scene-boxes" ? othersDrawn.map((t) => ({
 			...t.bbox,
-			label: imageLabelText(t.label ?? t.className, t.confidence)
+			label: imageLabelText(t.label ?? t.className, t.confidence),
+			...t.confidence !== void 0 ? { confidence: t.confidence } : {}
 		})) : [];
+		if (mode !== "crop" && input.withSubject && payload.mediaShowTriggerZone === true && payload.matchedZoneIds === void 0) this.deps.logger.info("trigger zone not drawn — the row never froze which zone fired", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: entry.ruleId,
+				recordId: entry.recordId,
+				ruleZoneIds: (payload.triggerZoneIds ?? []).join(",")
+			}
+		});
 		const zones = mode === "crop" || zoneIds.length === 0 ? [] : await this.zonePolygons(camera, zoneIds);
 		try {
 			const image = await this.render({
@@ -40190,6 +40605,7 @@ var NcNotificationImageStage = class {
 			});
 			const reason = image.rendered === mode ? void 0 : mode === "crop" ? "no-subject-box" : "no-tracks-at-instant";
 			if (reason !== void 0) this.reportFallback(input, mode, reason);
+			if (image.labels !== void 0) this.reportLabels(input, image.labels);
 			return reason !== void 0 ? {
 				...image,
 				reason
@@ -40238,6 +40654,19 @@ var NcNotificationImageStage = class {
 			}
 		});
 	}
+	/** ONE line per rendered picture: how many captions it carries and how many had no clear spot. */
+	reportLabels(input, labels) {
+		const camera = input.camera === "composite" ? input.entry.payload.subject.deviceId : input.camera;
+		this.deps.logger.debug("notification picture captions laid out", {
+			tags: { deviceId: camera },
+			meta: {
+				ruleId: input.entry.ruleId,
+				recordId: input.entry.recordId,
+				placed: labels.placed,
+				dropped: labels.dropped
+			}
+		});
+	}
 	/** The subject's trail, read once per render for its box AND its path. */
 	async subjectTrail(camera, trackId) {
 		const read = this.deps.getSubjectTrail;
@@ -46931,6 +47360,27 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
+* Incident 2026-10-22: a row stored with `groupingSec: 0` failed `NcRuleSchema` (min
+* {@link NC_GROUPING_MIN_SEC}) and the WHOLE rule was skipped as malformed on every load — a
+* system-event rule on which a window cannot even apply vanished from the engine and from
+* `listRules`. A non-positive (or non-numeric) window only ever meant "no window": dropped. A
+* positive one outside the range is clamped. One bad optional field never costs the rule.
+*/
+function repairStoredGroupingSec(value) {
+	if (value === void 0) return { kind: "unchanged" };
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return {
+		kind: "repaired",
+		from: value,
+		to: null
+	};
+	const clamped = clampGroupingSec(value);
+	return clamped === value ? { kind: "unchanged" } : {
+		kind: "repaired",
+		from: value,
+		to: clamped
+	};
+}
+/**
 * Project a RAW stored rule value (`data['rule']`, before any Zod parse). A value that is not
 * an object, or has no string `delivery`, is returned untouched: the schema parse that follows
 * rejects it exactly as before, and a projection must never be what decides a row is valid.
@@ -46938,9 +47388,12 @@ function isRecord(value) {
 function projectRawStoredRule(raw) {
 	if (!isRecord(raw) || typeof raw["delivery"] !== "string") return {
 		candidate: raw,
-		projection: { kind: "unchanged" }
+		projection: { kind: "unchanged" },
+		groupingRepair: { kind: "unchanged" }
 	};
-	const groupingSec = raw["groupingSec"];
+	const groupingRepair = repairStoredGroupingSec(raw["groupingSec"]);
+	const repaired = withRepairedGrouping(raw, groupingRepair);
+	const groupingSec = repaired["groupingSec"];
 	const projection = projectRetiredRuleFields({
 		delivery: raw["delivery"],
 		conditions: isRecord(raw["conditions"]) ? raw["conditions"] : {},
@@ -46949,15 +47402,25 @@ function projectRawStoredRule(raw) {
 		...typeof groupingSec === "number" ? { groupingSec } : {}
 	});
 	if (projection.kind === "unchanged" || projection.groupingSec === void 0) return {
-		candidate: raw,
-		projection
+		candidate: repaired,
+		projection,
+		groupingRepair
 	};
 	return {
 		candidate: {
-			...raw,
+			...repaired,
 			groupingSec: projection.groupingSec
 		},
-		projection
+		projection,
+		groupingRepair
+	};
+}
+function withRepairedGrouping(raw, repair) {
+	if (repair.kind === "unchanged") return raw;
+	const { groupingSec: _dropped, ...rest } = raw;
+	return repair.to === null ? rest : {
+		...rest,
+		groupingSec: repair.to
 	};
 }
 /**
@@ -47010,16 +47473,44 @@ var LOAD_LIMIT = 1e4;
 * Parse a raw body object (as returned from storage — may contain retired keys)
 * into an `NcRule` applying the legacy field projection.
 */
-function bodyToRule(id, raw, onProjection) {
-	const { candidate, projection } = projectRawStoredRule(raw);
+function bodyToRule(id, raw, onProjection, onGroupingRepair) {
+	const parsed = parseStoredRule(id, raw, onProjection, onGroupingRepair);
+	return parsed.ok ? parsed.rule : null;
+}
+function parseStoredRule(id, raw, onProjection, onGroupingRepair, onClassWidening) {
+	const { candidate, projection, groupingRepair } = projectRawStoredRule(raw);
 	const parsed = require_clip_model_registry.NcRuleSchema.safeParse({
 		...candidate,
 		id
 	});
-	if (!parsed.success) return null;
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		return {
+			ok: false,
+			reason: issue === void 0 ? "invalid" : `${issue.path.join(".") || "(root)"}: ${issue.message}`
+		};
+	}
 	if (projection.kind === "projected") onProjection?.(id, projection);
-	return withNormalizedMedia(parsed.data);
+	if (groupingRepair.kind === "repaired") onGroupingRepair?.(id, groupingRepair);
+	const media = withNormalizedMedia(parsed.data);
+	const rule = require_clip_model_registry.withSystemEventClasses(media);
+	if (rule !== media) onClassWidening?.(id, media, rule);
+	return {
+		ok: true,
+		rule
+	};
+}
+/**
+* D906: what a rule is stored as — its media policy folded (D897) and, on an
+* INSTANT system rule, every paired class it touches completed with both
+* edges. Applied on every WRITE; the load applies the same through
+* {@link parseStoredRule}, which also says once that it widened a rule.
+*/
+function normalizeStoredRule(rule) {
+	return require_clip_model_registry.withSystemEventClasses(withNormalizedMedia(rule));
 }
+/** At most this many skipped rows are NAMED in the WARN line; the count is always whole. */
+var SKIPPED_ROWS_NAMED_MAX = 10;
 /**
 * D897: the rule with its media policy in the stored shape — `image` set, the
 * legacy `attach` / `frame` / `zoneCrop` folded into it. Applied on LOAD (a read
@@ -47096,6 +47587,8 @@ var NcRuleStore = class NcRuleStore {
 	now;
 	newId;
 	identityIdsByName;
+	/** Rows the last successful {@link load} skipped; `null` before one succeeded. */
+	skipped = null;
 	/** Has a {@link load} ever completed? See the note there. */
 	loaded = false;
 	/** Legacy detection rules naming sounds already reported (D690) — once each. */
@@ -47107,6 +47600,10 @@ var NcRuleStore = class NcRuleStore {
 	pendingProjections = /* @__PURE__ */ new Map();
 	/** Rules whose projection was already logged in this process (D692 §9) — once each. */
 	projectionLogged = /* @__PURE__ */ new Set();
+	/** Rules whose out-of-range `groupingSec` repair was already logged — once each. */
+	groupingRepairLogged = /* @__PURE__ */ new Set();
+	/** Rules whose class widening (D906) was already logged — once each. */
+	classWideningLogged = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.logger = deps.logger;
 		this.now = deps.now ?? (() => Date.now());
@@ -47141,20 +47638,29 @@ var NcRuleStore = class NcRuleStore {
 		try {
 			const { records } = await this.kind.query({ limit: LOAD_LIMIT });
 			const next = /* @__PURE__ */ new Map();
-			let skipped = 0;
+			const skippedRows = [];
 			for (const row of records) {
-				const rule = bodyToRule(row.id, row.data, (ruleId, projection) => {
+				const parsed = parseStoredRule(row.id, row.data, (ruleId, projection) => {
 					this.pendingProjections.set(ruleId, projection);
-				});
-				if (rule === null) {
-					skipped += 1;
+				}, (ruleId, repair) => this.logGroupingRepair(ruleId, repair), (ruleId, before, after) => this.logClassWidening(ruleId, before, after));
+				if (!parsed.ok) {
+					const name = row.data["name"];
+					skippedRows.push({
+						ruleId: row.id,
+						name: typeof name === "string" ? name : null,
+						reason: parsed.reason
+					});
 					continue;
 				}
-				next.set(row.id, rule);
+				next.set(row.id, parsed.rule);
 			}
 			this.byId.clear();
 			for (const [id, rule] of next) this.byId.set(id, rule);
-			if (skipped > 0) this.logger.warn("notification rule rows skipped as malformed", { meta: { skipped } });
+			this.skipped = skippedRows;
+			if (skippedRows.length > 0) this.logger.warn("notification rule rows skipped as malformed", { meta: {
+				skipped: skippedRows.length,
+				rows: skippedRows.slice(0, SKIPPED_ROWS_NAMED_MAX)
+			} });
 			this.loaded = true;
 		} catch (err) {
 			this.logger.warn("notification rules load failed — keeping rules already in memory", { meta: {
@@ -47166,6 +47672,27 @@ var NcRuleStore = class NcRuleStore {
 		for (const id of warnLegacyAudioClassRules([...this.byId.values()], this.audioClassWarned, this.logger)) this.audioClassWarned.add(id);
 		this.logger.debug("notification rules loaded", { meta: { rules: this.byId.size } });
 	}
+	/** Say, once per process per rule, that an instant rule was read as its whole class (D906). */
+	logClassWidening(ruleId, before, after) {
+		if (this.classWideningLogged.has(ruleId)) return;
+		this.classWideningLogged.add(ruleId);
+		const had = new Set(before.conditions.systemEvent?.kinds ?? []);
+		this.logger.info("instant system rule read as its whole event class — both edges", { meta: {
+			ruleId,
+			rule: after.name,
+			added: (after.conditions.systemEvent?.kinds ?? []).filter((kind) => !had.has(kind))
+		} });
+	}
+	/** Say, once per process per rule, that an out-of-range stored `groupingSec` was repaired. */
+	logGroupingRepair(ruleId, repair) {
+		if (this.groupingRepairLogged.has(ruleId)) return;
+		this.groupingRepairLogged.add(ruleId);
+		this.logger.warn("rule carries an out-of-range groupingSec — repaired on read", { meta: {
+			ruleId,
+			from: repair.from,
+			to: repair.to
+		} });
+	}
 	/** Log, once per process per rule, what `bodyToRule` projected from a retired field. */
 	logPendingProjections() {
 		for (const [ruleId, projection] of this.pendingProjections) {
@@ -47234,6 +47761,13 @@ var NcRuleStore = class NcRuleStore {
 	* camera's ring) must ask this first: before the first load the empty list
 	* is not a fact, and a failed load leaves whatever was already mirrored.
 	*/
+	/**
+	* The rows the last SUCCESSFUL load could not parse — `null` until one has
+	* succeeded, so "not read yet" never reads as "nothing broken" (D315).
+	*/
+	skippedRows() {
+		return this.skipped;
+	}
 	isLoaded() {
 		return this.loaded;
 	}
@@ -47263,7 +47797,7 @@ var NcRuleStore = class NcRuleStore {
 	/** Create a new rule. `createdBy` is the SERVER-injected caller userId. */
 	async create(input, createdBy) {
 		const now = this.now();
-		const rule = withNormalizedMedia({
+		const rule = normalizeStoredRule({
 			...input,
 			id: this.newId(),
 			createdBy,
@@ -47308,7 +47842,7 @@ var NcRuleStore = class NcRuleStore {
 			createdAt: existing.createdAt,
 			updatedAt: this.now()
 		};
-		const updated = withNormalizedMedia(require_clip_model_registry.NcRuleSchema.parse(candidate));
+		const updated = normalizeStoredRule(require_clip_model_registry.NcRuleSchema.parse(candidate));
 		await this.write(updated);
 		return updated;
 	}
@@ -47348,7 +47882,7 @@ var NcRuleStore = class NcRuleStore {
 			id: ruleId
 		} : candidate);
 		if (!parsed.success) return existing;
-		const next = withNormalizedMedia(parsed.data);
+		const next = normalizeStoredRule(parsed.data);
 		const { id: _omit, ...data } = next;
 		await this.kind.put({
 			id: ruleId,
@@ -53377,6 +53911,104 @@ var NcZoneOwnershipCache = class {
 	}
 };
 //#endregion
+//#region src/notification-center/rule-health.ts
+var EMPTY_SNAPSHOT = {
+	timelapse: [],
+	summary: [],
+	alarm: null,
+	mutedDeviceIds: []
+};
+function fingerprintOf(reasons) {
+	return reasons.map((r) => `${r.code}:${[...r.ids].sort().join(",")}`).join("|");
+}
+/** The deleted subjects a rule still names, from the prune's `kept*` records. */
+function deletedReasons(rule, prunes) {
+	const snapshot = {
+		...EMPTY_SNAPSHOT,
+		rules: [rule]
+	};
+	const devices = referencedDeviceIds(snapshot);
+	const targets = referencedTargetIds(snapshot);
+	const deadDevices = /* @__PURE__ */ new Set();
+	const deadTargets = /* @__PURE__ */ new Set();
+	for (const p of prunes) {
+		if (p.kind !== "rule" || p.ruleId !== rule.id) continue;
+		if (p.outcome !== "kept" && p.outcome !== "kept-disabled") continue;
+		if (p.subjectKind === "device" && devices.has(Number(p.subject))) deadDevices.add(p.subject);
+		if (p.subjectKind === "target" && targets.has(p.subject)) deadTargets.add(p.subject);
+	}
+	const reasons = [];
+	if (deadDevices.size > 0) reasons.push({
+		code: "device-deleted",
+		ids: [...deadDevices].sort()
+	});
+	if (deadTargets.size > 0) reasons.push({
+		code: "target-deleted",
+		ids: [...deadTargets].sort()
+	});
+	return reasons;
+}
+var NcRuleHealthMonitor = class {
+	verdicts = /* @__PURE__ */ new Map();
+	/** Judge every rule once; return the edges to announce. */
+	evaluate(inputs) {
+		const next = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ new Set();
+		if (inputs.skipped !== null) for (const row of inputs.skipped) {
+			seen.add(row.ruleId);
+			const unparseable = {
+				code: "unparseable",
+				ids: [],
+				detail: row.reason
+			};
+			next.set(row.ruleId, this.verdict(row.name, unparseable, []));
+		}
+		if (inputs.rules !== null) for (const rule of inputs.rules) {
+			seen.add(rule.id);
+			const previous = this.verdicts.get(rule.id);
+			const deleted = inputs.prunes !== null ? deletedReasons(rule, inputs.prunes) : previous?.deleted ?? [];
+			const unparseable = inputs.skipped !== null ? null : previous?.unparseable ?? null;
+			next.set(rule.id, this.verdict(rule.name, unparseable, deleted));
+		}
+		const edges = [];
+		const answeredAll = inputs.rules !== null && inputs.skipped !== null;
+		for (const [ruleId, previous] of this.verdicts) {
+			if (seen.has(ruleId)) continue;
+			if (!answeredAll) next.set(ruleId, previous);
+		}
+		for (const [ruleId, verdict] of next) {
+			const previous = this.verdicts.get(ruleId);
+			const reasons = reasonsOf(verdict);
+			if (reasons.length > 0) {
+				if (previous?.fingerprint !== verdict.fingerprint) edges.push({
+					kind: "broken",
+					ruleId,
+					ruleName: verdict.name,
+					reasons
+				});
+			} else if (previous !== void 0 && reasonsOf(previous).length > 0) edges.push({
+				kind: "repaired",
+				ruleId,
+				ruleName: verdict.name
+			});
+		}
+		this.verdicts.clear();
+		for (const [ruleId, verdict] of next) if (reasonsOf(verdict).length > 0) this.verdicts.set(ruleId, verdict);
+		return edges;
+	}
+	verdict(name, unparseable, deleted) {
+		return {
+			name,
+			unparseable,
+			deleted,
+			fingerprint: fingerprintOf([...unparseable !== null ? [unparseable] : [], ...deleted])
+		};
+	}
+};
+function reasonsOf(verdict) {
+	return [...verdict.unparseable !== null ? [verdict.unparseable] : [], ...verdict.deleted];
+}
+//#endregion
 //#region src/notification-center/index.ts
 /**
 * NotificationCenter — the P1 core of the Notification Center (spec
@@ -53443,7 +54075,7 @@ var NC_ALARM_ANNOUNCE_RULE_ID = "nc-alarm-announce";
 * media (the SOURCE rule of a combined alarm row), and a zone overlay is
 * frozen only when the rule asked for one AND fired on a zone.
 */
-function mediaPolicyFields(mediaRule, cropZoneIds) {
+function mediaPolicyFields(mediaRule, cropZoneIds, matchedZoneIds) {
 	const media = effectiveMediaPolicyForRule(mediaRule);
 	const image = media.image ?? "crop";
 	return {
@@ -53452,6 +54084,7 @@ function mediaPolicyFields(mediaRule, cropZoneIds) {
 		...media.showTriggerZone === true && cropZoneIds !== void 0 && cropZoneIds.length > 0 ? { mediaShowTriggerZone: true } : {},
 		...media.showSubjectPath === true && image !== "none" ? { mediaShowSubjectPath: true } : {},
 		...cropZoneIds !== void 0 ? { triggerZoneIds: [...cropZoneIds] } : {},
+		...matchedZoneIds !== void 0 ? { matchedZoneIds: [...matchedZoneIds] } : {},
 		...media.profile !== void 0 ? { mediaProfile: media.profile } : {},
 		...media.gif === true ? { mediaGif: true } : {},
 		...media.clip === true ? { mediaClip: true } : {},
@@ -53957,6 +54590,21 @@ function groupOrderInput(fate, triggerZoneIds) {
 * condition's ids, else an occupancy rule's one zone. A grouped member freezes the same
 * ids a plain row of the rule would.
 */
+/**
+* The zones of `cropZoneIds` this subject actually triggered — what the zone
+* condition saw (membership plus the crossed zone, `zonesVisitedBy`), on the
+* rule whose media the row carries. On a combined alarm row the subject is the
+* alarm, so the source match's frozen zones answer. An occupancy rule's one
+* zone is the zone the count edge is ABOUT, so it is its own trigger.
+*/
+function matchedTriggerZoneIds(mediaRule, cropZoneIds, subject) {
+	if (cropZoneIds === void 0) return void 0;
+	if (mediaRule.conditions.zones === void 0) return [...cropZoneIds];
+	const alarmSource = subject.systemEvent?.alarmSource;
+	const visited = new Set(alarmSource !== void 0 ? alarmSource.zones ?? [] : subject.zones);
+	if (alarmSource === void 0 && subject.crossing !== void 0) visited.add(subject.crossing.zoneId);
+	return cropZoneIds.filter((id) => visited.has(id));
+}
 function ruleCropZoneIds(rule) {
 	if (rule.conditions.zones !== void 0) return rule.conditions.zones.ids;
 	const zoneId = rule.conditions.occupancy?.zoneId;
@@ -54110,6 +54758,8 @@ var NotificationCenter = class {
 	* evaluating one.
 	*/
 	pruneLedger;
+	/** D905: which rules cannot work, announced once per distinct reason. */
+	ruleHealth = new NcRuleHealthMonitor();
 	/** The prune itself — see `device-prune-runner.ts`. */
 	pruner;
 	/**
@@ -57539,7 +58189,7 @@ var NotificationCenter = class {
 		const subject = incoming.subject;
 		const alarmSource = subject.systemEvent?.alarmSource;
 		const sourceRule = alarmSource !== void 0 ? this.rules.get(alarmSource.ruleId) : null;
-		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, ruleCropZoneIds(sourceRule)) : { media: "none" };
+		const media = sourceRule !== null ? mediaPolicyFields(sourceRule, ruleCropZoneIds(sourceRule), matchedTriggerZoneIds(sourceRule, ruleCropZoneIds(sourceRule), subject)) : { media: "none" };
 		const mediaDeviceId = alarmSource?.deviceId ?? panel.deviceId;
 		const entries = targets.map((targetId) => ({
 			ruleId: NC_ALARM_ANNOUNCE_RULE_ID,
@@ -58745,6 +59395,7 @@ var NotificationCenter = class {
 		const renderedZones = notificationZones(rule, subject);
 		const confirm = frozenConfirmPolicy(rule, isSystemEvent);
 		const cropZoneIds = ruleCropZoneIds(mediaRule);
+		const matchedZoneIds = matchedTriggerZoneIds(mediaRule, cropZoneIds, subject);
 		const allTargets = [...rule.targets, ...userTargets.filter((t) => !direct.has(t.targetId))];
 		const linkedOwners = !noMedia && subject.linkedStills !== void 0 ? linkedMediaOwners(subject.linkedStills, linkedCameraMode(mediaRule.media)) : void 0;
 		const groupV2 = extras?.groupV2 ?? (subject.systemEvent !== void 0 && !noMedia ? alarmIncidentGroup(subject.systemEvent, subject.timestamp) : void 0);
@@ -58755,7 +59406,7 @@ var NotificationCenter = class {
 				...origin === "synthetic" ? { synthetic: true } : {},
 				priority: rule.priority,
 				...rule.template !== void 0 ? { template: rule.template } : {},
-				...noMedia ? { media: "none" } : mediaPolicyFields(mediaRule, cropZoneIds),
+				...noMedia ? { media: "none" } : mediaPolicyFields(mediaRule, cropZoneIds, matchedZoneIds),
 				...confirm !== void 0 ? {
 					confirm,
 					...cooldown !== void 0 ? { cooldown } : {},
@@ -59400,6 +60051,51 @@ var NotificationCenter = class {
 		if (!this.pruneLedger.isLoaded()) await this.pruneLedger.load();
 		await this.pruner.reconcileDevices();
 		await this.pruner.reconcileTargets();
+		this.announceRuleHealth();
+	}
+	/**
+	* D905 — say which rules cannot work: a row the load skipped, or a rule still
+	* naming a device / target the prune confirmed deleted. One edge per rule per
+	* distinct set of reasons; a reading that did not answer changes nothing.
+	*/
+	announceRuleHealth() {
+		const edges = this.ruleHealth.evaluate({
+			rules: this.rules.isLoaded() ? this.rules.list() : null,
+			skipped: this.rules.skippedRows(),
+			prunes: this.pruneLedger.isLoaded() ? this.pruner.listPrunes() : null
+		});
+		for (const edge of edges) {
+			const source = {
+				type: "addon",
+				id: "notification-center"
+			};
+			if (edge.kind === "broken") {
+				const [first] = edge.reasons;
+				if (first === void 0) continue;
+				const offendingIds = [...new Set(edge.reasons.flatMap((r) => r.ids))];
+				this.logger.warn("notification rule cannot work — announced", { meta: {
+					ruleId: edge.ruleId,
+					rule: edge.ruleName,
+					reasons: edge.reasons
+				} });
+				this.deps.emitBusEvent?.(require_clip_model_registry.createEvent(require_clip_model_registry.EventCategory.NotificationRuleBroken, source, {
+					ruleId: edge.ruleId,
+					ruleName: edge.ruleName,
+					reason: first.code,
+					reasons: edge.reasons,
+					offendingIds
+				}));
+			} else {
+				this.logger.info("notification rule works again — announced", { meta: {
+					ruleId: edge.ruleId,
+					rule: edge.ruleName
+				} });
+				this.deps.emitBusEvent?.(require_clip_model_registry.createEvent(require_clip_model_registry.EventCategory.NotificationRuleRepaired, source, {
+					ruleId: edge.ruleId,
+					ruleName: edge.ruleName
+				}));
+			}
+		}
 	}
 	/**
 	* `DeviceUnregistered` — a device was DELETED (only `removeDevice` emits it,
@@ -87251,7 +87947,12 @@ var RetrainCollectionService = class {
 				reason: "unknown-collection"
 			};
 		}
-		const stored = await this.storeStill(input.deviceId, input.epochMs);
+		const membershipOp = await this.deps.collections.addFrameOp({
+			collectionId: input.collectionId,
+			frameId: recordingFrameId(input.deviceId, input.epochMs),
+			deviceId: input.deviceId
+		});
+		const stored = await this.storeStill(input.deviceId, input.epochMs, membershipOp === null ? [] : [membershipOp]);
 		if (stored.kind === "refused") {
 			this.deps.logger.info("retrain collection add refused", {
 				tags,
@@ -87263,7 +87964,7 @@ var RetrainCollectionService = class {
 			});
 			return stored;
 		}
-		await this.deps.collections.addFrame({
+		if (stored.reused) await this.deps.collections.addFrame({
 			collectionId: input.collectionId,
 			frameId: stored.frame.frameId,
 			deviceId: input.deviceId
@@ -87328,7 +88029,7 @@ var RetrainCollectionService = class {
 		const ids = await this.deps.collections.listFrameIds(input.collectionId);
 		return this.deps.retrain.toWireFrames(await this.deps.frames.getMany(ids));
 	}
-	async storeStill(deviceId, epochMs) {
+	async storeStill(deviceId, epochMs, withRow) {
 		const existing = await this.deps.frames.get(recordingFrameId(deviceId, epochMs));
 		if (existing !== null) return {
 			kind: "stored",
@@ -87348,7 +88049,7 @@ var RetrainCollectionService = class {
 			deviceId,
 			epochMs,
 			bytes: still.jpeg
-		});
+		}, withRow);
 		return stored.kind === "copied" ? {
 			kind: "stored",
 			frame: stored.frame,
@@ -89671,9 +90372,9 @@ var RetrainService = class {
 			...this.frameUrls(updated.frameId)
 		};
 	}
-	/** Un-select: annotations first, then the copy. Never the other way round —
-	*  an annotation whose frame is gone is unopenable and unfixable. The frame's
-	*  collection memberships go with it. */
+	/** Un-select: the frame row, its annotations and its collection memberships
+	*  leave in one transaction (an annotation whose frame is gone is unopenable
+	*  and unfixable, so they never part); the blob is deleted after the row. */
 	async deselectFrame(input) {
 		const frame = await this.deps.frames.get(input.frameId);
 		if (frame === null) {
@@ -89692,11 +90393,16 @@ var RetrainService = class {
 			removedAnnotations: await this.removeFrame(frame)
 		};
 	}
-	/** Remove a frame from the dataset: annotations, memberships, then the copy. */
+	/**
+	* Remove a frame from the dataset. The frame row, its annotations and its
+	* collection memberships leave in ONE transaction (a failure removes nothing
+	* and throws); the blob is deleted after the row, never before.
+	*/
 	async removeFrame(frame) {
-		const removedAnnotations = await this.deps.annotations.deleteForFrame(frame.frameId);
-		await this.deps.memberships?.forgetFrame(frame.frameId);
-		await this.deps.frames.deleteFrame(frame);
+		const annotationOps = await this.deps.annotations.deleteOpsForFrame(frame.frameId);
+		const membershipOps = await this.deps.memberships?.forgetFrameOps(frame.frameId) ?? [];
+		await this.deps.frames.deleteFrame(frame, [...annotationOps, ...membershipOps]);
+		const removedAnnotations = annotationOps.length;
 		this.deps.logger.info("retrain frame removed from the dataset", {
 			tags: { deviceId: frame.deviceId },
 			meta: {
@@ -89890,7 +90596,8 @@ var RetrainService = class {
 	* The guarded replace. A caller that names the revision it saw gets exactly
 	* one attempt: a different current revision is a conflict, never a retry —
 	* the point is that it must look again. A caller that names none asked for
-	* last-write-wins, so a race lost between our read and the transaction is
+	* last-write-wins, so a race lost between our revision read and the records
+	* `transact` that commits the save (a per-frame lock serialises the two) is
 	* retried on the fresh revision, a bounded number of times.
 	*/
 	async replaceGuarded(frame, input, drafts, dismissed) {
@@ -103517,12 +104224,16 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	require_clip_model_registry.EventCategory.WorkerOffline,
 	require_clip_model_registry.EventCategory.PipelineNodeInferenceUnavailable,
 	require_clip_model_registry.EventCategory.PipelineDetectionBlind,
+	require_clip_model_registry.EventCategory.PipelineMotionNoisy,
+	require_clip_model_registry.EventCategory.PipelineMotionCalm,
 	require_clip_model_registry.EventCategory.RecordingHealthStalled,
 	require_clip_model_registry.EventCategory.RecordingHealthOk,
 	require_clip_model_registry.EventCategory.RecordingHealthDegraded,
 	require_clip_model_registry.EventCategory.StorageLocationLow,
 	require_clip_model_registry.EventCategory.StorageLocationCritical,
 	require_clip_model_registry.EventCategory.StorageLocationOk,
+	require_clip_model_registry.EventCategory.NotificationRuleBroken,
+	require_clip_model_registry.EventCategory.NotificationRuleRepaired,
 	require_clip_model_registry.EventCategory.AddonRunnerFailed,
 	require_clip_model_registry.EventCategory.AddonStarted,
 	require_clip_model_registry.EventCategory.AddonRestarted,
@@ -106533,6 +107244,18 @@ Object.freeze({
 				"empty"
 			]
 		},
+		{
+			"path": "filterCleaningDue",
+			"valueType": "boolean"
+		},
+		{
+			"path": "machineCareDue",
+			"valueType": "boolean"
+		},
+		{
+			"path": "machineCareRemainingRuns",
+			"valueType": "number"
+		},
 		{
 			"path": "halfLoad",
 			"valueType": "boolean"
@@ -115553,6 +116276,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				nodeAddons: (nodeId) => api.nodes.getNodeAddons.query({ nodeId })
 			},
 			readAlerts: () => api.alerts.list.query({ limit: 5e3 }),
+			emitBusEvent: (event) => this.ctx.eventBus.emit(event),
 			getSnapshot: (deviceId) => api.snapshot.getSnapshot.query({ deviceId }),
 			recognitionOutlook: ({ deviceId, trackId, className, labelKind, now }) => recognitionOutlook({
 				className,
@@ -115826,7 +116550,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 						since: timestamp - toleranceMs,
 						limit: NC_TRACKS_AT_INSTANT_LIMIT
 					});
-					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId));
+					return tracksAtInstant([...live, ...persisted.tracks], timestamp, toleranceMs, this.lastFrameDimsByDevice.get(deviceId), (drop) => this.ctx.logger.info("scene-boxes: other track not drawn", {
+						tags: { deviceId },
+						meta: {
+							trackId: drop.trackId,
+							className: drop.className,
+							reason: drop.reason,
+							instant: timestamp,
+							...drop.nearestDtMs !== void 0 ? { nearestDtMs: drop.nearestDtMs } : {}
+						}
+					}));
 				},
 				getDeviceName,
 				getDeviceLocation,