@camstack/addon-post-analysis 1.2.666 → 1.2.668

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-BIhYJRFt.js");
+const require_clip_model_registry = require("../clip-model-registry-DTC5bkf8.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -59754,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.
@@ -69135,10 +69269,18 @@ function applianceCycleOf(subject) {
 //#region src/notification-center/appliance-cycle-runs.ts
 var CYCLE_FACTS_WAIT_MS = 3e3;
 var CYCLE_FACTS_POLL_MS = 250;
-/** A closed run belongs to this finish when it ended within this much of it. */
+/** A closed run belongs to this finish when it ended within this much AFTER it. */
 var CYCLE_RUN_MATCH_MS = 10 * 6e4;
+/**
+* ... or up to this long BEFORE it: a run ends at the last real active instant
+* (the start of the pending stop), and the finish is announced one stop dwell
+* later - the longest a stop dwell is proposed is 20 minutes.
+*/
+var CYCLE_RUN_END_LAG_MS = 30 * 6e4;
 function factsOfClosed(run, finishedAtMs) {
-	if (run.endedAt === null || Math.abs(run.endedAt - finishedAtMs) > CYCLE_RUN_MATCH_MS) return NC_UNKNOWN_CYCLE_FACTS;
+	if (run.endedAt === null) return NC_UNKNOWN_CYCLE_FACTS;
+	const lag = finishedAtMs - run.endedAt;
+	if (lag > CYCLE_RUN_END_LAG_MS || -lag > CYCLE_RUN_MATCH_MS) return NC_UNKNOWN_CYCLE_FACTS;
 	return {
 		durationMs: run.durationMs,
 		energyKwh: run.detail.energyKwh
@@ -71161,6 +71303,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
@@ -71404,6 +71552,7 @@ Object.freeze({
 	"device-export": [
 		"listExposedDevices",
 		"listExposedEntities",
+		"listInstances",
 		"listSupportedDeviceKinds",
 		"listSupportedEntityKinds"
 	],
@@ -71655,6 +71804,15 @@ var WORD_LEVEL_FIELD = {
 */
 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
@@ -71681,6 +71839,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 {
@@ -71692,6 +71851,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;
@@ -71703,6 +71870,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.
@@ -71714,6 +71930,7 @@ 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);
@@ -71769,6 +71986,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");
@@ -85607,6 +85828,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
@@ -85616,6 +85846,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). */
@@ -85721,13 +85953,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);
@@ -85774,6 +86006,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,
@@ -85781,6 +86023,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;
@@ -85842,8 +86098,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) {
@@ -85912,9 +86206,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"
 			};
 		}
 	}
@@ -107556,6 +107858,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"),
@@ -110327,6 +110630,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();
@@ -114524,6 +114828,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`
@@ -114537,6 +114847,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;
@@ -114798,6 +115164,7 @@ var PackageDropDetector = class {
 			});
 			return;
 		}
+		const keyFrameMediaId = entry.keyFrameMediaId ?? await this.persistDeliveryStill(entry, rowId, rowTimestamp);
 		const ev = {
 			...draft,
 			id: rowId
@@ -114809,7 +115176,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,
@@ -118372,6 +118739,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({
@@ -120493,108 +120861,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;
@@ -122178,6 +122444,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
@@ -122453,7 +122721,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() });
@@ -124265,6 +124541,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;
@@ -128420,6 +128697,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({
@@ -129421,7 +129736,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 },
@@ -129589,7 +129904,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", {
@@ -129598,7 +129913,7 @@ 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);
@@ -129616,6 +129931,35 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		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