@camstack/addon-post-analysis 1.2.665 → 1.2.667

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-nn_STiGt.js");
+const require_clip_model_registry = require("../clip-model-registry-D7cqhFK3.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -7354,6 +7354,18 @@ function sensorEdgeOf(kind, value) {
 	if (HALTED.has(opening.state)) return "neither";
 	if (OPENING.has(opening.state)) return "opening";
 }
+/**
+* The WORD a sensor change is told with — the state the device moved to, read off
+* the same slice the edge is: `unlocked`, `open`, `closed`… for a lock, cover, contact
+* or switch, else `raised` / `cleared` for a boolean sensor (water, smoke…). Undefined
+* when the slice cannot say: a sentence never invents a state (D393).
+*/
+function sensorStateWordOf(kind, value, raised) {
+	const opening = alarmOpeningFromSensorEvent(kind, value);
+	if (opening.kind === "reading") return opening.state;
+	if (raised === void 0) return void 0;
+	return raised ? "raised" : "cleared";
+}
 //#endregion
 //#region src/notification-center/audio-rule-matcher.ts
 /**
@@ -7861,6 +7873,7 @@ function subjectFromSensorEvent(ev, markerTrackId, linked) {
 	const eventType = readSensorEventType(ev.value);
 	const sensorEdge = sensorEdgeOf(ev.kind, ev.value);
 	const sensorRaised = require_clip_model_registry.sensorRaisedOf(ev.kind, ev.value);
+	const sensorState = sensorStateWordOf(ev.kind, ev.value, sensorRaised);
 	return {
 		kind: "device-event",
 		recordId: String(ev.id),
@@ -7875,6 +7888,7 @@ function subjectFromSensorEvent(ev, markerTrackId, linked) {
 		...eventType !== void 0 ? { eventType } : {},
 		...sensorEdge !== void 0 ? { sensorEdge } : {},
 		...sensorRaised !== void 0 ? { sensorRaised } : {},
+		...sensorState !== void 0 ? { sensorState } : {},
 		...linked !== void 0 ? {
 			linkedSensorId: ev.sourceDeviceId,
 			linkedCameraIds: [...linked.linkedCameraIds],
@@ -9213,6 +9227,17 @@ var en_default = {
 	"alarm.combined.title": "Alarm: {{deviceName}}",
 	"alarm.intrusion.title": "Intrusion — {{locations}}",
 	"alarm.intrusion.body": "Intrusion: {{locations}}",
+	"alarm.intrusion.body.withChanges": "Intrusion: {{locations}} — {{changes}}",
+	"alarm.change.lock.unlocked": "{{device}} unlocked",
+	"alarm.change.lock.unlocking": "{{device}} unlocking",
+	"alarm.change.lock.jammed": "{{device}} jammed",
+	"alarm.change.lock.door-open": "{{device}} open",
+	"alarm.change.open": "{{device}} open",
+	"alarm.change.opening": "{{device}} opening",
+	"alarm.change.closed": "{{device}} closed",
+	"alarm.change.on": "{{device}} on",
+	"alarm.change.raised": "{{device}} triggered",
+	"alarm.change.cleared": "{{device}} cleared",
 	"system.alarm-arm-refused.title.home": "Arming home refused",
 	"system.alarm-arm-refused.title.away": "Arming away refused",
 	"system.alarm-arm-refused.title.night": "Arming night refused",
@@ -9630,6 +9655,17 @@ var it_default = {
 	"alarm.combined.title": "Allarme: {{deviceName}}",
 	"alarm.intrusion.title": "Intrusione — {{locations}}",
 	"alarm.intrusion.body": "Intrusione: {{locations}}",
+	"alarm.intrusion.body.withChanges": "Intrusione: {{locations}} — {{changes}}",
+	"alarm.change.lock.unlocked": "{{device}} aperta",
+	"alarm.change.lock.unlocking": "{{device}} in apertura",
+	"alarm.change.lock.jammed": "{{device}} bloccata",
+	"alarm.change.lock.door-open": "{{device}} aperta",
+	"alarm.change.open": "{{device}} aperto",
+	"alarm.change.opening": "{{device}} in apertura",
+	"alarm.change.closed": "{{device}} chiuso",
+	"alarm.change.on": "{{device}} acceso",
+	"alarm.change.raised": "{{device}} attivato",
+	"alarm.change.cleared": "{{device}} ripristinato",
 	"system.alarm-arm-refused.title.home": "Inserimento Casa rifiutato",
 	"system.alarm-arm-refused.title.away": "Inserimento Fuori rifiutato",
 	"system.alarm-arm-refused.title.night": "Inserimento Notte rifiutato",
@@ -59718,6 +59754,140 @@ async function promoteWithStill(input) {
 	});
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/key-frame-persist.ts
+/**
+* A box is written only when it can be USED — a degenerate rectangle, or one
+* measured on a degenerate frame, says nothing and would read back as a box at
+* the origin. Absent is the honest answer; the reader then pairs a snapshot,
+* exactly as it did before D510.
+*
+* Its result is spread into BOTH writes: the small companion is derived from
+* the very bytes of the native one, so it is the same scene at the same
+* instant and the box maps into it by ratio like any other scale of the frame.
+* A box on one row and not the other would make the summary's answer depend on
+* which row a reader happened to pick.
+*/
+function isStatableSubject(subject) {
+	if (subject === void 0) return false;
+	return subject.w > 0 && subject.h > 0 && subject.frameWidth > 0 && subject.frameHeight > 0;
+}
+/**
+* Read, derive and store one track's key frame + its web companion.
+*
+* PARCEL-OR-NOTHING: no parcel writes nothing and the caller's bounded retry
+* parks a later frame. The `keyFrame` write lands FIRST and its media id (D482)
+* is what the outcome carries — a `keyFrameSmall` failure afterwards must not
+* re-arm a retry that would re-shoot a key frame the rebuild can already read.
+*/
+async function persistTrackKeyFrame(deps, input) {
+	const { deviceId, trackId, retry } = input;
+	const drop = {
+		tags: { deviceId },
+		meta: {
+			trackId,
+			retry
+		}
+	};
+	try {
+		const parcel = await deps.fetchParkedKeyFrame(deviceId, trackId);
+		if (parcel === null || parcel.jpeg.byteLength === 0) {
+			deps.logger.error("key-frame parcel missing — nothing to write, retry parks a later frame", { ...drop });
+			return { kind: "parcel-missing" };
+		}
+		const subjectBox = isStatableSubject(parcel.subject) ? { subjectBox: parcel.subject } : {};
+		const keyFrameMediaId = await deps.media.putReplacing({
+			deviceId,
+			ownerKind: "track",
+			ownerId: trackId,
+			kind: "keyFrame",
+			timestamp: parcel.timestamp,
+			data: parcel.jpeg,
+			...subjectBox
+		});
+		try {
+			const keyFrameSmall = await deps.deriveSmall(parcel.jpeg);
+			await deps.media.putReplacing({
+				deviceId,
+				ownerKind: "track",
+				ownerId: trackId,
+				kind: "keyFrameSmall",
+				timestamp: parcel.timestamp,
+				data: keyFrameSmall,
+				...subjectBox
+			});
+		} catch (err) {
+			deps.logger.warn("keyFrameSmall write failed — the native keyFrame is stored", {
+				...drop,
+				meta: {
+					...drop.meta,
+					nodeId: parcel.nodeId,
+					error: require_clip_model_registry.errMsg(err)
+				}
+			});
+		}
+		deps.logger.debug("key frame written from the parked parcel", {
+			...drop,
+			meta: {
+				...drop.meta,
+				nodeId: parcel.nodeId,
+				width: parcel.width,
+				height: parcel.height,
+				bytes: parcel.jpeg.byteLength,
+				parkedTimestamp: parcel.timestamp
+			}
+		});
+		return {
+			kind: "landed",
+			keyFrameMediaId
+		};
+	} catch (err) {
+		const error = require_clip_model_registry.errMsg(err);
+		deps.logger.warn("key-frame write failed", {
+			...drop,
+			meta: {
+				...drop.meta,
+				error
+			}
+		});
+		return {
+			kind: "error",
+			error
+		};
+	}
+}
+/**
+* Write one parked frame under an OBJECT event (`object:<id>`), once.
+*
+* A package delivery has no track row owning a key frame, and the notification
+* ladder reads only `track:` and `object:` owners — so without this the
+* delivery ships text-only. `null` = no parcel to write (said at the caller).
+* `putReplacing` makes a repeat the same row, never a second one.
+*/
+async function persistObjectFrame(deps, input) {
+	const { deviceId, trackId, objectId, timestamp } = input;
+	const parcel = await deps.fetchParkedKeyFrame(deviceId, trackId);
+	if (parcel === null || parcel.jpeg.byteLength === 0) {
+		deps.logger.warn("object frame parcel missing — nothing to write", {
+			tags: { deviceId },
+			meta: {
+				trackId,
+				objectId
+			}
+		});
+		return null;
+	}
+	const subjectBox = isStatableSubject(parcel.subject) ? { subjectBox: parcel.subject } : {};
+	return deps.media.putReplacing({
+		deviceId,
+		ownerKind: "object",
+		ownerId: objectId,
+		kind: "keyFrame",
+		timestamp,
+		data: parcel.jpeg,
+		...subjectBox
+	});
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/person-over-vehicle.ts
 /**
 * How much of the PERSON box must sit inside a vehicle box to be counted.
@@ -71125,6 +71295,12 @@ Object.freeze({
 			"idleStopMinutes": 30
 		} } }
 	},
+	"media-player": {
+		"channelDown": { "steps": 1 },
+		"channelUp": { "steps": 1 },
+		"volumeDown": { "steps": 1 },
+		"volumeUp": { "steps": 1 }
+	},
 	"mqtt-broker": { "startEmbeddedBroker": {
 		"port": 1883,
 		"allowAnonymous": false
@@ -71491,8 +71667,8 @@ Object.freeze({
 * ## Caps with no boolean level pass through untouched
 *
 * `EVENT_KIND_BY_CAP` covers sixteen caps; `SOURCE_CAP_ACTIVE_FIELD` covers the
-* ten that have a boolean whose edge means something. `button`, `presence`,
-* `enum-sensor` and `event-emitter` are NOT levels — their ARRIVAL is the
+* ten that have a boolean whose edge means something. `button`, `presence`
+* and `event-emitter` are NOT levels (`enum-sensor` is a stampless word level, see `UNSTAMPED_WORD_FIELD`) — their ARRIVAL is the
 * event, and three presses in a row are three markers. Gating them would
 * re-ship the failure of 2026-08-08, when camera 101's press produced a row, a
 * ring, a matched rule and no marker. (`doorbell` is not a level either, but
@@ -71618,6 +71794,24 @@ var WORD_LEVEL_FIELD = {
 * running for an hour at boot did not just start).
 */
 var BOOLEAN_LEVEL_FIELD = { "running-state": "running" };
+/**
+* The device-history series key of a level cap's boolean — `cap:<cap>.<field>`,
+* the shape of `capSeriesKey` (system builtin, not importable from an addon;
+* the wiring spec pins the literal). `null` for a cap with no boolean level.
+*/
+function levelSeriesKey(capName) {
+	const field = BOOLEAN_LEVEL_FIELD[capName];
+	return field === void 0 ? null : `cap:${capName}.${field}`;
+}
+/**
+* Caps whose level is a WORD with NO change stamp: cap → field. `enum-sensor`
+* carries `{ value, lastFetchedAt }`, and `lastFetchedAt` moves on every
+* provider refresh, so it says nothing about when the word changed. Gated by
+* the word alone: the first sighting seeds, only a different word passes, and
+* a null / missing value is dropped and never remembered (planning#396: such
+* slices passed as `changed` many times a minute and could match an NC rule).
+*/
+var UNSTAMPED_WORD_FIELD = { "enum-sensor": "value" };
 /** The word a word-level cap rests in — its `false`, for the first-sighting rule. */
 var WORD_LEVEL_INACTIVE = {
 	cover: "closed",
@@ -71636,6 +71830,7 @@ var WORD_LEVEL_INACTIVE = {
 * post-analysis runner, D28).
 */
 var ADVANCE_FIELD = require_clip_model_registry.CAP_ADVANCE_FIELDS;
+var DEFAULT_SEED_WAIT_MS = 2e3;
 /** Default drop-summary window: one line per device per ten minutes, at most. */
 var DEFAULT_DROP_SUMMARY_WINDOW_MS = 6e5;
 var SensorTransitionGate = class {
@@ -71647,6 +71842,14 @@ var SensorTransitionGate = class {
 	lastStamps = /* @__PURE__ */ new Map();
 	/** Drops since the window opened, keyed by `${deviceId}:${capName}:${reason}`. */
 	drops = /* @__PURE__ */ new Map();
+	/** Seed reads started, by key; a settled one stays so a seed is read once. */
+	seeds = /* @__PURE__ */ new Map();
+	seedsSettled = /* @__PURE__ */ new Set();
+	/** Seeds whose wait ran out: decided as unseeded from then on. */
+	seedsAbandoned = /* @__PURE__ */ new Set();
+	readSeed;
+	onSeedFailed;
+	seedWaitMs;
 	windowStartedAt;
 	startedAtMs;
 	now;
@@ -71658,6 +71861,55 @@ var SensorTransitionGate = class {
 		this.freshnessMs = options.firstSightingFreshnessMs ?? require_clip_model_registry.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS;
 		this.summaryWindowMs = options.summaryWindowMs ?? DEFAULT_DROP_SUMMARY_WINDOW_MS;
 		this.windowStartedAt = options.now();
+		this.readSeed = options.readSeed;
+		this.onSeedFailed = options.onSeedFailed;
+		this.seedWaitMs = options.seedWaitMs ?? DEFAULT_SEED_WAIT_MS;
+	}
+	/**
+	* {@link observe}, plus: a level cap's first boolean `false` whose persisted
+	* prior is still being read waits for that read, bounded by `seedWaitMs`, and
+	* is decided again. This is the only wait on the path, and it is on a read
+	* that was started at the FIRST sighting of the device (a null at boot, long
+	* before the boolean) — never one begun by the event itself unless the
+	* boolean really is the first thing seen. A read that fails or times out
+	* decides as unseeded, i.e. exactly as before the seed existed (D49).
+	*/
+	async observeSettled(deviceId, capName, slice) {
+		const first = this.observe(deviceId, capName, slice);
+		if (first.changed || first.reason !== "seed-pending") return first;
+		const key = `${deviceId}:${capName}`;
+		const pending = this.seeds.get(key);
+		if (pending !== void 0) {
+			let timer;
+			const timeout = new Promise((resolve) => {
+				timer = setTimeout(resolve, this.seedWaitMs);
+			});
+			await Promise.race([pending, timeout]);
+			if (timer !== void 0) clearTimeout(timer);
+			if (!this.seedsSettled.has(key)) this.seedsAbandoned.add(key);
+		}
+		return this.observe(deviceId, capName, slice);
+	}
+	/** Start the one seed read of a level cap's key; never awaited here. */
+	ensureSeed(deviceId, capName) {
+		const read = this.readSeed;
+		if (read === void 0) return;
+		const key = `${deviceId}:${capName}`;
+		if (this.seeds.has(key)) return;
+		const settle = () => {
+			this.seedsSettled.add(key);
+		};
+		const started = read(deviceId, capName).then((seed) => {
+			if (seed !== null && !this.lastValues.has(key)) this.lastValues.set(key, seed.value);
+			settle();
+		}, (error) => {
+			this.onSeedFailed?.(deviceId, capName, error);
+			settle();
+		});
+		this.seeds.set(key, started);
+	}
+	seedPending(key) {
+		return this.seeds.has(key) && !this.seedsSettled.has(key) && !this.seedsAbandoned.has(key);
 	}
 	/**
 	* Feed one `DeviceStateChanged` slice for a cap `EVENT_KIND_BY_CAP` maps.
@@ -71669,7 +71921,10 @@ var SensorTransitionGate = class {
 	* a boolean in either direction, or a word-level cap's word changing.
 	*/
 	observe(deviceId, capName, slice) {
+		if (BOOLEAN_LEVEL_FIELD[capName] !== void 0) this.ensureSeed(deviceId, capName);
 		if (slice["lastChangedAt"] === 0) return this.drop(deviceId, capName, "cold-slice");
+		const unstampedField = UNSTAMPED_WORD_FIELD[capName];
+		if (unstampedField !== void 0) return this.observeUnstampedWord(deviceId, capName, slice, unstampedField);
 		const wordField = WORD_LEVEL_FIELD[capName];
 		if (wordField !== void 0) return this.observeWord(deviceId, capName, slice, wordField);
 		const levelField = BOOLEAN_LEVEL_FIELD[capName];
@@ -71722,6 +71977,10 @@ var SensorTransitionGate = class {
 		if (typeof raw !== "boolean") return this.drop(deviceId, capName, "non-boolean-value");
 		const key = `${deviceId}:${capName}`;
 		const prior = this.lastValues.get(key);
+		if (prior === void 0 && !raw && this.seedPending(key)) return {
+			changed: false,
+			reason: "seed-pending"
+		};
 		this.lastValues.set(key, raw);
 		if (prior === void 0) {
 			if (!raw) return this.drop(deviceId, capName, "baseline-seeded-inactive");
@@ -71740,11 +71999,25 @@ var SensorTransitionGate = class {
 	observeWord(deviceId, capName, slice, wordField) {
 		const raw = slice[wordField];
 		if (typeof raw !== "string" || raw.length === 0) return this.drop(deviceId, capName, "non-word-value");
+		const stamp = slice["lastChangedAt"];
+		if (typeof stamp !== "number" || !Number.isFinite(stamp) || stamp <= 0) return this.drop(deviceId, capName, "cold-slice");
 		const key = `${deviceId}:${capName}`;
 		const prior = this.lastWords.get(key);
 		this.lastWords.set(key, raw);
 		if (prior === void 0) return this.firstWordSighting(deviceId, capName, slice, raw);
 		if (prior === raw) return this.drop(deviceId, capName, "no-change");
+		if (stamp < this.startedAtMs) return this.drop(deviceId, capName, "baseline-seeded-stale-active");
+		return { changed: true };
+	}
+	/** A word-level cap with no change stamp: only a DIFFERENT word is a transition. */
+	observeUnstampedWord(deviceId, capName, slice, field) {
+		const raw = slice[field];
+		if (typeof raw !== "string" || raw.length === 0) return this.drop(deviceId, capName, "non-word-value");
+		const key = `${deviceId}:${capName}`;
+		const prior = this.lastWords.get(key);
+		this.lastWords.set(key, raw);
+		if (prior === void 0) return this.drop(deviceId, capName, "baseline-seeded-inactive");
+		if (prior === raw) return this.drop(deviceId, capName, "no-change");
 		return { changed: true };
 	}
 	/**
@@ -81820,11 +82093,11 @@ function unique(values) {
 * therefore keeps the alarm's own sentence, which is also what every row
 * enqueued before this deploy carries.
 */
-function combinedAlarmText(kind, source) {
+function combinedAlarmText(kind, source, followers = []) {
 	if (kind !== "alarm-triggered" || source === void 0) return null;
 	return {
 		titleKey: source.className !== void 0 ? "alarm.combined.title" : "system.alarm-triggered.title",
-		bodyKey: "alarm.intrusion.body"
+		bodyKey: [source, ...followers].some((ref) => ref.sensorChange !== void 0) ? "alarm.intrusion.body.withChanges" : "alarm.intrusion.body"
 	};
 }
 /**
@@ -81839,7 +82112,7 @@ function combinedAlarmText(kind, source) {
 */
 function alarmTextKeys(transition, body) {
 	const { kind, source } = transition;
-	const combined = combinedAlarmText(kind, source);
+	const combined = combinedAlarmText(kind, source, transition.followers);
 	if (combined !== null) return combined;
 	const baseTitle = transition.mode !== void 0 ? `system.${kind}.title.${transition.mode}` : `system.${kind}.title`;
 	const titleKey = body?.titleKeySuffix !== void 0 ? `${baseTitle}.${body.titleKeySuffix}` : baseTitle;
@@ -85546,6 +85819,15 @@ function isLinkedStillId(id) {
 var NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS = 15e3;
 var NC_LINKED_WAKE_POLL_MS = 1e3;
 var NC_LINKED_WAKE_MIN_GAP_MS = 6e4;
+/**
+* D60 — a tile the freshness read calls stale is RE-POLLED, unforced, until the
+* wrapper hands back a frame from the event or this bound is spent. The wrapper
+* settles a soft miss with its old cached hit; one more ask, a moment later,
+* usually finds the refreshed one. The bound sits inside the dispatcher's still
+* deadline (`NC_STILL_WAIT_MS`, 3 s): the row waits for it through `pendingUntil`.
+*/
+var NC_LINKED_STALE_POLL_MS = 500;
+var NC_LINKED_STALE_MAX_POLLS = 5;
 /** Per camera — the marker's own bound (`SENSOR_MARKER_SNAPSHOT_TIMEOUT_MS`). */
 var SENSOR_LINKED_CAPTURE_TIMEOUT_MS = 2500;
 /** The capture-free wrapper-state read, per camera. It runs IN PARALLEL with
@@ -85555,6 +85837,8 @@ var SENSOR_LINKED_CAPTURE_TIMEOUT_MS = 2500;
 *  photograph). A read that misses the bound or fails is UNKNOWN and keeps the
 *  tile (D49). */
 var SENSOR_LINKED_STATE_READ_TIMEOUT_MS = SENSOR_LINKED_CAPTURE_TIMEOUT_MS;
+/** The battery-slice read behind the unknown-state wake: cheap, and bounded. */
+var SENSOR_LINKED_BATTERY_READ_TIMEOUT_MS = 1e3;
 /** The one cache-only freshness read for the set — one hop, after the
 *  captures. A read that misses it keeps every tile and says `freshness
 *  unverified` (D49). */
@@ -85660,13 +85944,13 @@ var NcLinkedStillShelf = class {
 			startedAt,
 			options
 		};
-		let results;
+		let judged;
 		try {
-			results = await Promise.all(stills.cameraIds.map((id) => this.captureOne(id, ctx)));
+			const results = await Promise.all(stills.cameraIds.map((id) => this.captureOne(id, ctx)));
+			judged = await this.repollStale(ctx, atMs, await this.judgeFreshness(stills.sensorId, results, atMs));
 		} finally {
 			this.pendingWakes.delete(setId);
 		}
-		const judged = await this.judgeFreshness(stills.sensorId, results, atMs);
 		for (const r of judged) this.logTile(stills.sensorId, r);
 		const landed = judged.filter(isLandedTile);
 		const composed = await this.compose(stills.sensorId, landed, atMs);
@@ -85713,6 +85997,16 @@ var NcLinkedStillShelf = class {
 		if (verdict.reason === "waking" && ctx.options.wakeSleeping) return this.awaitWaking(cameraId, ctx);
 		if (verdict.reason === "unreachable" && ctx.options.wakeSleeping) return excluded("wake-skipped:unreachable");
 		if (verdict.reason !== null) return excluded(verdict.reason);
+		if (verdict.unknown !== null && capture.outcome === "empty" && ctx.options.wakeSleeping && await this.isBatteryCamera(cameraId)) {
+			this.deps.logger.info("linked camera state unknown and capture empty — waking as a battery camera", {
+				tags: { deviceId: cameraId },
+				meta: {
+					sensorId: ctx.sensorId,
+					stateUnknown: verdict.unknown
+				}
+			});
+			return this.wakeOne(cameraId, ctx);
+		}
 		return {
 			cameraId,
 			...capture,
@@ -85720,6 +86014,20 @@ var NcLinkedStillShelf = class {
 			tookMs: took()
 		};
 	}
+	/** Only a camera KNOWN to be a battery camera is woken on an unknown state. */
+	async isBatteryCamera(cameraId) {
+		const read = this.deps.isBatteryCamera;
+		if (read === void 0) return false;
+		try {
+			return await withTimeout$2(read(cameraId), SENSOR_LINKED_BATTERY_READ_TIMEOUT_MS, "battery read") === true;
+		} catch (err) {
+			this.deps.logger.warn("linked camera battery read failed — not woken on an unknown state", {
+				tags: { deviceId: cameraId },
+				meta: { error: String(err) }
+			});
+			return false;
+		}
+	}
 	/** D998: one forced capture, by the rule's leave, at most once per gap per camera. */
 	async wakeOne(cameraId, ctx) {
 		const took = () => this.deps.now() - ctx.startedAt;
@@ -85781,8 +86089,46 @@ var NcLinkedStillShelf = class {
 		};
 	}
 	markPending(ctx) {
-		const until = ctx.startedAt + NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS + NC_LINKED_WAKE_POLL_MS;
-		this.pendingWakes.set(ctx.setId, Math.max(this.pendingWakes.get(ctx.setId) ?? 0, until));
+		this.markPendingUntil(ctx.setId, ctx.startedAt + NC_LINKED_WAKE_CAPTURE_TIMEOUT_MS + NC_LINKED_WAKE_POLL_MS);
+	}
+	markPendingUntil(setId, until) {
+		this.pendingWakes.set(setId, Math.max(this.pendingWakes.get(setId) ?? 0, until));
+	}
+	/**
+	* D60: a `stale` tile asks again (unforced — a poll never wakes) until its
+	* frame is from the event or the bound is spent; the row's still-wait is held
+	* open meanwhile. A camera that never freshens stays `stale`, said on its line.
+	*/
+	async repollStale(ctx, atMs, judged) {
+		let current = judged;
+		if (!current.some((r) => r.outcome === "stale")) return current;
+		this.markPendingUntil(ctx.setId, this.deps.now() + NC_LINKED_STALE_POLL_MS * 6);
+		for (let i = 0; i < NC_LINKED_STALE_MAX_POLLS; i++) {
+			const waiting = current.filter((r) => r.outcome === "stale").map((r) => r.cameraId);
+			if (waiting.length === 0) break;
+			await new Promise((resolve) => setTimeout(resolve, NC_LINKED_STALE_POLL_MS));
+			const landedAgain = (await Promise.all(waiting.map(async (cameraId) => {
+				const capture = await this.captureStill(cameraId, false, SENSOR_LINKED_CAPTURE_TIMEOUT_MS);
+				return capture.outcome === "landed" && capture.jpeg !== void 0 ? {
+					cameraId,
+					outcome: "landed",
+					jpeg: capture.jpeg,
+					tookMs: this.deps.now() - ctx.startedAt
+				} : null;
+			}))).filter((r) => r !== null);
+			if (landedAgain.length === 0) continue;
+			const rejudged = await this.judgeFreshness(ctx.sensorId, landedAgain, atMs);
+			const fresh = new Map(rejudged.filter((r) => r.outcome === "landed").map((r) => [r.cameraId, r]));
+			current = current.map((r) => fresh.get(r.cameraId) ?? r);
+			for (const cameraId of fresh.keys()) this.deps.logger.info("linked camera frame was stale — a re-poll brought one from the event", {
+				tags: { deviceId: cameraId },
+				meta: {
+					sensorId: ctx.sensorId,
+					polls: i + 1
+				}
+			});
+		}
+		return current;
 	}
 	/** A wake that brought nothing back names itself, not the generic `empty`. */
 	asWakeResult(capture) {
@@ -85851,9 +86197,17 @@ var NcLinkedStillShelf = class {
 				unknown: null
 			};
 		} catch (err) {
+			const timedOut = err instanceof LinkedReadTimeout;
+			this.deps.logger.warn("linked camera snapshot state read failed — state unknown", {
+				tags: { deviceId: cameraId },
+				meta: {
+					error: String(err),
+					timedOut
+				}
+			});
 			return {
 				reason: null,
-				unknown: err instanceof LinkedReadTimeout ? "timeout" : "error"
+				unknown: timedOut ? "timeout" : "error"
 			};
 		}
 	}
@@ -89663,10 +90017,31 @@ function buildTemplateVars(texts, entry, deviceName, zoneLabels, timeZone, cycle
 		latestVersion: typeof systemEvent?.data["latestVersion"] === "string" ? systemEvent.data["latestVersion"] : "",
 		...systemEvent?.deviceId !== void 0 ? { deviceName: String(systemEvent.deviceId) } : {},
 		...systemEvent?.nodeId !== void 0 && (systemEvent.kind === "node-online" || systemEvent.kind === "node-offline") ? { nodeName: systemEvent.nodeId } : {},
+		...systemEvent?.alarmSource !== void 0 ? { changes: alarmChangesText(texts, systemEvent.alarmSource, systemEvent.alarmFollowers) } : {},
 		...systemEventParamsForTemplate(systemEvent?.textParams)
 	};
 }
 /**
+* `{{changes}}` of the combined alarm body: what each sensor of the incident did, in
+* arrival order and one phrase per device — "Laundry lock unlocked". The phrase is a
+* catalog key per kind and state (`alarm.change.<kind>.<state>`), then per state
+* (`alarm.change.<state>`), then the bare name: a state nobody worded never drops the device.
+*/
+function alarmChangesText(texts, source, followers) {
+	const phrases = [];
+	for (const ref of [source, ...followers ?? []]) {
+		const change = ref.sensorChange;
+		if (change === void 0) continue;
+		const key = [`alarm.change.${change.kind}.${change.state}`, `alarm.change.${change.state}`].find((candidate) => texts.has(candidate));
+		const phrase = key === void 0 ? change.name : texts.text({
+			key,
+			vars: { device: change.name }
+		});
+		if (!phrases.includes(phrase)) phrases.push(phrase);
+	}
+	return phrases.join(", ");
+}
+/**
 * Which catalog key supplies the DEFAULT body for a row.
 *
 * A system event names its own at intake (the variant selection — profiled or
@@ -105952,7 +106327,7 @@ function groupedAlarmPhaseKey(ruleId, trackId) {
 * combined alarm notification would then arrive with no picture, which is the
 * one thing it exists to fix.
 */
-function fireRefFor(rule, subject, kind) {
+function fireRefFor(rule, subject, kind, sensorName) {
 	const hasEventMedia = kind === "object-event" || kind === "package-event";
 	const className = subject.classNames[0];
 	const linkedOwners = subject.trackId === void 0 && subject.linkedStills !== void 0 ? linkedMediaOwners(subject.linkedStills, linkedCameraMode(rule.media)) : void 0;
@@ -105962,6 +106337,11 @@ function fireRefFor(rule, subject, kind) {
 		ruleName: rule.name,
 		deviceId: subject.deviceId,
 		...subject.sourceDeviceId !== void 0 ? { sourceDeviceId: subject.sourceDeviceId } : {},
+		...subject.sensorKind !== void 0 && subject.sensorState !== void 0 && sensorName !== void 0 ? { sensorChange: {
+			name: sensorName,
+			kind: subject.sensorKind,
+			state: subject.sensorState
+		} } : {},
 		recordId: subject.recordId,
 		...trackId !== void 0 ? { trackId } : {},
 		...linkedOwners !== void 0 && linkedOwners.extraStills.length > 0 ? { extraStills: linkedOwners.extraStills.map((x) => ({ ...x })) } : {},
@@ -105973,6 +106353,12 @@ function fireRefFor(rule, subject, kind) {
 		...subject.confidence !== void 0 ? { confidence: subject.confidence } : {}
 	};
 }
+/** The directory name of the sensor a match was about; absent for a camera subject. */
+function sensorNameOf(host, subject) {
+	if (subject.source !== "sensor") return void 0;
+	const name = host.deviceDirectory.get(subject.sourceDeviceId ?? subject.deviceId)?.name.trim();
+	return name !== void 0 && name.length > 0 ? name : void 0;
+}
 /**
 * Run this rule's onTrigger / onTriggerOff bindings for this match, and —
 * when the rule is gated on `armed_*` — auto-trigger the CamStack
@@ -105994,7 +106380,7 @@ function runRuleActions(host, rule, subject, kind, controls) {
 		deviceId: subject.deviceId,
 		bindings,
 		lookup: (id) => host.sequences.get(id),
-		origin: fireRefFor(rule, subject, kind)
+		origin: fireRefFor(rule, subject, kind, sensorNameOf(host, subject))
 	});
 	return phase;
 }
@@ -106018,7 +106404,7 @@ function autoTriggerAlarmPanel(host, rule, subject, kind) {
 		});
 		return NO_ALARM_PHASE;
 	}
-	const origin = fireRefFor(rule, subject, kind);
+	const origin = fireRefFor(rule, subject, kind, sensorNameOf(host, subject));
 	const phase = panel.classifyRuleMatch(origin);
 	try {
 		panel.triggerFromRule(origin);
@@ -107463,6 +107849,7 @@ var NotificationCenter = class {
 		this.linkedStills = getSnapshot !== void 0 ? new NcLinkedStillShelf({
 			getSnapshot,
 			...deps.getSnapshotState !== void 0 ? { getSnapshotState: deps.getSnapshotState } : {},
+			...deps.isBatteryCamera !== void 0 ? { isBatteryCamera: deps.isBatteryCamera } : {},
 			...deps.getFrameCapturedAt !== void 0 ? { getFrameCapturedAt: deps.getFrameCapturedAt } : {},
 			isOnline: (id) => this.deviceDirectory.get(id)?.online,
 			logger: this.logger.child("linked-stills"),
@@ -110234,6 +110621,7 @@ var BuildNotificationCenter = class extends BuildNotificationCenterBase {
 				now: () => Date.now()
 			}),
 			...buildLinkedSnapshotReads(api.snapshot),
+			isBatteryCamera: async (deviceId) => await api.battery.getStatus.query({ deviceId }) !== null,
 			identityIdsByName: async () => {
 				const byName = /* @__PURE__ */ new Map();
 				const identities = await stores.identityStore.listIdentities();
@@ -114431,6 +114819,12 @@ function deliveredIdempotencyKey(entryId) {
 function pickedUpIdempotencyKey(entryId) {
 	return `pa-pkg-${entryId}-pickedup`;
 }
+/**
+* How long a delivery waits for its still to be written before it ships
+* without one. Under the notification still poll (`NC_STILL_WAIT_MS`, 3 s) so
+* a slow store never holds the alert longer than the dispatcher would.
+*/
+var PACKAGE_FRAME_PERSIST_BOUND_MS = 2e3;
 var PackageDropDetector = class {
 	deps;
 	/** Per-device mirror of the last LOGGED value of the `packageDropEnabled`
@@ -114444,6 +114838,62 @@ var PackageDropDetector = class {
 	* LLM gate (D931). `null` means the delivery is dropped (no, or no yes).
 	* An empty object means the rule did not ask. A verdict is spread onto the row.
 	*/
+	/**
+	* The delivery's still, written once under `object:<rowId>` when the entry
+	* had no key frame. Never throws and never waits past
+	* {@link PACKAGE_FRAME_PERSIST_BOUND_MS}: a delivery without a picture still
+	* ships, and says why (D391).
+	*/
+	async persistDeliveryStill(entry, rowId, timestamp) {
+		const persist = this.deps.persistDeliveryFrame;
+		if (persist === void 0) return void 0;
+		const tags = { deviceId: entry.deviceId };
+		const meta = {
+			entryId: entry.id,
+			rowId
+		};
+		let timer;
+		try {
+			const bound = new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timeout"), PACKAGE_FRAME_PERSIST_BOUND_MS);
+			});
+			const written = await Promise.race([persist({
+				deviceId: entry.deviceId,
+				trackId: entry.sourceTrackId ?? entry.id,
+				rowId,
+				timestamp
+			}), bound]);
+			if (written === "timeout") {
+				this.deps.logger.warn("package delivery still not written in time — shipping without it", {
+					tags,
+					meta: {
+						...meta,
+						boundMs: PACKAGE_FRAME_PERSIST_BOUND_MS
+					}
+				});
+				return;
+			}
+			if (written === null) {
+				this.deps.logger.warn("package delivery has no frame to write — shipping without a still", {
+					tags,
+					meta
+				});
+				return;
+			}
+			return written;
+		} catch (err) {
+			this.deps.logger.warn("package delivery still write failed — shipping without it", {
+				tags,
+				meta: {
+					...meta,
+					error: require_clip_model_registry.errMsg(err)
+				}
+			});
+			return;
+		} finally {
+			if (timer !== void 0) clearTimeout(timer);
+		}
+	}
 	async llmFields(entry, rules, hitZones, tags) {
 		if (!rules.some((rule) => rule.confirmWithLlm === true && rule.zoneIds.some((id) => hitZones.includes(id)))) return {};
 		const confirm = this.deps.confirmPackage;
@@ -114705,6 +115155,7 @@ var PackageDropDetector = class {
 			});
 			return;
 		}
+		const keyFrameMediaId = entry.keyFrameMediaId ?? await this.persistDeliveryStill(entry, rowId, rowTimestamp);
 		const ev = {
 			...draft,
 			id: rowId
@@ -114716,7 +115167,7 @@ var PackageDropDetector = class {
 			eventId: String(rowId),
 			className: entry.className,
 			zoneIds: hitZones,
-			...entry.keyFrameMediaId !== void 0 ? { keyFrameMediaId: entry.keyFrameMediaId } : {},
+			...keyFrameMediaId !== void 0 ? { keyFrameMediaId } : {},
 			bbox: {
 				x: entry.bbox.x,
 				y: entry.bbox.y,
@@ -118279,6 +118730,7 @@ var BuildStores = class extends BuildStoresBase {
 			resolveSettings: (deviceId) => this.resolveDevicePackageDropSettings(deviceId),
 			resolveZoneMembershipMinOverlap: async (deviceId) => (await this.resolveDeviceTrackingSettings(deviceId)).zoneMembershipMinOverlap,
 			confirmPackage: (input) => this.deps.confirmPackage(input),
+			persistDeliveryFrame: (request) => this.deps.persistPackageDeliveryFrame(request),
 			onLlmSilence: (edge) => {
 				const deviceId = edge.phase === "silent" ? edge.note.deviceId : edge.deviceId;
 				this.ctx.eventBus.emit({
@@ -120400,108 +120852,6 @@ async function ensureTrackHierarchyMedia(deps, input) {
 	await Promise.all(tasks);
 }
 //#endregion
-//#region src/pipeline-analytics/pipeline/key-frame-persist.ts
-/**
-* A box is written only when it can be USED — a degenerate rectangle, or one
-* measured on a degenerate frame, says nothing and would read back as a box at
-* the origin. Absent is the honest answer; the reader then pairs a snapshot,
-* exactly as it did before D510.
-*
-* Its result is spread into BOTH writes: the small companion is derived from
-* the very bytes of the native one, so it is the same scene at the same
-* instant and the box maps into it by ratio like any other scale of the frame.
-* A box on one row and not the other would make the summary's answer depend on
-* which row a reader happened to pick.
-*/
-function isStatableSubject(subject) {
-	if (subject === void 0) return false;
-	return subject.w > 0 && subject.h > 0 && subject.frameWidth > 0 && subject.frameHeight > 0;
-}
-/**
-* Read, derive and store one track's key frame + its web companion.
-*
-* PARCEL-OR-NOTHING: no parcel writes nothing and the caller's bounded retry
-* parks a later frame. The `keyFrame` write lands FIRST and its media id (D482)
-* is what the outcome carries — a `keyFrameSmall` failure afterwards must not
-* re-arm a retry that would re-shoot a key frame the rebuild can already read.
-*/
-async function persistTrackKeyFrame(deps, input) {
-	const { deviceId, trackId, retry } = input;
-	const drop = {
-		tags: { deviceId },
-		meta: {
-			trackId,
-			retry
-		}
-	};
-	try {
-		const parcel = await deps.fetchParkedKeyFrame(deviceId, trackId);
-		if (parcel === null || parcel.jpeg.byteLength === 0) {
-			deps.logger.error("key-frame parcel missing — nothing to write, retry parks a later frame", { ...drop });
-			return { kind: "parcel-missing" };
-		}
-		const subjectBox = isStatableSubject(parcel.subject) ? { subjectBox: parcel.subject } : {};
-		const keyFrameMediaId = await deps.media.putReplacing({
-			deviceId,
-			ownerKind: "track",
-			ownerId: trackId,
-			kind: "keyFrame",
-			timestamp: parcel.timestamp,
-			data: parcel.jpeg,
-			...subjectBox
-		});
-		try {
-			const keyFrameSmall = await deps.deriveSmall(parcel.jpeg);
-			await deps.media.putReplacing({
-				deviceId,
-				ownerKind: "track",
-				ownerId: trackId,
-				kind: "keyFrameSmall",
-				timestamp: parcel.timestamp,
-				data: keyFrameSmall,
-				...subjectBox
-			});
-		} catch (err) {
-			deps.logger.warn("keyFrameSmall write failed — the native keyFrame is stored", {
-				...drop,
-				meta: {
-					...drop.meta,
-					nodeId: parcel.nodeId,
-					error: require_clip_model_registry.errMsg(err)
-				}
-			});
-		}
-		deps.logger.debug("key frame written from the parked parcel", {
-			...drop,
-			meta: {
-				...drop.meta,
-				nodeId: parcel.nodeId,
-				width: parcel.width,
-				height: parcel.height,
-				bytes: parcel.jpeg.byteLength,
-				parkedTimestamp: parcel.timestamp
-			}
-		});
-		return {
-			kind: "landed",
-			keyFrameMediaId
-		};
-	} catch (err) {
-		const error = require_clip_model_registry.errMsg(err);
-		deps.logger.warn("key-frame write failed", {
-			...drop,
-			meta: {
-				...drop.meta,
-				error
-			}
-		});
-		return {
-			kind: "error",
-			error
-		};
-	}
-}
-//#endregion
 //#region src/pipeline-analytics/pipeline/key-frame-retry.ts
 /** Retry-path attempts allowed per track. The operator's number. */
 var KEY_FRAME_MAX_RETRIES = 3;
@@ -122085,6 +122435,8 @@ var DEFAULT_ASSIST_MIN_SCORE = .3;
 * cannot page the whole table into memory to build a manifest.
 */
 var RETRAIN_EXPORT_MAX = 2e4;
+/** How far back a restart looks for a level cap's last persisted boolean. */
+var LEVEL_SEED_WINDOW_MS = 48 * 36e5;
 /**
 * Pipeline Analytics addon — subscribes to `PipelineInferenceResult` +
 * `PipelineAudioInferenceResult` on the bus, refines raw detections
@@ -122360,7 +122712,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	*/
 	sensorTransitions = new SensorTransitionGate({
 		startedAtMs: Date.now(),
-		now: () => Date.now()
+		now: () => Date.now(),
+		readSeed: (deviceId, capName) => this.readPersistedLevel(deviceId, capName),
+		onSeedFailed: (deviceId, capName, error) => this.ctx.logger.warn("level seed read failed — gate starts unseeded", {
+			tags: { deviceId },
+			meta: {
+				capName,
+				error: require_clip_model_registry.errMsg(error)
+			}
+		})
 	});
 	/** `camera-index-unknown` drops, summarised per window — see the file. */
 	cameraIndexUnknownDrops = new CameraIndexUnknownDrops({ nowMs: Date.now() });
@@ -124172,6 +124532,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				this.packageDropDetector = value;
 			},
 			confirmPackage: (input) => this.confirmPackageDelivery(input),
+			persistPackageDeliveryFrame: (request) => this.persistPackageDeliveryFrame(request),
 			stationaryEvidence: () => this.stationaryEvidence,
 			setStationaryEvidence: (value) => {
 				this.stationaryEvidence = value;
@@ -128327,6 +128688,44 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			via: "frame"
 		});
 	}
+	/**
+	* #383: a delivery whose entry had no key frame writes the source track's
+	* parked frame under the object row it just created — the one owner the
+	* notification ladder reads for a package event.
+	*/
+	async persistPackageDeliveryFrame(request) {
+		const mediaStore = this.mediaStore;
+		if (mediaStore === null) return null;
+		return persistObjectFrame({
+			fetchParkedKeyFrame: async (deviceId, trackId) => {
+				const parcel = await this.mediaCapture.fetchParkedParcel(trackId, "keyFrame");
+				if (parcel === null || parcel.info.deviceId !== deviceId) return null;
+				const subject = parcel.info.subject;
+				return {
+					jpeg: parcel.jpeg,
+					width: parcel.width,
+					height: parcel.height,
+					timestamp: parcel.timestamp,
+					nodeId: parcel.info.nodeId,
+					subject: {
+						x: subject.bbox.x,
+						y: subject.bbox.y,
+						w: subject.bbox.w,
+						h: subject.bbox.h,
+						frameWidth: subject.frameWidth,
+						frameHeight: subject.frameHeight
+					}
+				};
+			},
+			media: mediaStore,
+			logger: this.ctx.logger
+		}, {
+			deviceId: request.deviceId,
+			trackId: request.trackId,
+			objectId: String(request.rowId),
+			timestamp: request.timestamp
+		});
+	}
 	async confirmPackageDelivery(input) {
 		const crops = this.packageScene?.cropsFor(input.deviceId);
 		return confirmPackageWithLlm({
@@ -129328,7 +129727,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		const store = this.sensorEventStore;
 		const cache = this.linkedCamerasCache;
 		if (store === null || cache === null) return;
-		if (!this.sensorSliceCarriedATransition(data)) return;
+		if (!await this.sensorSliceCarriedATransition(data)) return;
 		const cameras = await resolveSensorNotificationCameras(cache, data).catch((err) => {
 			this.ctx.logger.debug("linked-camera resolution failed — evaluated per row", {
 				tags: { deviceId: data.deviceId },
@@ -129496,7 +129895,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	* The drops are SUMMARISED, never logged one by one: this path carries every
 	* camera's native `motion` slice at motion rate.
 	*/
-	sensorSliceCarriedATransition(data) {
+	async sensorSliceCarriedATransition(data) {
 		const slice = data.slice;
 		if (typeof slice !== "object" || slice === null || Array.isArray(slice)) {
 			this.ctx.logger.debug("sensor state change carried no slice — dropped", {
@@ -129505,11 +129904,53 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			});
 			return false;
 		}
-		const verdict = this.sensorTransitions.observe(data.deviceId, data.capName, { ...slice });
+		const verdict = await this.sensorTransitions.observeSettled(data.deviceId, data.capName, { ...slice });
 		this.flushSensorTransitionDrops();
+		if (verdict.changed) {
+			const entries = Object.entries(slice);
+			const field = (key) => entries.find(([k]) => k === key)?.[1];
+			this.ctx.logger.info("sensor slice passed the transition gate", {
+				tags: { deviceId: data.deviceId },
+				meta: {
+					capName: data.capName,
+					state: field("state") ?? field("value") ?? field("entryOpen") ?? field("active") ?? null,
+					lastChangedAt: field("lastChangedAt") ?? null,
+					verdict: "changed"
+				}
+			});
+		}
 		return verdict.changed;
 	}
 	/**
+	* The last persisted boolean of a level cap, from device-history — the
+	* gate's seed after a restart. Off the event path (the gate starts it at the
+	* first sighting). A cap that declares no history field, or a series with no
+	* point, answers `null`.
+	*/
+	async readPersistedLevel(deviceId, capName) {
+		const key = levelSeriesKey(capName);
+		if (key === null) return null;
+		const to = Date.now();
+		const result = await this.ctx.api.deviceHistory.query.query({
+			deviceId,
+			key,
+			from: to - LEVEL_SEED_WINDOW_MS,
+			to,
+			resolution: "raw",
+			maxPoints: 200
+		});
+		const latest = result.series.flatMap((s) => s.points).reduce((best, p) => best === null || p.t > best.t ? p : best, null);
+		if (latest !== null && latest.last !== null) return {
+			value: latest.last >= .5,
+			since: latest.t
+		};
+		const held = result.series.flatMap((s) => s.before === null ? [] : [s.before]).reduce((best, b) => best === null || b.t > best.t ? b : best, null);
+		return held !== null && held.value !== null ? {
+			value: held.value >= .5,
+			since: held.t
+		} : null;
+	}
+	/**
 	* One `info` line per (device, cap, reason) per window, or none.
 	*
 	* A branch that drops work says so — but this one drops ~0.6 events/s