@camstack/addon-post-analysis 1.2.621 → 1.2.622

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-MHJ9BSUV.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -5402,15 +5402,28 @@ 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;
+/**
+* Every source track ALIVE at `timestamp` (± {@link NC_TRACK_LIFE_SLACK_MS})
+* with a position within `toleranceMs` of it, its nearest box normalised,
+* deduplicated by track id (a live copy and a persisted copy of one track are
+* one track). Pure.
 */
 function tracksAtInstant(sources, timestamp, toleranceMs, fallbackDims) {
 	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) continue;
 		const w = track.frameWidth ?? fallbackDims?.w ?? 0;
 		const h = track.frameHeight ?? fallbackDims?.h ?? 0;
 		if (w <= 0 || h <= 0) continue;
@@ -20451,8 +20464,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
@@ -28515,6 +28528,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);
@@ -30520,8 +30560,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 +30574,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",
@@ -30561,7 +30601,7 @@ var en_default = {
 		"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}})",
@@ -30822,7 +30862,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 +30953,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 +30967,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,7 +30989,7 @@ 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}})",
@@ -31209,7 +31255,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 +33532,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`
@@ -39735,6 +39791,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 +40006,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 +40047,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 +40073,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 +40125,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 +40153,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 +40250,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 +40269,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 +40290,8 @@ async function renderNotificationImage(req) {
 	return {
 		bytes: toArrayBufferBytes(out),
 		name: `${rendered}.jpg`,
-		rendered
+		rendered,
+		...labels !== void 0 ? { labels } : {}
 	};
 }
 var NcNotificationImageStage = class {
@@ -40174,10 +40365,19 @@ 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 others = mode === "scene-boxes" ? otherTracks(await this.tracksAt(camera, source.timestamp), subjectTrackId, subjectBox, payload.subject.className).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 +40390,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 +40439,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 +47145,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 +47173,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 +47187,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,17 +47258,45 @@ 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
 * projection: a rule nobody saved since keeps its row as written) and on every
@@ -47096,6 +47372,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 +47385,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 +47423,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 +47457,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 +47546,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 +47582,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 +47627,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 +47667,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 +53696,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 +53860,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 +53869,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 +54375,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 +54543,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 +57974,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 +59180,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 +59191,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 +59836,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,
@@ -103523,6 +104004,8 @@ var NC_SYSTEM_EVENT_CATEGORIES = [
 	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,
@@ -115553,6 +116036,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,