@camstack/addon-post-analysis 1.2.281 → 1.2.283

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BtqlSCQT.js");
+const require_dist = require("../dist-CT5xOY86.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -287,6 +287,7 @@ function coverageFor(rules, panelDeviceId, mode, skipProbe) {
 	const ids = /* @__PURE__ */ new Set();
 	let ruleCount = 0;
 	let allDevices = false;
+	let except = null;
 	for (const rule of rules) {
 		if (!rule.enabled) continue;
 		const gate = rule.conditions.deviceState;
@@ -294,21 +295,35 @@ function coverageFor(rules, panelDeviceId, mode, skipProbe) {
 		if (!gate.states.includes(wanted)) continue;
 		ruleCount += 1;
 		const scope = rule.conditions.devices;
+		const excluded = rule.conditions.devicesExclude ?? [];
 		if (scope === void 0 || scope.length === 0) {
 			allDevices = true;
+			except = narrowExcept(except, excluded);
 			continue;
 		}
-		for (const id of scope) ids.add(id);
+		for (const id of scope) if (!excluded.includes(id)) ids.add(id);
 	}
 	const deviceIds = [...ids].toSorted((a, b) => a - b);
+	const allDevicesExcept = except === null || except === "none" ? [] : [...except].filter((id) => !ids.has(id)).toSorted((a, b) => a - b);
 	return {
 		mode,
 		ruleCount,
 		allDevices,
+		allDevicesExcept,
 		deviceIds,
 		skippedDevices: skippedFor(deviceIds, skipProbe)
 	};
 }
+/**
+* Fold one UNSCOPED covering rule into the except-set: with no exclusion it
+* covers everything (`'none'`, final); otherwise only what every unscoped rule
+* excludes stays uncovered — the intersection.
+*/
+function narrowExcept(current, excluded) {
+	if (current === "none" || excluded.length === 0) return "none";
+	if (current === null) return new Set(excluded);
+	return new Set(excluded.filter((id) => current.has(id)));
+}
 function skippedFor(deviceIds, skipProbe) {
 	if (skipProbe === void 0) return [];
 	const out = [];
@@ -382,6 +397,19 @@ function buildArmAnnouncement(coverage, deviceName, bypassed = []) {
 			textCount: names.length
 		};
 	}
+	if (coverage.allDevices && coverage.allDevicesExcept.length > 0) {
+		const names = coverage.allDevicesExcept.map(deviceName);
+		return {
+			bodyKey: "alarm.arm.body.allDevicesExcept",
+			textParams: {
+				rules,
+				mode,
+				count: `${names.length}`,
+				names: names.join(", ")
+			},
+			textCount: names.length
+		};
+	}
 	if (coverage.allDevices) return {
 		bodyKey: "alarm.arm.body.allDevices",
 		textParams: {
@@ -600,7 +628,8 @@ function alarmCoveredDevices(rules, panelDeviceId, mode) {
 		if (!gate.states.includes(wanted)) continue;
 		const scope = rule.conditions.devices;
 		if (scope === void 0 || scope.length === 0) continue;
-		for (const id of scope) ids.add(id);
+		const excluded = rule.conditions.devicesExclude ?? [];
+		for (const id of scope) if (!excluded.includes(id)) ids.add(id);
 	}
 	return [...ids].toSorted((a, b) => a - b);
 }
@@ -6634,6 +6663,8 @@ var SceneEngine = class {
 var DEFAULT_LOAD_LIMIT = 1e5;
 var DurableLedger = class DurableLedger {
 	mirror = /* @__PURE__ */ new Map();
+	/** Whether ANY load has read the store successfully — see {@link hasAnswered}. */
+	answered = false;
 	spec;
 	store;
 	logger;
@@ -6689,6 +6720,7 @@ var DurableLedger = class DurableLedger {
 			}
 			this.mirror.clear();
 			for (const [key, row] of next) this.mirror.set(key, row);
+			this.answered = true;
 			if (skipped > 0) this.logger.warn("durable rows skipped as malformed — they gate NOTHING", { meta: {
 				collection: this.spec.collection,
 				skipped
@@ -6703,6 +6735,16 @@ var DurableLedger = class DurableLedger {
 			return [...this.mirror.values()];
 		}
 	}
+	/**
+	* Whether the mirror is an ANSWER from the store: true once any load has
+	* succeeded, and never false again (a later failed load keeps that answer).
+	* Before it, an empty mirror is "not read yet", never "the store is empty" —
+	* {@link load} swallows its failure, so a caller that must tell the two apart
+	* asks here (D642 review I1).
+	*/
+	hasAnswered() {
+		return this.answered;
+	}
 	/** Every mirrored row, insertion-ordered. */
 	snapshot() {
 		return [...this.mirror.values()];
@@ -7795,10 +7837,10 @@ function replaceConditionReferences(monitor, condition, reference) {
 //#endregion
 //#region src/notification-center/snooze-exempt.ts
 /** The cap whose presence in a sequence makes the rule the alarm's trigger. */
-var ALARM_PANEL_CAP$2 = "alarm-panel";
+var ALARM_PANEL_CAP$1 = "alarm-panel";
 var ALARM_KINDS = new Set(require_dist.NC_ALARM_SYSTEM_EVENT_KINDS);
 function actuatesAlarmPanel(sequences) {
-	for (const sequence of sequences) for (const step of sequence.actions) if (step.kind === "cap" && step.cap === ALARM_PANEL_CAP$2) return true;
+	for (const sequence of sequences) for (const step of sequence.actions) if (step.kind === "cap" && step.cap === ALARM_PANEL_CAP$1) return true;
 	return false;
 }
 /**
@@ -8436,6 +8478,78 @@ var NcAlertStore = class {
 		};
 	}
 };
+//#endregion
+//#region src/notification-center/alerts/consumable-subject.ts
+/**
+* A consumable EPISODE's name, and the thresholds the rule set asks for (D642).
+*
+* Before D642 one cluster-wide threshold judged every item, so an item had one
+* episode: `consumable:<deviceId>:<key>`. The threshold is now the RULE's, and
+* the ledger keeps one episode per threshold a rule asks for — each with its
+* own hysteresis, pending raise and reminder — named
+* `consumable@<threshold>:<deviceId>:<key>`.
+*
+* The threshold rides the FAMILY segment on purpose: the device id stays the
+* second segment (`alertSubjectDeviceId`, D636 — the log tag and the indexed
+* column read it), and the item key stays last and whole, whatever it holds.
+*
+* Pure. No clock, no I/O.
+*/
+var FAMILY = "consumable";
+/** The episode of `key` on `deviceId`, judged at `thresholdPercent`. */
+function consumableSubject(thresholdPercent, deviceId, key) {
+	return `${FAMILY}@${String(thresholdPercent)}:${String(deviceId)}:${key}`;
+}
+/** The pre-D642 subject of the same item — read only to carry it over. */
+function legacyConsumableSubject(deviceId, key) {
+	return `${FAMILY}:${String(deviceId)}:${key}`;
+}
+/** `null` for a subject that is not a consumable's. */
+function parseConsumableSubject(subject) {
+	const first = subject.indexOf(":");
+	const second = first < 0 ? -1 : subject.indexOf(":", first + 1);
+	if (first < 0 || second < 0) return null;
+	const family = subject.slice(0, first);
+	const deviceId = Number(subject.slice(first + 1, second));
+	const key = subject.slice(second + 1);
+	if (!Number.isInteger(deviceId) || key.length === 0) return null;
+	if (family === FAMILY) return {
+		thresholdPercent: 15,
+		deviceId,
+		key,
+		legacy: true
+	};
+	if (!family.startsWith(`${FAMILY}@`)) return null;
+	const thresholdPercent = Number(family.slice(11));
+	if (!Number.isInteger(thresholdPercent)) return null;
+	return {
+		thresholdPercent,
+		deviceId,
+		key,
+		legacy: false
+	};
+}
+/**
+* Every consumable threshold the rule set asks for, ascending.
+*
+* A rule asks when it is a system-event rule whose kinds include a consumable
+* kind — enabled or not: a disabled rule's episode stays PENDING (no rule
+* matched it) and is re-offered the moment the rule is switched back on
+* (D636), which is what that rule would have said had it been on. With no such
+* rule at all the default is still judged, so an episode exists for the first
+* rule an operator writes to hear (D636's "offered once per rule change").
+*/
+function consumableThresholdCensus(rules) {
+	const thresholds = /* @__PURE__ */ new Set();
+	for (const rule of rules) {
+		const condition = rule.conditions.systemEvent;
+		if (rule.delivery !== "system-event" || condition === void 0) continue;
+		if (!condition.kinds.some((kind) => require_dist.NC_CONSUMABLE_SYSTEM_EVENT_KINDS.includes(kind))) continue;
+		thresholds.add(require_dist.consumableLowPercentOf(condition));
+	}
+	if (thresholds.size === 0) thresholds.add(15);
+	return [...thresholds].toSorted((a, b) => a - b);
+}
 function deriveConsumableBand(input) {
 	const { level, status } = input.reading;
 	const measured = level !== null && Number.isFinite(level);
@@ -9563,6 +9677,7 @@ function isLinkedSetSubject(subject) {
 function subjectFromSensorEvent(ev, markerTrackId, linked) {
 	const eventType = readSensorEventType(ev.value);
 	const sensorEdge = sensorEdgeOf(ev.kind, ev.value);
+	const sensorRaised = require_dist.sensorRaisedOf(ev.kind, ev.value);
 	return {
 		kind: "device-event",
 		recordId: String(ev.id),
@@ -9576,6 +9691,7 @@ function subjectFromSensorEvent(ev, markerTrackId, linked) {
 		sensorKind: ev.kind,
 		...eventType !== void 0 ? { eventType } : {},
 		...sensorEdge !== void 0 ? { sensorEdge } : {},
+		...sensorRaised !== void 0 ? { sensorRaised } : {},
 		...linked !== void 0 ? {
 			linkedSensorId: ev.sourceDeviceId,
 			linkedCameraIds: [...linked.linkedCameraIds],
@@ -9803,6 +9919,7 @@ function presentConditionIds(c) {
 	const ids = [];
 	if (c.systemEvent !== void 0) ids.push("systemEvent");
 	if (c.devices !== void 0 && c.devices.length > 0) ids.push("devices");
+	if (c.devicesExclude !== void 0 && c.devicesExclude.length > 0) ids.push("devicesExclude");
 	if (c.source !== void 0 && c.source !== "any") ids.push("source");
 	if (c.classes !== void 0 && c.classes.length > 0) ids.push("classes");
 	if (c.classesExclude !== void 0 && c.classesExclude.length > 0) ids.push("classesExclude");
@@ -9819,6 +9936,7 @@ function presentConditionIds(c) {
 	if (c.plates !== void 0) ids.push("plates");
 	if (c.sensorKinds !== void 0 && c.sensorKinds.length > 0) ids.push("sensorKinds");
 	if (c.eventTypeTokens !== void 0 && c.eventTypeTokens.length > 0) ids.push("eventTypeTokens");
+	if (c.sensorTransition !== void 0) ids.push("sensorTransition");
 	if (c.packagePhase !== void 0 && c.packagePhase !== "both") ids.push("packagePhase");
 	if (c.customZones !== void 0 && c.customZones.length > 0) ids.push("customZones");
 	if (c.occupancy !== void 0) ids.push("occupancy");
@@ -9913,12 +10031,23 @@ function zonesVisitedBy(subject) {
 * before the subject exists (the linked-camera capture gate). Coarse in one
 * direction only: `true` may still fail later; `false` never would have fired.
 */
-function deviceEventRuleMayFireOnKind(rule, sensorKind) {
+function deviceEventRuleMayFireOnKind(rule, sensorKind, sensorRaised) {
 	const c = rule.conditions;
 	if (c.occupancy !== void 0) return false;
+	if (sensorTransitionRefuses(c.sensorTransition, sensorRaised)) return false;
 	if (c.sensorKinds === void 0 || c.sensorKinds.length === 0) return true;
 	return toLowerSet(c.sensorKinds).has(sensorKind.trim().toLowerCase());
 }
+/**
+* Does a rule's `sensorTransition` refuse this edge? Only a KNOWN edge can be
+* refused: `sensorRaised === undefined` (a kind with no raise, an unreadable
+* slice) always passes — a flood rule never goes silent on a bad read (D640).
+* The ONE predicate {@link evaluateRule} and the capture gate both ask.
+*/
+function sensorTransitionRefuses(transition, sensorRaised) {
+	if (transition === void 0 || sensorRaised === void 0) return false;
+	return sensorRaised !== (transition === "raised");
+}
 function toLowerSet(values) {
 	return new Set(values.map((v) => v.trim().toLowerCase()));
 }
@@ -9955,9 +10084,6 @@ function matchesIdentityScope(subject, scope) {
 function ruleAwaitsRecognition(rule) {
 	return rule.conditions.identities !== void 0 || rule.conditions.plates !== void 0;
 }
-var ARMED_WORD_PREFIX = "armed_";
-var ALARM_PANEL_CAP$1 = "alarm-panel";
-var ALARM_PANEL_TRIGGER_METHOD = "trigger";
 /**
 * A rule "belongs to the alarm" when its `deviceState` gate names ANY device's
 * `armed_*` word — CamStack's own panel or any other, e.g. an HA-mirrored
@@ -9975,8 +10101,10 @@ var ALARM_PANEL_TRIGGER_METHOD = "trigger";
 * catalog on save, so a new key would be dropped by the first edit.
 */
 function ruleBelongsToAlarm(rule) {
-	if ((rule.conditions.deviceState?.states ?? []).some((s) => s.trim().toLowerCase().startsWith(ARMED_WORD_PREFIX))) return true;
-	return (rule.actions?.onTrigger ?? []).some((sequence) => sequence.enabled && sequence.actions.some((step) => step.kind === "cap" && step.cap === ALARM_PANEL_CAP$1 && step.method === ALARM_PANEL_TRIGGER_METHOD));
+	return require_dist.ruleBelongsToAlarm({
+		conditions: rule.conditions,
+		...rule.actions?.onTrigger !== void 0 ? { onTrigger: rule.actions.onTrigger } : {}
+	});
 }
 /**
 * The edge an alarm rule refuses: a close, or a halt/fault (a cover stopped
@@ -10085,6 +10213,9 @@ function systemEventExclusion(condition, subject) {
 	if (wantedPackages !== void 0 && applies("packageNames")) {
 		if (!subjectPackages(subject).some((name) => wantedPackages.includes(name))) return "packageNames";
 	}
+	if (applies("consumableLowPercent") && subject.consumableLowPercent !== void 0) {
+		if (subject.consumableLowPercent !== require_dist.consumableLowPercentOf(condition)) return "consumableLowPercent";
+	}
 }
 function subjectNodes(subject) {
 	const ids = [...subject.nodeIds ?? []];
@@ -10152,6 +10283,7 @@ function evaluateRule(rule, subject, deviceState, zoneOwners, sceneStates) {
 		if (!sceneConditionSatisfied(c.scene, observation)) return fail("scene");
 	}
 	if (c.devices !== void 0 && c.devices.length > 0 && !matchesDeviceScope(c.devices, subject)) return fail("devices");
+	if (c.devicesExclude !== void 0 && deviceScopeExcludes(c.devicesExclude, subject)) return fail("devicesExclude");
 	if (c.source !== void 0 && c.source !== "any") {
 		if ((subject.source ?? "pipeline") !== c.source) return fail("source");
 	}
@@ -10228,6 +10360,7 @@ function evaluateRule(rule, subject, deviceState, zoneOwners, sceneStates) {
 	if (c.eventTypeTokens !== void 0 && c.eventTypeTokens.length > 0) {
 		if (subject.eventType === void 0 || !toLowerSet(c.eventTypeTokens).has(subject.eventType.trim().toLowerCase())) return fail("eventTypeTokens");
 	}
+	if (sensorTransitionRefuses(c.sensorTransition, subject.sensorRaised)) return fail("sensorTransition");
 	if (c.packagePhase !== void 0 && c.packagePhase !== "both") {
 		if (subject.packagePhase !== c.packagePhase) return fail("packagePhase");
 	}
@@ -10333,6 +10466,27 @@ function matchesDeviceScope(scope, subject) {
 	if (scope.includes(subject.deviceId)) return true;
 	return subject.sourceDeviceId !== void 0 && scope.includes(subject.sourceDeviceId);
 }
+/**
+* Does a rule's `devicesExclude` (D641) exclude this subject?
+*
+* The exact complement of {@link matchesDeviceScope}, row by row. A per-camera
+* row is excluded by its camera OR by the sensor that fired, the two ids an
+* include matches on. A linked set stands for the rows it replaced (D630 §6):
+* it is excluded when its SENSOR is, or when EVERY camera that took a row is —
+* one excluded row camera leaves the others firing, as their own rows would
+* have. A camera that only LINKS the sensor excludes nothing, for the reason it
+* includes nothing: ADR 0632 widens the media, never which rules fire.
+*/
+function deviceScopeExcludes(excluded, subject) {
+	if (excluded.length === 0) return false;
+	if (subject.linkedSensorId !== void 0) {
+		if (excluded.includes(subject.linkedSensorId)) return true;
+		const rows = subject.rowCameraIds ?? [];
+		return rows.length > 0 && rows.every((cameraId) => excluded.includes(cameraId));
+	}
+	if (excluded.includes(subject.deviceId)) return true;
+	return subject.sourceDeviceId !== void 0 && excluded.includes(subject.sourceDeviceId);
+}
 function cooldownKey(rule, subject) {
 	const first = subject.classNames[0];
 	const classKey = keysPerClass(rule, subject) && first !== void 0 ? `:c:${first}` : "";
@@ -10941,6 +11095,7 @@ function systemSubject(input) {
 				...input.packageNames !== void 0 ? { packageNames: input.packageNames } : {},
 				...input.textCount !== void 0 ? { textCount: input.textCount } : {},
 				...input.alarmSource !== void 0 ? { alarmSource: input.alarmSource } : {},
+				...input.consumableLowPercent !== void 0 ? { consumableLowPercent: input.consumableLowPercent } : {},
 				data
 			}
 		},
@@ -11042,9 +11197,11 @@ function incomingFromBatteryBand(input) {
 * these to be treated as the battery notifications are — with two differences
 * that come from the subject and not from taste:
 *
-*  - **the subject carries the ITEM.** `consumable:<deviceId>:<key>`, because a
-*    vacuum has a brush AND a filter AND a mop pad, and one subject for all
-*    three would let the brush's alert cancel the filter's.
+*  - **the subject carries the ITEM.** `consumable@<threshold>:<deviceId>:<key>`,
+*    because a vacuum has a brush AND a filter AND a mop pad, and one subject
+*    for all three would let the brush's alert cancel the filter's. It carries
+*    the THRESHOLD too (D642): each rule's threshold is its own episode, and
+*    the engine pairs a rule with the episode judged at its own number.
 *  - **the body variant follows what is KNOWN.** An item with no percentage
 *    gets a finished sentence rather than a template with a stand-in number in
 *    it, for the same reason a binary battery does.
@@ -11053,17 +11210,46 @@ function incomingFromBatteryBand(input) {
 */
 function incomingFromConsumableBand(input) {
 	const kind = input.band === "low" ? "device-consumable-low" : "device-consumable-normal";
-	const measured = input.item.level !== null && Number.isFinite(input.item.level);
+	const level = input.item.level;
+	const percentage = level !== null && Number.isFinite(level) ? Math.round(level) : null;
+	const measured = percentage !== null;
 	return systemSubject({
 		facts: input.facts,
 		kind,
-		subject: `consumable:${input.deviceId}:${input.item.key}`,
+		subject: consumableSubject(input.thresholdPercent, input.deviceId, input.item.key),
 		titleKey: `system.${kind}.title`,
 		bodyKey: measured ? `system.${kind}.body` : `system.${kind}.body.unmeasured`,
 		textParams: {
 			...deviceTextParams(input.deviceId, input.identity),
 			item: input.item.label,
-			...measured ? { percentage: String(Math.round(input.item.level)) } : {}
+			...percentage !== null ? { percentage: String(percentage) } : {}
+		},
+		deviceId: input.deviceId,
+		consumableLowPercent: input.thresholdPercent,
+		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
+	});
+}
+/**
+* A vacuum TANK band, as a system-event subject (D642).
+*
+* Built like {@link incomingFromConsumableBand}: `tank:<deviceId>:<tank>` is
+* one subject per tank (the dust bin's alert must not cancel the clean water's),
+* and the recovery keeps it. The BODY VARIANT names the tank in the reader's
+* language — the params are frozen before the language is known, so the tank's
+* name cannot be a param; `tank` carries the stable token for a custom
+* template.
+*/
+function incomingFromTankBand(input) {
+	const kind = input.band === "low" ? "device-tank-low" : input.band === "full" ? "device-tank-full" : "device-tank-normal";
+	return systemSubject({
+		facts: input.facts,
+		kind,
+		subject: `tank:${String(input.deviceId)}:${input.tank}`,
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.${input.tank}`,
+		textParams: {
+			...deviceTextParams(input.deviceId, input.identity),
+			tank: input.tank
 		},
 		deviceId: input.deviceId,
 		...input.identity !== void 0 ? { deviceType: input.identity.type } : {}
@@ -11651,6 +11837,91 @@ function deliveryForKind(kind) {
 	return kind;
 }
 //#endregion
+//#region src/notification-center/alerts/tank-band.ts
+/**
+* A vacuum TANK reduced to the only thing worth storing: its band (D642).
+*
+* The `vacuum-control` slice carries four tanks — clean water, dirty water,
+* detergent, dust bin — each `null` when the hardware has none, else
+* `{ level, status }`. The operator asked for them to notify like consumables:
+* clean water / detergent running low, dirty water / dust bin full.
+*
+* ## The verdict is the provider's
+*
+* A tank's `status` is the device's own float switch (`ok` | `low` | `full`),
+* and it is the ONLY thing judged. The hub has no threshold for a tank level:
+* the rule for thresholds is that they belong to whoever generates the event,
+* and a tank that says `low` has already decided. A tank that reports only a
+* `level` is therefore not judged at all (`null`) rather than judged against a
+* number the hub would have to invent.
+*
+* ## `null` is the third answer, and it is not `normal`
+*
+* An unknown status says nothing — it neither opens nor closes an episode, for
+* the reason `battery-band.ts` gives: a reading nobody took is not evidence
+* that anything changed.
+*
+* Pure. No clock, no I/O.
+*/
+/** The four tanks `vacuum-control` names, by their slice field. */
+var NC_TANK_KEYS = [
+	"cleanWater",
+	"dirtyWater",
+	"detergent",
+	"dustBin"
+];
+/**
+* How long a tank change must HOLD before it counts (D642 review M2).
+*
+* A float switch sloshing at the edge of `low` / `full` flips its status back
+* and forth while the robot moves; each flip is a durable transition, and
+* without a hold each one is a raise and a recovery on the operator's phone.
+* One minute is two reload ticks: long enough to outlast a slosh, short enough
+* that a genuinely full dust bin is said within a minute and a half.
+*/
+var NC_TANK_HOLD_MS = 6e4;
+function deriveTankBand(reading) {
+	switch (reading.status) {
+		case "low": return "low";
+		case "full": return "full";
+		case "ok": return "normal";
+		case null: return null;
+	}
+}
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tankStatusOf(value) {
+	return value === "ok" || value === "low" || value === "full" ? value : null;
+}
+/**
+* A `device.state-changed` payload carrying a `vacuum-control` slice, reduced
+* to its tanks. `null` for any other cap. A tank the hardware does not have
+* (`null`) is skipped; a malformed field reads as unknown, never as a
+* fabricated verdict (D393: absent is not zero).
+*/
+function vacuumTanksOf(data) {
+	if (data["capName"] !== "vacuum-control") return null;
+	const deviceId = data["deviceId"];
+	const slice = data["slice"];
+	if (typeof deviceId !== "number" || !isRecord$4(slice)) return null;
+	const tanks = [];
+	for (const key of NC_TANK_KEYS) {
+		const raw = slice[key];
+		if (!isRecord$4(raw)) continue;
+		const level = raw["level"];
+		tanks.push({
+			key,
+			level: typeof level === "number" && Number.isFinite(level) ? level : null,
+			status: tankStatusOf(raw["status"])
+		});
+	}
+	return tanks.length === 0 ? null : {
+		deviceId,
+		tanks
+	};
+}
+//#endregion
 //#region src/notification-center/alerts/battery-band.ts
 /**
 * The stand-in a provider writes for a binary NORMAL. Anything below it, on a
@@ -11681,10 +11952,14 @@ function deriveBatteryBand(input) {
 * `NcDeviceAlerts` — the one place a SUSTAINED device fault becomes a
 * notification, and keeps becoming one until it stops being true.
 *
-* It owns two families and nothing else:
+* It owns these families and nothing else:
 *
 *  - **battery band** — `battery:<deviceId>`, fed by the `battery` runtime-state
 *    slice that already arrives on `device.state-changed`;
+*  - **consumable band** — `consumable@<threshold>:<deviceId>:<key>`, one
+*    episode per item per threshold a RULE asks for (D642);
+*  - **tank band** — `tank:<deviceId>:<tank>`, a vacuum's tanks, judged on the
+*    provider's own verdict (D642);
 *  - **the reminder tick** — the operator's "how often do you say it again".
 *
 * It does NOT own device liveness. `device-offline` already has a producer, a
@@ -11724,6 +11999,10 @@ var PENDING_CADENCE_MAX_MS = 36e5;
 function pendingCadenceMs(settings) {
 	return settings.renotifyMinutes > 0 ? Math.min(settings.renotifyMinutes * 6e4, PENDING_CADENCE_MAX_MS) : PENDING_CADENCE_MAX_MS;
 }
+/** The RAM key of one item's last reading — every threshold's episode reads it. */
+function itemKeyOf(deviceId, key) {
+	return `${String(deviceId)}:${key}`;
+}
 var NcDeviceAlerts = class {
 	deps;
 	now;
@@ -11735,8 +12014,28 @@ var NcDeviceAlerts = class {
 	* durable.
 	*/
 	lastReading = /* @__PURE__ */ new Map();
-	/** The last reading per consumable SUBJECT, for the reminder sweep. */
+	/**
+	* The last reading per consumable ITEM (`<deviceId>:<key>`), for the
+	* reminder sweep and for judging a threshold a rule gains later (D642).
+	*/
 	lastConsumable = /* @__PURE__ */ new Map();
+	/** The last reading per tank SUBJECT, for the reminder sweep. */
+	lastTank = /* @__PURE__ */ new Map();
+	/**
+	* Tank changes on HOLD (review M2): a band that would move the episode,
+	* first seen at `since`. It counts once it has held for `NC_TANK_HOLD_MS`,
+	* confirmed by a later slice write or by the reload tick — no timer of its
+	* own, so nothing outlives the device. Bounded by the device's tanks (four),
+	* and dropped with the device by {@link forget}.
+	*/
+	tankHold = /* @__PURE__ */ new Map();
+	/**
+	* Thresholds some episode row carries that the LAST census did not ask for.
+	* A threshold's rows are retired only when two consecutive censuses agree it
+	* is gone (D49: a read that would destroy work needs a second read to
+	* agree). RAM only: a restart costs one more tick of patience.
+	*/
+	absentThresholds = /* @__PURE__ */ new Set();
 	/**
 	* Subject → WHEN its PENDING raise was last offered, and to which
 	* {@link NcDeviceAlertsDeps.rulesVersion}. RAM only, on purpose: after a
@@ -11794,31 +12093,137 @@ var NcDeviceAlerts = class {
 	* observed.
 	*/
 	observeConsumable(deviceId, item) {
-		const subject = `consumable:${deviceId}:${item.key}`;
-		const previous = this.deps.rows.get(subject);
+		this.lastConsumable.set(itemKeyOf(deviceId, item.key), {
+			deviceId,
+			item
+		});
+		const thresholds = this.deps.consumableThresholds();
+		if (thresholds === null) {
+			this.logger()?.debug("consumable reading kept — the rules have not been read yet", {
+				tags: { deviceId },
+				meta: { item: item.key }
+			});
+			return;
+		}
 		const settings = this.deps.settings();
+		for (const thresholdPercent of thresholds) this.judgeConsumable(deviceId, item, thresholdPercent, settings);
+	}
+	/**
+	* ONE vacuum tank, from a device's `vacuum-control` slice (D642).
+	*
+	* The provider's verdict is the band (`tank-band.ts`); an unknown status
+	* leaves everything untouched, an open episode included.
+	*/
+	observeTank(deviceId, tank) {
+		const band = deriveTankBand(tank);
+		if (band === null) return;
+		const subject = `tank:${String(deviceId)}:${tank.key}`;
+		this.lastTank.set(subject, {
+			deviceId,
+			tank
+		});
+		if (!this.tankChangeHeld(subject, deviceId, band)) return;
+		this.apply(subject, band !== "normal", this.deps.settings(), (facts, alerting) => incomingFromTankBand({
+			facts,
+			deviceId,
+			band: alerting ? band : "normal",
+			tank: tank.key,
+			identity: this.deps.lookup(deviceId)
+		}));
+	}
+	/**
+	* Has this tank band held long enough to move its episode? A band that
+	* would not move it (a repeat, or low ⇄ full inside one open episode) passes
+	* at once and clears any hold — that is what makes a flapping switch start
+	* its hold over every time it flips back. A first HEALTHY observation passes
+	* too: it seeds silently, so there is nothing to hold.
+	*/
+	tankChangeHeld(subject, deviceId, band) {
+		const row = this.deps.rows.get(subject);
+		const alerting = band !== "normal";
+		if (!(row === void 0 ? alerting : row.alerting !== alerting)) {
+			this.tankHold.delete(subject);
+			return true;
+		}
+		const nowMs = this.now();
+		const held = this.tankHold.get(subject);
+		if (held === void 0 || held.band !== band) {
+			this.tankHold.set(subject, {
+				band,
+				since: nowMs
+			});
+			this.logger()?.debug("tank change on hold — counts once it has held", {
+				tags: { deviceId },
+				meta: {
+					subject,
+					band,
+					holdMs: NC_TANK_HOLD_MS
+				}
+			});
+			return false;
+		}
+		if (nowMs - held.since < 6e4) return false;
+		this.tankHold.delete(subject);
+		return true;
+	}
+	/** The tick's half of the hold: a change that has held with no new slice write. */
+	confirmHeldTanks() {
+		const nowMs = this.now();
+		for (const [subject, held] of [...this.tankHold]) {
+			if (nowMs - held.since < 6e4) continue;
+			const reading = this.lastTank.get(subject);
+			if (reading === void 0) {
+				this.tankHold.delete(subject);
+				continue;
+			}
+			this.observeTank(reading.deviceId, reading.tank);
+		}
+	}
+	/** One item against ONE threshold: its own episode, its own hysteresis. */
+	judgeConsumable(deviceId, item, thresholdPercent, settings) {
+		const subject = consumableSubject(thresholdPercent, deviceId, item.key);
+		const previous = this.deps.rows.get(subject) ?? this.adoptLegacy(subject, deviceId, item.key);
 		const band = deriveConsumableBand({
 			reading: {
 				level: item.level,
 				status: item.status
 			},
-			thresholdPercent: settings.consumableLowPercent,
+			thresholdPercent,
 			previous: previous?.alerting === true ? "low" : previous === void 0 ? void 0 : "normal"
 		});
 		if (band === null) return;
-		this.lastConsumable.set(subject, {
-			deviceId,
-			item
-		});
 		this.apply(subject, band === "low", settings, (facts, alerting) => incomingFromConsumableBand({
 			facts,
 			deviceId,
 			band: alerting ? "low" : "normal",
 			item,
+			thresholdPercent,
 			identity: this.deps.lookup(deviceId)
 		}));
 	}
 	/**
+	* A pre-D642 row of this item (`consumable:<id>:<key>`, judged at the
+	* cluster threshold, which shipped as the rule default) is carried over to
+	* the default-threshold episode rather than re-announced: the live vacuum
+	* had two items low and reminding when D642 shipped. Any other threshold
+	* starts fresh; an unadopted legacy row retires with the census.
+	*/
+	adoptLegacy(subject, deviceId, key) {
+		const parts = parseConsumableSubject(subject);
+		const legacySubject = legacyConsumableSubject(deviceId, key);
+		const legacy = this.deps.rows.get(legacySubject);
+		if (legacy === void 0 || parts === null) return void 0;
+		const legacyParts = parseConsumableSubject(legacySubject);
+		if (legacyParts === null || legacyParts.thresholdPercent !== parts.thresholdPercent) return;
+		const adopted = {
+			...legacy,
+			subject
+		};
+		this.deps.rows.put(adopted);
+		this.dropRow(legacySubject, "carried over to its threshold episode (D642)");
+		return adopted;
+	}
+	/**
 	* The reminder sweep. Called from an existing periodic tick; it allocates
 	* nothing on the healthy path.
 	*
@@ -11829,6 +12234,9 @@ var NcDeviceAlerts = class {
 	*/
 	tick() {
 		const settings = this.deps.settings();
+		const thresholds = this.deps.consumableThresholds();
+		if (thresholds !== null) this.reconcileThresholds(thresholds, settings);
+		this.confirmHeldTanks();
 		this.retryPending(settings);
 		if (settings.renotifyMinutes <= 0) return;
 		for (const row of this.deps.rows.all()) {
@@ -11861,14 +12269,58 @@ var NcDeviceAlerts = class {
 		const subjects = this.deps.rows.all().map((row) => row.subject).filter((subject) => alertSubjectDeviceId(subject) === deviceId);
 		for (const subject of subjects) {
 			this.lastReading.delete(subject);
-			this.lastConsumable.delete(subject);
+			this.lastTank.delete(subject);
 			this.offeredAt.delete(subject);
 			await this.deps.rows.remove(subject);
 		}
 		this.lastReading.delete(`battery:${deviceId}`);
+		for (const [key, reading] of this.lastConsumable) if (reading.deviceId === deviceId) this.lastConsumable.delete(key);
+		for (const subject of this.tankHold.keys()) if (alertSubjectDeviceId(subject) === deviceId) this.tankHold.delete(subject);
+		for (const subject of this.lastTank.keys()) if (alertSubjectDeviceId(subject) === deviceId) this.lastTank.delete(subject);
 		return subjects.length;
 	}
 	/**
+	* Bring the consumable episodes in line with the thresholds the rules ask
+	* for (D642). A threshold with no episode for an item yet is judged from the
+	* item's last reading — a rule that gains a threshold hears about an item
+	* already past it on the next tick, not at the next slice write. A
+	* threshold that no rule asks for any more has its episodes RETIRED, but
+	* only when two consecutive censuses agree it is gone; retiring is silent
+	* (nothing recovered — nobody is listening at that number any more) and
+	* logged per row.
+	*/
+	reconcileThresholds(thresholds, settings) {
+		for (const { deviceId, item } of this.lastConsumable.values()) for (const thresholdPercent of thresholds) {
+			if (this.deps.rows.get(consumableSubject(thresholdPercent, deviceId, item.key))) continue;
+			this.judgeConsumable(deviceId, item, thresholdPercent, settings);
+		}
+		const absent = /* @__PURE__ */ new Set();
+		for (const row of this.deps.rows.all()) {
+			const parts = parseConsumableSubject(row.subject);
+			if (parts === null || thresholds.includes(parts.thresholdPercent)) continue;
+			absent.add(parts.thresholdPercent);
+			if (this.absentThresholds.has(parts.thresholdPercent)) this.dropRow(row.subject, "retired — no rule judges consumables at this threshold (D642)");
+		}
+		this.absentThresholds = absent;
+	}
+	/** Remove one row, mirror and durable, with a line that names why. */
+	dropRow(subject, reason) {
+		this.offeredAt.delete(subject);
+		this.logger()?.info(`device alert ${reason}`, {
+			...tagsOf(subject),
+			meta: { subject }
+		});
+		this.deps.rows.remove(subject).catch((error) => {
+			this.logger()?.warn("device alert row could not be removed", {
+				...tagsOf(subject),
+				meta: {
+					subject,
+					error: error instanceof Error ? error.message : String(error)
+				}
+			});
+		});
+	}
+	/**
 	* Offer every PENDING raise once more — when the rule set changed since its
 	* last offer, OR when {@link pendingCadenceMs} has passed since it. The
 	* cadence is what delivers a raise refused only by a rule's SCHEDULE (or any
@@ -11900,14 +12352,25 @@ var NcDeviceAlerts = class {
 	}
 	/** How to re-word a subject's alert from the last reading, or `null`. */
 	restatementOf(subject) {
-		const consumable = this.lastConsumable.get(subject);
-		if (consumable !== void 0) return (facts) => incomingFromConsumableBand({
+		const parts = parseConsumableSubject(subject);
+		const consumable = parts === null || parts.legacy ? void 0 : this.lastConsumable.get(itemKeyOf(parts.deviceId, parts.key));
+		if (parts !== null && consumable !== void 0) return (facts) => incomingFromConsumableBand({
 			facts,
 			deviceId: consumable.deviceId,
 			band: "low",
 			item: consumable.item,
+			thresholdPercent: parts.thresholdPercent,
 			identity: this.deps.lookup(consumable.deviceId)
 		});
+		const tank = this.lastTank.get(subject);
+		const tankBand = tank === void 0 ? null : deriveTankBand(tank.tank);
+		if (tank !== void 0 && (tankBand === "low" || tankBand === "full")) return (facts) => incomingFromTankBand({
+			facts,
+			deviceId: tank.deviceId,
+			band: tankBand,
+			tank: tank.tank.key,
+			identity: this.deps.lookup(tank.deviceId)
+		});
 		const battery = this.lastReading.get(subject);
 		if (battery !== void 0) return (facts) => incomingFromBatteryBand({
 			facts,
@@ -12007,11 +12470,9 @@ var NcDeviceAlerts = class {
 	report(subject, verdict, alerting) {
 		const logger = this.deps.logger;
 		if (logger === void 0) return;
-		const deviceId = alertSubjectDeviceId(subject);
-		const tags = deviceId !== void 0 ? { deviceId } : {};
 		if (verdict.kind === "silent" && !alerting) {
 			logger.debug("device alert cleared without a notification", {
-				tags,
+				...tagsOf(subject),
 				meta: {
 					subject,
 					reason: "notifyRecovery is off, or nothing changed"
@@ -12020,7 +12481,7 @@ var NcDeviceAlerts = class {
 			return;
 		}
 		logger.debug("device alert said nothing", {
-			tags,
+			...tagsOf(subject),
 			meta: {
 				subject,
 				verdict: verdict.kind
@@ -12431,6 +12892,21 @@ var en_default = {
 	"system.device-consumable-normal.title": "Consumable replaced",
 	"system.device-consumable-normal.body": "{{item}} on {{deviceName}} is back to {{percentage}}%",
 	"system.device-consumable-normal.body.unmeasured": "{{item}} on {{deviceName}} is OK again",
+	"system.device-tank-low.title": "Tank low",
+	"system.device-tank-full.title": "Tank full",
+	"system.device-tank-normal.title": "Tank OK",
+	"system.device-tank-low.body.cleanWater": "The clean water tank on {{deviceName}} is running low",
+	"system.device-tank-full.body.cleanWater": "The clean water tank on {{deviceName}} is full",
+	"system.device-tank-normal.body.cleanWater": "The clean water tank on {{deviceName}} is OK again",
+	"system.device-tank-low.body.dirtyWater": "The dirty water tank on {{deviceName}} is running low",
+	"system.device-tank-full.body.dirtyWater": "The dirty water tank on {{deviceName}} is full",
+	"system.device-tank-normal.body.dirtyWater": "The dirty water tank on {{deviceName}} is OK again",
+	"system.device-tank-low.body.detergent": "The detergent tank on {{deviceName}} is running low",
+	"system.device-tank-full.body.detergent": "The detergent tank on {{deviceName}} is full",
+	"system.device-tank-normal.body.detergent": "The detergent tank on {{deviceName}} is OK again",
+	"system.device-tank-low.body.dustBin": "The dust bin on {{deviceName}} is running low",
+	"system.device-tank-full.body.dustBin": "The dust bin on {{deviceName}} is full",
+	"system.device-tank-normal.body.dustBin": "The dust bin on {{deviceName}} is OK again",
 	"system.camera-online.title": "Device online",
 	"system.camera-online.body": "Device {{deviceName}} is online",
 	"system.camera-offline.title": "Device offline",
@@ -12460,6 +12936,7 @@ var en_default = {
 	"snooze.scope.anyRule": "A rule",
 	"snooze.scope.rule": "“{{rule}}”",
 	"alarm.arm.body.allDevices": "Active: all devices",
+	"alarm.arm.body.allDevicesExcept": "Active: all devices except {{count}}: {{names}}",
 	"alarm.arm.body.noDevices": "Active: no device restriction",
 	"alarm.arm.body.devices": "Active: {{names}}",
 	"alarm.arm.body.devicesSkipped": "Active: {{names}}\nExcluded: {{skippedNames}}",
@@ -12719,6 +13196,21 @@ var it_default = {
 	"system.device-consumable-normal.title": "Consumabile sostituito",
 	"system.device-consumable-normal.body": "{{item}} su {{deviceName}} è tornato al {{percentage}}%",
 	"system.device-consumable-normal.body.unmeasured": "{{item}} su {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.title": "Serbatoio quasi vuoto",
+	"system.device-tank-full.title": "Serbatoio pieno",
+	"system.device-tank-normal.title": "Serbatoio a posto",
+	"system.device-tank-low.body.cleanWater": "Il serbatoio dell'acqua pulita di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.cleanWater": "Il serbatoio dell'acqua pulita di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.cleanWater": "Il serbatoio dell'acqua pulita di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.dirtyWater": "Il serbatoio dell'acqua sporca di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.dirtyWater": "Il serbatoio dell'acqua sporca di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.dirtyWater": "Il serbatoio dell'acqua sporca di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.detergent": "Il serbatoio del detergente di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.detergent": "Il serbatoio del detergente di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.detergent": "Il serbatoio del detergente di {{deviceName}} è di nuovo a posto",
+	"system.device-tank-low.body.dustBin": "Il contenitore della polvere di {{deviceName}} è quasi vuoto",
+	"system.device-tank-full.body.dustBin": "Il contenitore della polvere di {{deviceName}} è pieno",
+	"system.device-tank-normal.body.dustBin": "Il contenitore della polvere di {{deviceName}} è di nuovo a posto",
 	"system.camera-online.title": "Dispositivo online",
 	"system.camera-online.body": "Il dispositivo {{deviceName}} è online",
 	"system.camera-offline.title": "Dispositivo offline",
@@ -12748,6 +13240,7 @@ var it_default = {
 	"snooze.scope.anyRule": "Una regola",
 	"snooze.scope.rule": "“{{rule}}”",
 	"alarm.arm.body.allDevices": "Attivi: tutti i dispositivi",
+	"alarm.arm.body.allDevicesExcept": "Attivi: tutti i dispositivi tranne {{count}}: {{names}}",
 	"alarm.arm.body.noDevices": "Attivi: nessuna restrizione",
 	"alarm.arm.body.devices": "Attivi: {{names}}",
 	"alarm.arm.body.devicesSkipped": "Attivi: {{names}}\nEsclusi: {{skippedNames}}",
@@ -13262,7 +13755,7 @@ function assertPatchKeepsFamily(existing, patch) {
 * the offending kind or filter). Then rethrow. A refused save is dropped work,
 * and dropped work is never silent. Any other error passes through unlogged.
 */
-function logRefusal(check, ctx) {
+function logRefusal$2(check, ctx) {
 	try {
 		check();
 	} catch (err) {
@@ -13278,11 +13771,115 @@ function logRefusal(check, ctx) {
 }
 /** {@link assertRuleFamily}, logged. The create path of both routes. */
 function guardRuleFamily(rule, ctx) {
-	logRefusal(() => assertRuleFamily(rule), ctx);
+	logRefusal$2(() => assertRuleFamily(rule), ctx);
 }
 /** {@link assertPatchKeepsFamily}, logged. The update path of both routes. */
 function guardPatchFamily(existing, patch, ctx) {
-	logRefusal(() => assertPatchKeepsFamily(existing, patch), ctx);
+	logRefusal$2(() => assertPatchKeepsFamily(existing, patch), ctx);
+}
+//#endregion
+//#region src/notification-center/device-scope-guard.ts
+/**
+* The deliveries whose evaluation reads the device scope — the `devices`
+* descriptor's `appliesTo`, restated as the one delivery that lacks it.
+*/
+var NO_DEVICE_SCOPE_DELIVERY = "system-event";
+var NcDevicesExcludeRefusal = class extends Error {
+	delivery;
+	devicesExclude;
+	constructor(delivery, devicesExclude) {
+		super(`rule refused: devicesExclude does not apply to a '${delivery}' rule — a system rule excludes devices with systemEvent.excludeDeviceIds`);
+		this.name = "NcDevicesExcludeRefusal";
+		this.delivery = delivery;
+		this.devicesExclude = devicesExclude;
+	}
+};
+function assertDevicesExcludeDelivery(rule) {
+	const excluded = rule.conditions.devicesExclude;
+	if (excluded === void 0 || rule.delivery !== NO_DEVICE_SCOPE_DELIVERY) return;
+	throw new NcDevicesExcludeRefusal(rule.delivery, excluded);
+}
+/** Run the check; a refusal is dropped work, so it is logged before it is rethrown. */
+function logRefusal$1(check, ctx) {
+	try {
+		check();
+	} catch (err) {
+		if (err instanceof NcDevicesExcludeRefusal) warnRefusal$1(ctx.logger, err, ctx);
+		throw err;
+	}
+}
+function warnRefusal$1(logger, err, ctx) {
+	logger.warn("nc rule refused: devicesExclude on a system rule", { meta: {
+		...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
+		by: ctx.by,
+		delivery: err.delivery,
+		devicesExclude: [...err.devicesExclude]
+	} });
+}
+/** The create path of both routes. */
+function guardRuleDevicesExclude(rule, ctx) {
+	logRefusal$1(() => assertDevicesExcludeDelivery(rule), ctx);
+}
+/**
+* The update path of both routes: the MERGED rule is judged, and only when the
+* patch changes `delivery` or `conditions`.
+*/
+function guardPatchDevicesExclude(existing, patch, ctx) {
+	if (existing === null) return;
+	const merged = mergedFamilySubject(existing, patch);
+	if (merged === null) return;
+	logRefusal$1(() => assertDevicesExcludeDelivery(merged), ctx);
+}
+//#endregion
+//#region src/notification-center/sensor-transition-guard.ts
+/** The one delivery whose subject carries a sensor edge. */
+var SENSOR_TRANSITION_DELIVERY = "device-event";
+var NcSensorTransitionRefusal = class extends Error {
+	delivery;
+	sensorTransition;
+	constructor(delivery, sensorTransition) {
+		super(`rule refused: sensorTransition '${sensorTransition}' applies only to a device-event rule, not '${delivery}'`);
+		this.name = "NcSensorTransitionRefusal";
+		this.delivery = delivery;
+		this.sensorTransition = sensorTransition;
+	}
+};
+function assertSensorTransitionDelivery(rule) {
+	const transition = rule.conditions.sensorTransition;
+	if (transition === void 0 || rule.delivery === SENSOR_TRANSITION_DELIVERY) return;
+	throw new NcSensorTransitionRefusal(rule.delivery, transition);
+}
+/** Run the check; a refusal is dropped work, so it is logged before it is rethrown. */
+function logRefusal(check, ctx) {
+	try {
+		check();
+	} catch (err) {
+		if (err instanceof NcSensorTransitionRefusal) warnRefusal(ctx.logger, err, ctx);
+		throw err;
+	}
+}
+function warnRefusal(logger, err, ctx) {
+	logger.warn("nc rule refused: sensorTransition off a device-event rule", { meta: {
+		...ctx.ruleId !== void 0 ? { ruleId: ctx.ruleId } : {},
+		by: ctx.by,
+		delivery: err.delivery,
+		sensorTransition: err.sensorTransition
+	} });
+}
+/** The create path of both routes. */
+function guardRuleSensorTransition(rule, ctx) {
+	logRefusal(() => assertSensorTransitionDelivery(rule), ctx);
+}
+/**
+* The update path of both routes: the MERGED rule is judged, and only when the
+* patch changes `delivery` or `conditions` — an unchanged full-form save
+* (a rename, a retarget) is not re-judged.
+*/
+function guardPatchSensorTransition(existing, patch, ctx) {
+	if (existing === null) return;
+	const merged = mergedFamilySubject(existing, patch);
+	if (merged === null) return;
+	logRefusal(() => assertSensorTransitionDelivery(merged), ctx);
 }
 //#endregion
 //#region src/notification-center/occupancy-watcher.ts
@@ -13997,6 +14594,10 @@ function systemEventKeys(kind) {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body.ignored`
 	};
+	if (require_dist.NC_TANK_SYSTEM_EVENT_KINDS.includes(kind)) return {
+		titleKey: `system.${kind}.title`,
+		bodyKey: `system.${kind}.body.cleanWater`
+	};
 	return {
 		titleKey: `system.${kind}.title`,
 		bodyKey: `system.${kind}.body`
@@ -14053,6 +14654,19 @@ function labelFor(conditions) {
 	return conditions.identities?.[0] ?? conditions.labelEquals?.[0] ?? conditions.plates?.values?.[0] ?? void 0;
 }
 /**
+* The edge a planned sensor event carries (D640): RAISED by default — the
+* alert, which is what an operator pressing Test on a flood rule expects to
+* see — and cleared only for a rule that asks for the clear. Only for a kind
+* that HAS a raise: a doorbell press carries none in production, and a test
+* subject claiming one would be a subject no real record could be.
+*/
+function sensorEdgeFor(trigger, c) {
+	const kind = c.sensorKinds?.[0];
+	if (trigger !== "device-event" || kind === void 0) return {};
+	if (!require_dist.NC_SENSOR_TRANSITION_KINDS.includes(kind.trim().toLowerCase())) return {};
+	return { sensorRaised: c.sensorTransition !== "cleared" };
+}
+/**
 * Plan the injection that fires this rule.
 *
 * Every condition the engine reads off the SUBJECT is satisfied here; the two
@@ -14074,6 +14688,10 @@ function planRuleTest(input) {
 		note: "This rule names no camera and none was supplied, so the event is attributed to no device and carries no picture. Scope the rule to a camera, or pick one, to see the notification it would really send."
 	});
 	const deviceId = scopedDeviceId ?? NC_SYSTEM_DEVICE_ID;
+	if (trigger !== "system-event" && (c.devicesExclude ?? []).includes(deviceId)) notes.push({
+		conditionId: "devicesExclude",
+		note: "The camera this test uses is one the rule excludes, so the evaluation will refuse the event — exactly as it refuses every real one there. Pick another camera to see the notification."
+	});
 	const scheduledAt = scheduleActiveAt(rule.schedule, now);
 	if (scheduledAt === null) notes.push({
 		conditionId: "schedule",
@@ -14123,6 +14741,7 @@ function planRuleTest(input) {
 			} } : {},
 			...c.sensorKinds?.[0] !== void 0 ? { sensorKind: c.sensorKinds[0] } : {},
 			...c.eventTypeTokens?.[0] !== void 0 ? { eventType: c.eventTypeTokens[0] } : {},
+			...sensorEdgeFor(trigger, c),
 			...trigger === "package-event" ? { packagePhase: c.packagePhase === "picked-up" ? "picked-up" : "delivered" } : {},
 			...c.source !== void 0 && c.source !== "any" ? { source: c.source } : {},
 			...bbox !== void 0 ? { bbox } : {},
@@ -14656,6 +15275,10 @@ var NcTestEventInputSchema = require_dist.object({
 	/** DEVICE-EVENT: the raw device event-type token, when the source is an
 	*  event-emitter slice. */
 	eventType: require_dist.string().optional(),
+	/** DEVICE-EVENT: which edge a boolean sensor moved on — true raised, false
+	*  cleared (D640). Absent = the slice could not say, which production
+	*  answers for a doorbell press or an unreadable read. */
+	sensorRaised: require_dist.boolean().optional(),
 	/** PACKAGE-EVENT: which lifecycle phase. */
 	packagePhase: require_dist._enum(["delivered", "picked-up"]).optional(),
 	/** Detection provenance. Absent = `pipeline` (what a record with no stamped
@@ -14874,6 +15497,7 @@ function buildSyntheticEvent(input, recordId, now) {
 			...input.labelConfidence !== void 0 ? { labelConfidence: input.labelConfidence } : {},
 			...input.sensorKind !== void 0 ? { sensorKind: input.sensorKind } : {},
 			...input.eventType !== void 0 ? { eventType: input.eventType } : {},
+			...input.sensorRaised !== void 0 ? { sensorRaised: input.sensorRaised } : {},
 			...input.packagePhase !== void 0 ? { packagePhase: input.packagePhase } : {},
 			...input.bbox !== void 0 ? { bbox: input.bbox } : {},
 			...input.crossing !== void 0 ? { crossing: input.crossing } : {},
@@ -15989,7 +16613,7 @@ function makeNcActionHandlers(deps) {
 			catalog: [...require_dist.NC_CONDITION_CATALOG],
 			taxonomy: require_dist.NC_TAXONOMY
 		}),
-		"nc.getTemplateCatalog": async () => ({ vars: [...require_dist.NC_TEMPLATE_VARS] }),
+		"nc.getTemplateCatalog": async () => ({ vars: require_dist.servedTemplateVars() }),
 		"nc.previewTemplate": async (input) => {
 			const texts = deps.previewTexts;
 			if (texts === void 0) throw new Error("nc.previewTemplate: text catalog not wired");
@@ -16004,6 +16628,14 @@ function makeNcActionHandlers(deps) {
 				logger: deps.logger,
 				by: c.userId
 			});
+			guardRuleSensorTransition(parsed, {
+				logger: deps.logger,
+				by: c.userId
+			});
+			guardRuleDevicesExclude(parsed, {
+				logger: deps.logger,
+				by: c.userId
+			});
 			await assertTargetsOwned(parsed.targets.map((t) => t.targetId), c);
 			const rule = await deps.ruleStore.create({
 				...parsed,
@@ -16027,6 +16659,16 @@ function makeNcActionHandlers(deps) {
 				by: c.userId,
 				ruleId: input.ruleId
 			});
+			guardPatchSensorTransition(existing, patch, {
+				logger: deps.logger,
+				by: c.userId,
+				ruleId: input.ruleId
+			});
+			guardPatchDevicesExclude(existing, patch, {
+				logger: deps.logger,
+				by: c.userId,
+				ruleId: input.ruleId
+			});
 			if (patch.targets !== void 0) await assertTargetsOwned(patch.targets.map((t) => t.targetId), c);
 			const { ownerUserId: _owner, disabledTargetIds: _optOut, ...safe } = patch;
 			const rule = await deps.ruleStore.update(input.ruleId, safe, clear);
@@ -19170,6 +19812,19 @@ function pruneRuleConditions(conditions, isDead, notes) {
 			notes.removed("conditions.devices", deviceSubjects(verdict.dead));
 		}
 	}
+	const excluded = conditions.devicesExclude;
+	if (excluded !== void 0) {
+		const verdict = judgeList(excluded, isDead);
+		if (!verdict.untouched) {
+			const { devicesExclude: _dead, ...rest } = next;
+			next = verdict.last ? rest : {
+				...rest,
+				devicesExclude: [...verdict.next]
+			};
+			changed = true;
+			notes.removed("conditions.devicesExclude", deviceSubjects(verdict.dead));
+		}
+	}
 	const systemEvent = conditions.systemEvent;
 	if (systemEvent?.deviceIds !== void 0) {
 		const verdict = judgeList(systemEvent.deviceIds, isDead);
@@ -19350,6 +20005,7 @@ function referencedDeviceIds(snapshot) {
 	for (const rule of snapshot.rules) {
 		const c = rule.conditions;
 		add(c.devices);
+		add(c.devicesExclude);
 		add(c.systemEvent?.deviceIds);
 		if (c.deviceState !== void 0) ids.add(c.deviceState.deviceId);
 		if (c.scene?.deviceId !== void 0) ids.add(c.scene.deviceId);
@@ -22203,6 +22859,50 @@ var NcOutbox = class {
 			return [];
 		}
 	}
+	/**
+	* The rows `getRuleLastRuns` reduces — ONE statement: fire time inside
+	* `[sinceMs, ∞)`, newest-first on `idx_nc_outbox_created`, projected to the
+	* four columns the reduction reads (never the `payload` JSON), at most
+	* `limit` rows. `sinceMs: null` = no lower bound (the operator keeps the
+	* outbox forever); `limit` still bounds the read.
+	*
+	* Unlike {@link queryHistory} this THROWS on a store error: its caller
+	* answers "which rules did not run", and an empty page from a failed read
+	* would answer "none of them did" (D393).
+	*/
+	async queryLastRunRows(sinceMs, limit) {
+		const rows = await this.store.query.query({
+			collection: NC_OUTBOX_COLLECTION,
+			filter: {
+				...sinceMs !== null ? { whereBetween: { createdAt: [sinceMs, Number.MAX_SAFE_INTEGER] } } : {},
+				orderBy: {
+					field: "createdAt",
+					direction: "desc"
+				},
+				limit
+			},
+			columns: [...NC_LAST_RUN_COLUMNS]
+		});
+		const out = [];
+		let malformed = 0;
+		let oldestReadAt = null;
+		for (const row of rows) {
+			const at = Number(row.data["createdAt"]);
+			if (Number.isFinite(at) && (oldestReadAt === null || at < oldestReadAt)) oldestReadAt = at;
+			const parsed = lastRunRow(row.data);
+			if (parsed === null) malformed += 1;
+			else out.push(parsed);
+		}
+		if (malformed > 0) this.logger.warn("last-run read skipped malformed outbox rows", { meta: {
+			malformed,
+			read: rows.length
+		} });
+		return {
+			rows: out,
+			truncated: rows.length >= limit,
+			oldestReadAt
+		};
+	}
 	async getWatermark() {
 		try {
 			const row = await this.store.get.query({
@@ -22490,6 +23190,27 @@ function rowToEntry$1(id, data) {
 		payload
 	};
 }
+/** The columns {@link NcOutbox.queryLastRunRows} projects. */
+var NC_LAST_RUN_COLUMNS = [
+	"ruleId",
+	"createdAt",
+	"status",
+	"deviceId"
+];
+/** A projected row back to a {@link NcLastRunRow} — a guard, never a cast. */
+function lastRunRow(data) {
+	const ruleId = data["ruleId"];
+	const createdAt = Number(data["createdAt"]);
+	const deviceId = Number(data["deviceId"]);
+	const status = data["status"];
+	if (typeof ruleId !== "string" || !Number.isFinite(createdAt) || !Number.isFinite(deviceId) || status !== "pending" && status !== "sent" && status !== "dead") return null;
+	return {
+		ruleId,
+		createdAt,
+		status,
+		deviceId
+	};
+}
 //#endregion
 //#region src/notification-center/rule-actions.ts
 var NcRuleActionRunner = class {
@@ -23181,6 +23902,58 @@ var NcRuleAiStore = class {
 	}
 };
 //#endregion
+//#region src/notification-center/rule-last-runs.ts
+/**
+* Row bound of the one read. Projected rows are four scalars (~100 B), so the
+* bound costs ~2 MB at worst. The live outbox volume was NOT measured when
+* this was chosen. It exists so a runaway rule cannot turn an admin page load
+* into a table walk — and when it bites, `horizonMs` says so.
+*/
+var NC_RULE_LAST_RUNS_SCAN_LIMIT = 2e4;
+/** Least successful first: a fire that reached some targets and not others
+*  did not "deliver". */
+var STATUS_SEVERITY = {
+	sent: 0,
+	pending: 1,
+	dead: 2
+};
+function worse(a, b) {
+	return STATUS_SEVERITY[b] > STATUS_SEVERITY[a] ? b : a;
+}
+/**
+* Reduce newest-first rows to one run per rule, in one pass.
+*
+* Rows sharing the newest `createdAt` of a rule are one fire to several
+* targets; they merge into the least successful status. `read.rows` MUST be
+* ordered newest-first — that is what the outbox read asks the store for.
+*/
+function summariseRuleLastRuns(read, scan) {
+	const byRule = /* @__PURE__ */ new Map();
+	for (const row of read.rows) {
+		const seen = byRule.get(row.ruleId);
+		if (seen === void 0) byRule.set(row.ruleId, {
+			ruleId: row.ruleId,
+			lastAt: row.createdAt,
+			status: row.status,
+			deviceId: row.deviceId
+		});
+		else if (seen.lastAt === row.createdAt && worse(seen.status, row.status) !== seen.status) byRule.set(row.ruleId, {
+			...seen,
+			status: row.status,
+			deviceId: row.deviceId
+		});
+	}
+	return {
+		runs: [...byRule.values()],
+		horizonMs: horizonOf(read, scan)
+	};
+}
+/** How far back the answer really looked — see the module doc. */
+function horizonOf(read, scan) {
+	if (read.truncated && read.oldestReadAt !== null) return Math.max(0, scan.now - read.oldestReadAt);
+	return scan.windowMs;
+}
+//#endregion
 //#region src/notification-center/durable-reread.ts
 function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -23420,7 +24193,7 @@ var NcRuleStore = class {
 	*/
 	async load() {
 		await this.ledger.load();
-		this.loaded = true;
+		if (this.ledger.hasAnswered()) this.loaded = true;
 		this.logger.debug("notification rules loaded", { meta: { rules: this.ledger.size } });
 	}
 	/**
@@ -27850,7 +28623,6 @@ var ARM_ANYWAY_REJECTION_COPY = {
 */
 var NC_DEVICE_ALERT_FALLBACK = {
 	batteryLowPercent: 20,
-	consumableLowPercent: 15,
 	renotifyMinutes: 720,
 	notifyRecovery: true
 };
@@ -28145,9 +28917,14 @@ function outboxEntryToHistory(texts, entry) {
 function renderAudioSpec(spec) {
 	return spec.mode === "label" ? `label:${spec.labels.join("+")}` : `level:${String(spec.dbThreshold)}dBFS|h${String(spec.hitPercent)}|s${String(spec.samplingSeconds)}`;
 }
-/** The camera scope in one token — `@all` is a real answer, not a missing one. */
-function renderAudioScope(devices) {
-	return devices.length === 0 ? "@all" : devices.join("+");
+/**
+* The camera scope in one token — `@all` is a real answer, not a missing one,
+* and `@all-except:<ids>` is a different one (D641): an excluding rule logged
+* as `@all` would claim the camera it never watches.
+*/
+function renderAudioScope(devices, excluded) {
+	if (devices.length === 0) return excluded.length === 0 ? "@all" : `@all-except:${excluded.join("+")}`;
+	return devices.filter((id) => !excluded.includes(id)).join("+");
 }
 var NotificationCenter = class NotificationCenter {
 	logger;
@@ -29100,6 +29877,7 @@ var NotificationCenter = class NotificationCenter {
 				return (await this.consumeEventAndReport(event)).outcomes.some((outcome) => outcome.matched);
 			},
 			rulesVersion: () => this.rulesFingerprint(),
+			consumableThresholds: () => this.rules.isLoaded() ? consumableThresholdCensus(this.rules.list()) : null,
 			settings: () => this.deviceAlertSettings(),
 			lookup: (deviceId) => this.deviceDirectory.get(deviceId),
 			rows: this.alertStore.port(),
@@ -29889,7 +30667,7 @@ var NotificationCenter = class NotificationCenter {
 	* scope the evaluation will match on (`matchesDeviceScope`).
 	*/
 	beginLinkedStills(request) {
-		const { sensorId, sensorKind, cameraIds, atMs, rowCameraIds } = request;
+		const { sensorId, sensorKind, cameraIds, atMs, rowCameraIds, sensorRaised } = request;
 		const shelf = this.linkedStills;
 		if (shelf === null || !this.evaluationActive || cameraIds.length < 2) return void 0;
 		if (this.deviceMutes.isMuted(sensorId)) return void 0;
@@ -29899,7 +30677,13 @@ var NotificationCenter = class NotificationCenter {
 		const involved = [sensorId, ...rowShown];
 		if (!this.rules.listEnabled("device-event").some((rule) => {
 			if (rule.media.attach === "none") return false;
-			if (!deviceEventRuleMayFireOnKind(rule, sensorKind)) return false;
+			if (!deviceEventRuleMayFireOnKind(rule, sensorKind, sensorRaised)) return false;
+			const excluded = rule.conditions.devicesExclude;
+			if (excluded !== void 0 && deviceScopeExcludes(excluded, {
+				deviceId: sensorId,
+				linkedSensorId: sensorId,
+				rowCameraIds: rowShown
+			})) return false;
 			const devices = rule.conditions.devices;
 			return devices === void 0 || devices.length === 0 || devices.some((id) => involved.includes(id));
 		})) return void 0;
@@ -30021,6 +30805,8 @@ var NotificationCenter = class NotificationCenter {
 			if (!(mode === "condition" ? rule.conditions.audio !== void 0 : rule.conditions.audio === void 0 && referencesAudioClass(rule.conditions.classes))) continue;
 			const devices = rule.conditions.devices;
 			if (devices !== void 0 && devices.length > 0 && !devices.includes(deviceId)) continue;
+			const excluded = rule.conditions.devicesExclude;
+			if (excluded !== void 0 && deviceScopeExcludes(excluded, { deviceId })) continue;
 			return shelf.capture(deviceId, atMs, "audio");
 		}
 	}
@@ -30123,6 +30909,8 @@ var NotificationCenter = class NotificationCenter {
 			if (occ === void 0 || !matchesOccupancy(occ, subject)) continue;
 			const devices = rule.conditions.devices;
 			if (devices !== void 0 && devices.length > 0 && !devices.includes(edge.deviceId)) continue;
+			const excluded = rule.conditions.devicesExclude;
+			if (excluded !== void 0 && deviceScopeExcludes(excluded, { deviceId: edge.deviceId })) continue;
 			return shelf.capture(edge.deviceId, edge.timestamp, "occupancy");
 		}
 	}
@@ -30198,6 +30986,11 @@ var NotificationCenter = class NotificationCenter {
 			for (const item of consumables.items) this.deviceAlerts.observeConsumable(consumables.deviceId, item);
 			return;
 		}
+		const tanks = event.category === "device.state-changed" ? vacuumTanksOf(event.data) : null;
+		if (tanks !== null) {
+			for (const tank of tanks.tanks) this.deviceAlerts.observeTank(tanks.deviceId, tank);
+			return;
+		}
 		const lookup = this.deviceDirectory.lookup();
 		const incoming = incomingFromSystemEvent(event, lookup);
 		if (incoming === null) {
@@ -30258,6 +31051,14 @@ var NotificationCenter = class NotificationCenter {
 					logger: this.logger,
 					by: caller.userId
 				});
+				guardRuleSensorTransition(rule, {
+					logger: this.logger,
+					by: caller.userId
+				});
+				guardRuleDevicesExclude(rule, {
+					logger: this.logger,
+					by: caller.userId
+				});
 				await this.validateTargetRefs(rule.targets.map((t) => t.targetId));
 				const created = await this.rules.create(rule, caller.userId);
 				this.logger.info("notification rule created", { meta: {
@@ -30276,6 +31077,16 @@ var NotificationCenter = class NotificationCenter {
 					by: caller.userId,
 					ruleId
 				});
+				guardPatchSensorTransition(existing, patch, {
+					logger: this.logger,
+					by: caller.userId,
+					ruleId
+				});
+				guardPatchDevicesExclude(existing, patch, {
+					logger: this.logger,
+					by: caller.userId,
+					ruleId
+				});
 				const { disabledTargetIds: _optOut, ...safePatch } = patch;
 				const updated = await this.rules.update(ruleId, safePatch, clear ?? []);
 				this.logger.info("notification rule updated", { meta: {
@@ -30298,7 +31109,7 @@ var NotificationCenter = class NotificationCenter {
 				catalog: [...require_dist.NC_CONDITION_CATALOG],
 				taxonomy: require_dist.NC_TAXONOMY
 			}),
-			getTemplateCatalog: async () => ({ vars: [...require_dist.NC_TEMPLATE_VARS] }),
+			getTemplateCatalog: async () => ({ vars: require_dist.servedTemplateVars() }),
 			previewTemplate: async (input) => previewTemplate(this.texts, input),
 			getHistory: async ({ filter }) => {
 				const entries = await this.outbox.queryHistory({
@@ -30317,6 +31128,14 @@ var NotificationCenter = class NotificationCenter {
 				}
 				return { entries: mapped };
 			},
+			getRuleLastRuns: async () => {
+				const now = this.now();
+				const windowMs = (await this.deps.pruneWindows()).outboxMs;
+				return summariseRuleLastRuns(await this.outbox.queryLastRunRows(windowMs !== null ? now - windowMs : null, NC_RULE_LAST_RUNS_SCAN_LIMIT), {
+					now,
+					windowMs
+				});
+			},
 			resolveArtifactUrl: async ({ artifactId }) => ({ url: await this.deps.resolveArtifactUrl?.(artifactId) ?? null }),
 			listDeviceMutes: async () => ({ mutedDeviceIds: this.deviceMutes.listMuted() }),
 			setDeviceMuted: async ({ deviceId, muted }) => {
@@ -30648,6 +31467,7 @@ var NotificationCenter = class NotificationCenter {
 			coverage: this.coverageFor(panel).map((c) => ({
 				...c,
 				deviceIds: [...c.deviceIds],
+				allDevicesExcept: [...c.allDevicesExcept],
 				skippedDevices: c.skippedDevices.map((s) => ({ ...s }))
 			}))
 		};
@@ -31157,6 +31977,9 @@ var NotificationCenter = class NotificationCenter {
 						failed: evaluation.failedCondition,
 						classes: subject.classNames,
 						...subject.sensorEdge !== void 0 ? { sensorEdge: subject.sensorEdge } : {},
+						...subject.sensorRaised !== void 0 ? { sensorRaised: subject.sensorRaised } : {},
+						...subject.sourceDeviceId !== void 0 ? { sourceDeviceId: subject.sourceDeviceId } : {},
+						...subject.linkedSensorId !== void 0 ? { linkedSensorId: subject.linkedSensorId } : {},
 						eventId: subject.recordId,
 						...subject.trackId !== void 0 ? { trackId: subject.trackId } : {}
 					}
@@ -31266,7 +32089,11 @@ var NotificationCenter = class NotificationCenter {
 					eventId: subject.recordId,
 					...subject.trackId !== void 0 ? { trackId: subject.trackId } : {},
 					...subject.confidence !== void 0 ? { confidence: subject.confidence } : {},
-					...subject.zones.length > 0 ? { zones: subject.zones } : {}
+					...subject.zones.length > 0 ? { zones: subject.zones } : {},
+					...rule.conditions.sensorTransition !== void 0 ? {
+						sensorTransition: rule.conditions.sensorTransition,
+						sensorRaised: subject.sensorRaised ?? null
+					} : {}
 				}
 			});
 			const unresolvable = unresolvableButtons(rule.actions);
@@ -31873,7 +32700,8 @@ var NotificationCenter = class NotificationCenter {
 				ruleId: rule.id,
 				ruleName: rule.name,
 				spec,
-				devices: rule.conditions.devices ?? []
+				devices: rule.conditions.devices ?? [],
+				excluded: rule.conditions.devicesExclude ?? []
 			});
 		}
 		this.audioWatcher.setWatchedSpecs(audioSpecs);
@@ -31965,10 +32793,12 @@ var NotificationCenter = class NotificationCenter {
 	* for at all"; the per-camera line answers "why is 617 not notifying" — and
 	* that question is ALWAYS asked per camera, so the line carries
 	* `tags.deviceId` and a rule scoped to no camera is reported as watching
-	* every one rather than silently omitted.
+	* every one rather than silently omitted — every one EXCEPT its
+	* `devicesExclude` cameras (D641), each of which gets its own NOT-watching
+	* line on that camera.
 	*/
 	reportAudioWatch(entries) {
-		const rendered = entries.map((e) => `${e.ruleId}=${renderAudioSpec(e.spec)}@${renderAudioScope(e.devices)}`).toSorted().join(",");
+		const rendered = entries.map((e) => `${e.ruleId}=${renderAudioSpec(e.spec)}@${renderAudioScope(e.devices, e.excluded)}`).toSorted().join(",");
 		if (rendered === this.lastAudioWatchReport) return;
 		this.lastAudioWatchReport = rendered;
 		this.logger.info("audio watched specs", { meta: {
@@ -31982,14 +32812,28 @@ var NotificationCenter = class NotificationCenter {
 				mode: entry.spec.mode,
 				spec: renderAudioSpec(entry.spec)
 			};
+			for (const deviceId of entry.excluded) this.logger.info("audio rule NOT watching camera", {
+				tags: { deviceId },
+				meta: {
+					...meta,
+					reason: "devicesExclude"
+				}
+			});
 			if (entry.devices.length === 0) {
-				this.logger.info("audio rule watching every camera", { meta });
+				if (entry.excluded.length === 0) this.logger.info("audio rule watching every camera", { meta });
+				else this.logger.info("audio rule watching every camera except the excluded", { meta: {
+					...meta,
+					excluded: [...entry.excluded]
+				} });
 				continue;
 			}
-			for (const deviceId of entry.devices) this.logger.info("audio rule watching camera", {
-				tags: { deviceId },
-				meta
-			});
+			for (const deviceId of entry.devices) {
+				if (entry.excluded.includes(deviceId)) continue;
+				this.logger.info("audio rule watching camera", {
+					tags: { deviceId },
+					meta
+				});
+			}
 		}
 	}
 	/** Boot reseed of confirmed occupancy edge-state (durability, constraint 4) —
@@ -32068,7 +32912,6 @@ var NotificationCenter = class NotificationCenter {
 	deviceAlertSettings() {
 		return this.deps.readDeviceAlertSettings?.() ?? {
 			batteryLowPercent: NC_DEVICE_ALERT_FALLBACK.batteryLowPercent,
-			consumableLowPercent: NC_DEVICE_ALERT_FALLBACK.consumableLowPercent,
 			renotifyMinutes: NC_DEVICE_ALERT_FALLBACK.renotifyMinutes,
 			notifyRecovery: NC_DEVICE_ALERT_FALLBACK.notifyRecovery
 		};
@@ -55690,19 +56533,6 @@ var DeviceAlertSettingsSchema = require_dist.object({
 	*/
 	batteryLowPercent: require_dist.number().int().min(1).max(99).default(20),
 	/**
-	* What counts as a nearly-exhausted CONSUMABLE — a filter, a brush, a mop pad.
-	*
-	* Its own number and not the battery's, because the two are different chores
-	* on different clocks: a battery at 20 % is hours from flat, a brush at 20 %
-	* is weeks from worn, and an operator who wants to be told early about one
-	* does not necessarily want to be told early about the other.
-	*
-	* Applies to the MEASURED side only. An item whose provider states a
-	* `replace` verdict is low whatever this says — the provider decided, and a
-	* threshold cannot talk it out of it (`alerts/consumable-band.ts`).
-	*/
-	consumableLowPercent: require_dist.number().int().min(1).max(99).default(15),
-	/**
 	* How long a still-true alert waits before it says itself again.
 	*
 	* **0 = say it once.** That is the behaviour of every other notification this
@@ -77406,7 +78236,7 @@ function buildGlobalSettingsSchema(cap) {
 		{
 			id: "device-alerts",
 			title: "Battery & offline alerts",
-			description: "What counts as a low battery, how often a still-true alert is repeated, and whether the return to normal is announced. These govern the “Battery” and “Devices & streams” system-event rules; the rules themselves still choose which devices and which kinds. A device with a binary low-battery indicator (no real percentage) is judged by the indicator, and the threshold below does not apply to it.",
+			description: "What counts as a low battery, how often a still-true alert is repeated, and whether the return to normal is announced. These govern the device-event rules; the rules themselves still choose which devices and which kinds — and each rule sets its own consumable threshold. A device with a binary low-battery indicator (no real percentage) is judged by the indicator, and the threshold below does not apply to it.",
 			columns: 2,
 			fields: [
 				{
@@ -77420,17 +78250,6 @@ function buildGlobalSettingsSchema(cap) {
 					default: DEVICE_ALERT_DEFAULTS.batteryLowPercent,
 					unit: "%"
 				},
-				{
-					type: "number",
-					key: "consumableLowPercent",
-					label: "Low consumable at",
-					description: "At or below this, a measured consumable — a filter, a brush, a mop pad — is nearly exhausted. Its own number rather than the battery’s: a battery at 20% is hours from flat, a brush at 20% is weeks from worn. An item whose device reports “replace” outright is announced whatever this says.",
-					min: 1,
-					max: 99,
-					step: 1,
-					default: DEVICE_ALERT_DEFAULTS.consumableLowPercent,
-					unit: "%"
-				},
 				{
 					type: "number",
 					key: "alertRenotifyMinutes",
@@ -83590,7 +84409,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			},
 			readDeviceAlertSettings: () => ({
 				batteryLowPercent: this.deviceAlertSettingsMirror.batteryLowPercent,
-				consumableLowPercent: this.deviceAlertSettingsMirror.consumableLowPercent,
 				renotifyMinutes: this.deviceAlertSettingsMirror.alertRenotifyMinutes,
 				notifyRecovery: this.deviceAlertSettingsMirror.alertNotifyRecovery
 			}),
@@ -89431,10 +90249,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	startLinkedStills(data, timestamp, cameras) {
 		const sensorKind = require_dist.EVENT_KIND_BY_CAP[data.capName]?.kind;
 		if (sensorKind === void 0) return void 0;
+		const sensorRaised = require_dist.sensorRaisedOf(sensorKind, sensorSliceRecord(data.slice));
 		try {
 			return this.notificationCenter?.beginLinkedStills({
 				sensorId: data.deviceId,
 				sensorKind,
+				...sensorRaised !== void 0 ? { sensorRaised } : {},
 				cameraIds: cameras.mediaCameraIds,
 				rowCameraIds: cameras.rowCameraIds,
 				atMs: timestamp