@camstack/addon-post-analysis 1.1.26 → 1.1.28

package/dist/pipeline-analytics/index.js

@@ -2,12 +2,11 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BEx5ST1W.js");
-const require_resolve_frame = require("../resolve-frame-Cbm_NFuq.js");
-let _camstack_shm_ring = require("@camstack/shm-ring");
+const require_dist = require("../dist-Bnb58pyL.js");
+let node_crypto = require("node:crypto");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
-let node_crypto = require("node:crypto");
+let _camstack_shm_ring = require("@camstack/shm-ring");
 //#region src/pipeline-analytics/videoclips-provider.ts
 var SOURCE = "analytics";
 function clipIdFor(eventId, startMs, endMs) {
@@ -266,6 +265,7 @@ var FaceGalleryProvider = class {
 	trackStore;
 	eventStore;
 	refreshGallery;
+	emitFaceGalleryChanged;
 	constructor(deps) {
 		this.identityStore = deps.identityStore;
 		this.faceStore = deps.faceStore;
@@ -273,6 +273,13 @@ var FaceGalleryProvider = class {
 		this.trackStore = deps.trackStore;
 		this.eventStore = deps.eventStore;
 		this.refreshGallery = deps.refreshGallery;
+		this.emitFaceGalleryChanged = deps.emitFaceGalleryChanged;
+	}
+	/** Best-effort emit — never allowed to fail the mutation it follows. */
+	safeEmitFaceGalleryChanged(payload) {
+		try {
+			this.emitFaceGalleryChanged(payload);
+		} catch {}
 	}
 	async listIdentities() {
 		const rows = await this.identityStore.listIdentities();
@@ -491,6 +498,11 @@ var FaceGalleryProvider = class {
 			}, currentFace.trackId);
 		}
 		this.refreshGallery();
+		this.safeEmitFaceGalleryChanged({
+			deviceId: currentFace.deviceId,
+			faceId,
+			kind: "assigned"
+		});
 	}
 	/**
 	* Unassign a buffered face from its identity:
@@ -521,6 +533,11 @@ var FaceGalleryProvider = class {
 		await this.eventStore.clearLabelForTrack(face.trackId);
 		await this.trackStore.clearLabel(face.trackId);
 		this.refreshGallery();
+		this.safeEmitFaceGalleryChanged({
+			deviceId: face.deviceId,
+			faceId,
+			kind: "unassigned"
+		});
 	}
 	/**
 	* Delete a buffered face entirely (row + its crop media). If the face is
@@ -534,6 +551,11 @@ var FaceGalleryProvider = class {
 		await this.mediaStore.deleteForOwner("face", [input.faceId]);
 		await this.faceStore.delete(input.faceId);
 		this.refreshGallery();
+		this.safeEmitFaceGalleryChanged({
+			deviceId: face.deviceId,
+			faceId: input.faceId,
+			kind: "deleted"
+		});
 	}
 	/** Batch-assign many faces to one identity. Per-face failures are collected,
 	*  not thrown, so one bad face doesn't abort the rest. */
@@ -691,10 +713,26 @@ function clusterByText(items, maxDistance = 1) {
 //#region src/pipeline-analytics/plate-gallery-provider.ts
 var PlateGalleryProvider = class {
 	plateStore;
+	vehicleStore;
 	mediaStore;
+	trackStore;
+	eventStore;
+	refreshGallery;
+	emitPlateGalleryChanged;
 	constructor(deps) {
 		this.plateStore = deps.plateStore;
+		this.vehicleStore = deps.vehicleStore;
 		this.mediaStore = deps.mediaStore;
+		this.trackStore = deps.trackStore;
+		this.eventStore = deps.eventStore;
+		this.refreshGallery = deps.refreshGallery;
+		this.emitPlateGalleryChanged = deps.emitPlateGalleryChanged;
+	}
+	/** Best-effort emit — never allowed to fail the mutation it follows. */
+	safeEmitPlateGalleryChanged(payload) {
+		try {
+			this.emitPlateGalleryChanged(payload);
+		} catch {}
 	}
 	async plateCropBase64(plate) {
 		if (plate.mediaKey) {
@@ -704,8 +742,9 @@ var PlateGalleryProvider = class {
 		const media = await this.mediaStore.listByOwner("plate", plate.id);
 		return media.length > 0 ? media[0].base64 : void 0;
 	}
-	async toPlateInfo(plate) {
+	async toPlateInfo(plate, nameMap) {
 		const base64 = await this.plateCropBase64(plate);
+		const vehicleName = plate.recognizedVehicleId != null ? nameMap?.get(plate.recognizedVehicleId) : void 0;
 		return {
 			plateId: plate.id,
 			deviceId: plate.deviceId,
@@ -714,20 +753,31 @@ var PlateGalleryProvider = class {
 			text: plate.text,
 			score: plate.score,
 			corrected: plate.corrected,
+			assigned: plate.assigned,
+			...plate.recognizedVehicleId != null ? { recognizedVehicleId: plate.recognizedVehicleId } : {},
+			...vehicleName !== void 0 ? { vehicleName } : {},
+			...plate.plateBbox !== void 0 ? { plateBbox: plate.plateBbox } : {},
+			...plate.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: plate.keyFrameMediaKey } : {},
 			...base64 !== void 0 ? { base64 } : {}
 		};
 	}
+	async vehicleNameMap() {
+		const vehicles = await this.vehicleStore.listVehicles();
+		return new Map(vehicles.map((v) => [v.id, v.name]));
+	}
 	async listPlates(input) {
 		const rows = await this.plateStore.listRecentPlates({
 			...input?.deviceId !== void 0 ? { deviceId: input.deviceId } : {},
 			...input?.limit !== void 0 ? { limit: input.limit } : {}
 		});
-		return Promise.all(rows.map((p) => this.toPlateInfo(p)));
+		const nameMap = await this.vehicleNameMap();
+		return Promise.all(rows.map((p) => this.toPlateInfo(p, nameMap)));
 	}
 	async getPlateByTrack(input) {
 		const plate = await this.plateStore.get(`plate-${input.trackId}`);
 		if (!plate || plate.deviceId !== input.deviceId) return null;
-		return this.toPlateInfo(plate);
+		const nameMap = await this.vehicleNameMap();
+		return this.toPlateInfo(plate, nameMap);
 	}
 	async getPlateMedia(input) {
 		return (await this.mediaStore.listByOwner("plate", input.plateId)).map((m) => ({
@@ -745,7 +795,8 @@ var PlateGalleryProvider = class {
 			dist: plateDistance(input.text, p.text)
 		})).filter((x) => x.dist <= maxDistance).toSorted((a, b) => a.dist - b.dist || b.p.timestamp - a.p.timestamp);
 		const limited = input.limit !== void 0 ? scored.slice(0, input.limit) : scored;
-		return Promise.all(limited.map((x) => this.toPlateInfo(x.p)));
+		const nameMap = await this.vehicleNameMap();
+		return Promise.all(limited.map((x) => this.toPlateInfo(x.p, nameMap)));
 	}
 	async suggestPlateClusters(input) {
 		const maxDistance = input?.maxDistance ?? 1;
@@ -764,8 +815,203 @@ var PlateGalleryProvider = class {
 		});
 	}
 	async deletePlate(input) {
+		const plate = await this.plateStore.get(input.plateId);
+		if (plate?.assigned) await this.unassignPlate({ plateId: input.plateId });
 		await this.plateStore.delete(input.plateId);
 		await this.mediaStore.deleteForOwner("plate", [input.plateId]);
+		this.refreshGallery();
+		if (plate) this.safeEmitPlateGalleryChanged({
+			deviceId: plate.deviceId,
+			plateId: input.plateId,
+			kind: "deleted"
+		});
+	}
+	async listVehicles() {
+		const rows = await this.vehicleStore.listVehicles();
+		const result = [];
+		for (const r of rows) {
+			let coverKey = r.coverMediaKey ?? void 0;
+			if (!coverKey) coverKey = (await this.vehicleStore.listSamples(r.id)).find((s) => s.mediaKey)?.mediaKey;
+			let coverBase64;
+			if (coverKey) {
+				const media = await this.mediaStore.getByKey(coverKey);
+				if (media) coverBase64 = media.base64;
+			}
+			result.push({
+				id: r.id,
+				name: r.name,
+				sampleCount: r.sampleCount,
+				...coverKey != null ? { coverMediaKey: coverKey } : {},
+				...coverBase64 !== void 0 ? { coverBase64 } : {}
+			});
+		}
+		return result;
+	}
+	async createVehicle(input) {
+		const raw = await this.vehicleStore.createVehicle({ name: input.name });
+		this.refreshGallery();
+		return {
+			id: raw.id,
+			name: raw.name,
+			sampleCount: raw.sampleCount,
+			...raw.coverMediaKey !== void 0 ? { coverMediaKey: raw.coverMediaKey } : {}
+		};
+	}
+	async renameVehicle(input) {
+		await this.vehicleStore.renameVehicle(input.id, input.name);
+	}
+	async deleteVehicle(input) {
+		const plates = await this.plateStore.listAllRecentPlates({});
+		for (const p of plates) if (p.recognizedVehicleId === input.id) await this.unassignPlate({ plateId: p.id });
+		await this.mediaStore.deleteForOwner("vehicle", [input.id]);
+		await this.vehicleStore.deleteVehicle(input.id);
+		this.refreshGallery();
+	}
+	async listVehicleSamples(input) {
+		const rows = await this.vehicleStore.listSamples(input.vehicleId);
+		const result = [];
+		for (const row of rows) {
+			let base64;
+			if (row.mediaKey) {
+				const media = await this.mediaStore.getByKey(row.mediaKey);
+				if (media) base64 = media.base64;
+			}
+			result.push({
+				id: row.id,
+				text: row.text,
+				score: row.score,
+				addedAt: row.addedAt,
+				...row.deviceId !== void 0 ? { deviceId: row.deviceId } : {},
+				...base64 !== void 0 ? { base64 } : {}
+			});
+		}
+		return result;
+	}
+	async removeVehicleSample(input) {
+		const sample = (await this.vehicleStore.listSamples(input.vehicleId)).find((s) => s.id === input.sampleId);
+		if (sample?.mediaKey) await this.mediaStore.deleteByKey(sample.mediaKey);
+		await this.vehicleStore.removeSample(input.vehicleId, input.sampleId);
+	}
+	async assignPlate(input) {
+		const { plateId, vehicleId } = input;
+		const plate = await this.plateStore.get(plateId);
+		if (!plate) throw new Error(`PlateGalleryProvider.assignPlate: plate not found: ${plateId}`);
+		if (plate.assignedSampleId !== void 0 && plate.recognizedVehicleId !== void 0) {
+			await this.removeVehicleSample({
+				vehicleId: plate.recognizedVehicleId,
+				sampleId: plate.assignedSampleId
+			});
+			await this.plateStore.clearAssignment(plateId);
+			await this.plateStore.update(plateId, { mediaKey: null });
+		}
+		const current = await this.plateStore.get(plateId);
+		if (!current) throw new Error(`PlateGalleryProvider.assignPlate: plate disappeared: ${plateId}`);
+		let newKey;
+		if (current.mediaKey) {
+			newKey = await this.mediaStore.reown({
+				fromOwnerKind: "plate",
+				fromOwnerId: plateId,
+				toOwnerKind: "vehicle",
+				toOwnerId: vehicleId,
+				key: current.mediaKey
+			});
+			await this.plateStore.update(plateId, { mediaKey: newKey });
+		}
+		let sampleId;
+		try {
+			sampleId = (await this.vehicleStore.addSample({
+				vehicleId,
+				text: current.text,
+				score: current.score,
+				sourcePlateId: plateId,
+				...newKey !== void 0 ? { mediaKey: newKey } : {},
+				...current.deviceId !== void 0 ? { deviceId: current.deviceId } : {}
+			})).id;
+			await this.plateStore.markAssigned(plateId, vehicleId, sampleId);
+		} catch (err) {
+			if (newKey !== void 0) try {
+				await this.mediaStore.reown({
+					fromOwnerKind: "vehicle",
+					fromOwnerId: vehicleId,
+					toOwnerKind: "plate",
+					toOwnerId: plateId,
+					key: newKey
+				});
+			} catch {}
+			throw err;
+		}
+		const vehicle = (await this.vehicleStore.listVehicles()).find((v) => v.id === vehicleId);
+		if (vehicle?.name !== void 0) {
+			await this.trackStore.setLabel(current.trackId, vehicle.name);
+			await this.eventStore.setLabelForTrack(current.trackId, vehicle.name);
+			await recomputeTrackImportance({
+				trackStore: this.trackStore,
+				eventStore: this.eventStore
+			}, current.trackId);
+		}
+		this.refreshGallery();
+		this.safeEmitPlateGalleryChanged({
+			deviceId: current.deviceId,
+			plateId,
+			kind: "assigned"
+		});
+	}
+	async unassignPlate(input) {
+		const { plateId } = input;
+		const plate = await this.plateStore.get(plateId);
+		if (!plate) throw new Error(`PlateGalleryProvider.unassignPlate: plate not found: ${plateId}`);
+		const owningVehicleId = plate.recognizedVehicleId;
+		if (plate.mediaKey && owningVehicleId !== void 0) try {
+			const restoredKey = await this.mediaStore.reown({
+				fromOwnerKind: "vehicle",
+				fromOwnerId: owningVehicleId,
+				toOwnerKind: "plate",
+				toOwnerId: plateId,
+				key: plate.mediaKey
+			});
+			await this.plateStore.update(plateId, { mediaKey: restoredKey });
+		} catch {}
+		if (plate.assignedSampleId !== void 0 && owningVehicleId !== void 0) await this.vehicleStore.removeSample(owningVehicleId, plate.assignedSampleId);
+		await this.plateStore.clearAssignment(plateId);
+		await this.eventStore.clearLabelForTrack(plate.trackId);
+		await this.trackStore.clearLabel(plate.trackId);
+		this.refreshGallery();
+		this.safeEmitPlateGalleryChanged({
+			deviceId: plate.deviceId,
+			plateId,
+			kind: "unassigned"
+		});
+	}
+	async assignPlates(input) {
+		let assigned = 0;
+		const failed = [];
+		for (const plateId of input.plateIds) try {
+			await this.assignPlate({
+				plateId,
+				vehicleId: input.vehicleId
+			});
+			assigned += 1;
+		} catch {
+			failed.push(plateId);
+		}
+		return {
+			assigned,
+			failed
+		};
+	}
+	async unassignPlates(input) {
+		let unassigned = 0;
+		const failed = [];
+		for (const plateId of input.plateIds) try {
+			await this.unassignPlate({ plateId });
+			unassigned += 1;
+		} catch {
+			failed.push(plateId);
+		}
+		return {
+			unassigned,
+			failed
+		};
 	}
 };
 //#endregion
@@ -853,7 +1099,6 @@ var DEFAULT_TRACKER_CONFIG = {
 	stationarySpeedPx: 2
 };
 var MAX_PATH_LENGTH = 300;
-var nextTrackId = 1;
 function clamp(value, min, max) {
 	return Math.max(min, Math.min(max, value));
 }
@@ -1060,7 +1305,7 @@ var SortTracker = class {
 			const det = detections[di];
 			if (this.config.occlusionEnabled && occluderBoxes.some((ob) => containment(det.bbox, ob) >= this.config.occlusionContainment)) continue;
 			surviving.push({
-				id: `track-${nextTrackId++}`,
+				id: (0, node_crypto.randomUUID)(),
 				bbox: det.bbox,
 				class: det.class,
 				originalClass: det.originalClass,
@@ -1526,7 +1771,9 @@ var FrameProcessor = class {
 		const labelsByBbox = /* @__PURE__ */ new Map();
 		const embeddingByBbox = /* @__PURE__ */ new Map();
 		const firstLevelBboxById = /* @__PURE__ */ new Map();
+		const sourceIdByBbox = /* @__PURE__ */ new Map();
 		const faceBboxByBbox = /* @__PURE__ */ new Map();
+		const faceAlignedCropByBbox = /* @__PURE__ */ new Map();
 		const plateByBbox = /* @__PURE__ */ new Map();
 		const maskByBbox = /* @__PURE__ */ new Map();
 		const flatDetections = frame.detections.filter((d) => d.kind === "first-level").map((det) => {
@@ -1553,6 +1800,7 @@ var FrameProcessor = class {
 				height: det.maskHeight
 			});
 			firstLevelBboxById.set(det.id, bbox);
+			sourceIdByBbox.set(bbox, det.id);
 			return {
 				...bbox,
 				detection,
@@ -1569,6 +1817,7 @@ var FrameProcessor = class {
 				w: det.bbox.width,
 				h: det.bbox.height
 			});
+			if (det.faceAlignedCrop !== void 0) faceAlignedCropByBbox.set(parentBbox, det.faceAlignedCrop);
 			if (det.embedding !== void 0 && !embeddingByBbox.has(parentBbox)) embeddingByBbox.set(parentBbox, {
 				embedding: det.embedding,
 				...det.embeddingModelId !== void 0 ? { embeddingModelId: det.embeddingModelId } : {}
@@ -1611,9 +1860,12 @@ var FrameProcessor = class {
 			});
 			const emb = embeddingByBbox.get(td.bbox);
 			const faceBbox = faceBboxByBbox.get(td.bbox);
+			const faceAlignedCrop = faceAlignedCropByBbox.get(td.bbox);
 			const plate = plateByBbox.get(td.bbox);
+			const sourceDetectionId = sourceIdByBbox.get(td.bbox);
 			return {
 				trackId: td.trackId,
+				...sourceDetectionId !== void 0 ? { sourceDetectionId } : {},
 				className: td.class,
 				confidence: td.score,
 				bbox: { ...td.bbox },
@@ -1625,6 +1877,7 @@ var FrameProcessor = class {
 					...emb.embeddingModelId !== void 0 ? { embeddingModelId: emb.embeddingModelId } : {}
 				} : {},
 				...faceBbox !== void 0 ? { faceBbox } : {},
+				...faceAlignedCrop !== void 0 ? { faceAlignedCrop } : {},
 				...plate !== void 0 ? {
 					plateText: plate.text,
 					plateScore: plate.score,
@@ -1675,6 +1928,84 @@ var FrameProcessor = class {
 		};
 	}
 };
+var DEFAULT_UPDATE_GATE_CONFIG = {
+	minConfDelta: .1,
+	minIntervalMs: 4e3,
+	minCropAreaGrowth: .15
+};
+/**
+* Decide whether a `phase:'update'` event should fire this frame.
+*
+* Priority of triggers: newly-resolved identity/plate > confidence
+* improvement > materially larger crop. All triggers are debounced by
+* `minIntervalMs` relative to the last emit. Deltas are measured against
+* the LAST-EMITTED memory, so a run of sub-threshold new-bests accumulates
+* and fires once it crosses `minConfDelta`.
+*/
+function evaluateTrackLifecycleUpdate(signal, memory, config) {
+	const identityTrigger = signal.label !== void 0 && signal.label !== "" && (memory === void 0 || memory.lastLabel !== signal.label);
+	const confidenceTrigger = signal.isNewBest && (memory === void 0 || signal.confidence - memory.lastConfidence >= config.minConfDelta);
+	const cropTrigger = signal.bboxArea !== void 0 && memory?.lastBboxArea !== void 0 && memory.lastBboxArea > 0 && signal.bboxArea >= memory.lastBboxArea * (1 + config.minCropAreaGrowth);
+	const reason = identityTrigger ? "identity" : confidenceTrigger ? "confidence" : cropTrigger ? "crop" : void 0;
+	const keptMemory = memory ?? {
+		lastConfidence: signal.confidence,
+		lastEmitAt: signal.now
+	};
+	if (reason === void 0) return {
+		emit: false,
+		memory: keptMemory
+	};
+	if (memory !== void 0 && signal.now - memory.lastEmitAt < config.minIntervalMs) return {
+		emit: false,
+		memory
+	};
+	const nextLabel = signal.label ?? memory?.lastLabel;
+	const nextBboxArea = signal.bboxArea ?? memory?.lastBboxArea;
+	return {
+		emit: true,
+		reason,
+		memory: {
+			lastConfidence: memory === void 0 ? signal.confidence : Math.max(memory.lastConfidence, signal.confidence),
+			lastEmitAt: signal.now,
+			...nextLabel !== void 0 ? { lastLabel: nextLabel } : {},
+			...nextBboxArea !== void 0 ? { lastBboxArea: nextBboxArea } : {}
+		}
+	};
+}
+/**
+* Assemble the typed lifecycle payload. Optional fields (and the whole
+* `media` object) are omitted when absent so consumers get a clean shape.
+*/
+function buildTrackLifecyclePayload(input) {
+	const media = {
+		...input.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: input.keyFrameMediaKey } : {},
+		...input.bestCropMediaKey !== void 0 ? { bestCropMediaKey: input.bestCropMediaKey } : {},
+		...input.bestEventId !== void 0 ? { bestEventId: input.bestEventId } : {}
+	};
+	const hasMedia = Object.keys(media).length > 0;
+	return {
+		deviceId: input.deviceId,
+		trackId: input.trackId,
+		phase: input.phase,
+		classes: [...input.classes],
+		bestClassName: input.bestClassName,
+		bestConfidence: input.bestConfidence,
+		firstSeen: input.firstSeen,
+		lastSeen: input.lastSeen,
+		durationMs: Math.max(0, input.lastSeen - input.firstSeen),
+		...input.label !== void 0 ? { label: input.label } : {},
+		...input.identityId !== void 0 ? { identityId: input.identityId } : {},
+		...input.plateText !== void 0 ? { plateText: input.plateText } : {},
+		...input.zonesVisited !== void 0 ? { zonesVisited: [...input.zonesVisited] } : {},
+		...input.totalDistance !== void 0 ? { totalDistance: input.totalDistance } : {},
+		...input.positionsCount !== void 0 ? { positionsCount: input.positionsCount } : {},
+		...input.importance !== void 0 ? { importance: input.importance } : {},
+		...input.importanceReason !== void 0 ? { importanceReason: input.importanceReason } : {},
+		...input.embeddingId !== void 0 ? { embeddingId: input.embeddingId } : {},
+		...input.embeddingModelId !== void 0 ? { embeddingModelId: input.embeddingModelId } : {},
+		...hasMedia ? { media } : {}
+	};
+}
 //#endregion
 //#region src/pipeline-analytics/pipeline/best-detection-tracker.ts
 var BestDetectionTracker = class {
@@ -1879,6 +2210,50 @@ function nativeDetectionsToFrame(input) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/delete-track-cascade.ts
+/**
+* Extensible whole-track deletion cascade. Runs every registered
+* `TrackScopedStore` (each removes its ephemeral rows + owned media for the
+* tracks), THEN deletes the track ROOT rows LAST.
+*
+* ORDER MATTERS: every leaf store first, the track row last. The intended
+* production registry (leaves first, root last):
+*
+*   [ eventStore,           // object events + their event-owned media
+*     mediaStore,           // track + unassigned face/plate crops (NEVER identity/vehicle)
+*     faceStore,            // unassigned face rows (assigned/enrolled exempt)
+*     plateStore,           // unassigned plate reads (assigned/enrolled exempt)
+*     objectEmbeddingStore, // per-track CLIP search vectors
+*   ]
+*/
+async function cascadeDeleteTracks(registry, trackStore, trackIds) {
+	for (const store of registry) await store.deleteByTracks(trackIds);
+	for (const trackId of trackIds) await trackStore.deletePersisted(trackId);
+}
+/**
+* Widened batch whole-track deletion — the ONE engine behind the three §5 entry
+* points. Runs the FULL registry cascade per track (via `cascadeDeleteTracks`
+* with a single-id list so the track root is deleted last), fires cleanup on
+* success only, and collects the ids whose cascade threw. Per-track ISOLATED —
+* one bad id never aborts the rest of the batch.
+*/
+async function runTrackCascadeBatch(deps, trackIds) {
+	let deleted = 0;
+	const failed = [];
+	for (const trackId of trackIds) try {
+		await cascadeDeleteTracks(deps.registry, deps.trackStore, [trackId]);
+		deps.onTrackCleanup(deps.deviceId, trackId);
+		deleted += 1;
+	} catch (err) {
+		deps.onFailure?.(trackId, err);
+		failed.push(trackId);
+	}
+	return {
+		deleted,
+		failed
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/runtime/binding-cache.ts
 var BindingCache = class {
 	api;
@@ -1984,6 +2359,10 @@ var TRACKS_COLUMNS = [
 		name: "zonesVisited",
 		type: "JSON"
 	},
+	{
+		name: "classes",
+		type: "JSON"
+	},
 	{
 		name: "totalDistance",
 		type: "REAL"
@@ -2032,6 +2411,7 @@ function cloneTrack(t) {
 			}
 		})),
 		zonesVisited: [...t.zonesVisited],
+		classes: [...t.classes],
 		totalDistance: t.totalDistance,
 		state: t.state,
 		active: t.active,
@@ -2076,6 +2456,7 @@ var TrackStore = class {
 				existing.positions.push(params.position);
 			} else existing.positions.push(params.position);
 			for (const z of params.zones) if (!existing.zonesVisited.includes(z)) existing.zonesVisited.push(z);
+			if (!existing.classes.includes(params.className)) existing.classes.push(params.className);
 			return existing;
 		}
 		const fresh = {
@@ -2088,6 +2469,7 @@ var TrackStore = class {
 			positions: [params.position],
 			snapshots: [],
 			zonesVisited: [...params.zones],
+			classes: [params.className],
 			totalDistance: 0,
 			state: params.state,
 			active: true,
@@ -2230,6 +2612,92 @@ var TrackStore = class {
 	clearAll() {
 		this.active.clear();
 	}
+	/** Delete the persisted track row (keyed by trackId) and drop the in-RAM
+	*  active entry if present. Used by the whole-track deletion cascade. */
+	async deletePersisted(trackId) {
+		await this.store.delete.mutate({
+			collection: TRACKS_COLLECTION,
+			key: trackId
+		});
+		this.active.delete(trackId);
+	}
+	/**
+	* A page of persisted track ids for a device whose `lastSeen < cutoffMs`
+	* (exclusive), oldest first. Feeds the `pruneTracksBefore` drain loop (design
+	* §5.1): the caller cascades the returned ids (which deletes their rows) and
+	* calls again until an empty page. Backed by `idx_tracks_device_lastSeen`.
+	*
+	* Filter shape mirrors `EventStore.pruneBefore`: inclusive `[0, cutoffMs - 1]`
+	* → strictly `< cutoffMs`. Best-effort — a query failure yields [].
+	*/
+	async listIdsBefore(deviceId, cutoffMs, limit) {
+		try {
+			return (await this.store.query.query({
+				collection: TRACKS_COLLECTION,
+				filter: {
+					where: { deviceId },
+					whereBetween: { lastSeen: [0, cutoffMs - 1] },
+					orderBy: {
+						field: "lastSeen",
+						direction: "asc"
+					},
+					limit
+				}
+			})).map((r) => r.id).filter((id) => typeof id === "string");
+		} catch (err) {
+			this.logger.warn("TrackStore.listIdsBefore failed", { meta: {
+				deviceId,
+				cutoffMs,
+				error: String(err)
+			} });
+			return [];
+		}
+	}
+	/**
+	* The distinct set of deviceIds that currently have persisted tracks. Feeds
+	* the per-device retention sweep (design §6) so a device that stopped
+	* producing frames still has its aged track debris pruned. Paged scan +
+	* in-memory dedup (the query cap has no DISTINCT); best-effort.
+	*/
+	async listDeviceIds() {
+		const seenDevices = /* @__PURE__ */ new Set();
+		const seenIds = /* @__PURE__ */ new Set();
+		const PAGE = 500;
+		let cursor = 0;
+		try {
+			for (;;) {
+				const rows = await this.store.query.query({
+					collection: TRACKS_COLLECTION,
+					filter: {
+						whereBetween: { lastSeen: [cursor, Number.MAX_SAFE_INTEGER] },
+						orderBy: {
+							field: "lastSeen",
+							direction: "asc"
+						},
+						limit: PAGE
+					}
+				});
+				if (rows.length === 0) break;
+				let newInPage = 0;
+				let maxLastSeen = cursor;
+				for (const r of rows) {
+					if (typeof r.id === "string" && !seenIds.has(r.id)) {
+						seenIds.add(r.id);
+						newInPage++;
+					}
+					const ls = Number(r.data["lastSeen"]);
+					if (Number.isFinite(ls) && ls > maxLastSeen) maxLastSeen = ls;
+					const deviceId = Number(r.data["deviceId"]);
+					if (Number.isFinite(deviceId)) seenDevices.add(deviceId);
+				}
+				if (rows.length < PAGE || newInPage === 0) break;
+				cursor = maxLastSeen;
+			}
+		} catch (err) {
+			this.logger.warn("TrackStore.listDeviceIds failed", { meta: { error: String(err) } });
+		}
+		return [...seenDevices];
+	}
 	/** Historical query — hits the persisted collection. */
 	async queryHistorical(params) {
 		const filter = { where: { deviceId: params.deviceId } };
@@ -2271,6 +2739,7 @@ var TrackStore = class {
 				positions: [...t.positions],
 				snapshots: [...t.snapshots],
 				zonesVisited: [...t.zonesVisited],
+				...t.classes !== void 0 ? { classes: [...t.classes] } : {},
 				totalDistance: t.totalDistance,
 				state: t.state,
 				...t.importance !== void 0 ? { importance: t.importance } : {},
@@ -2283,6 +2752,7 @@ var TrackStore = class {
 		const positions = data["positions"] ?? [];
 		const snapshots = data["snapshots"] ?? [];
 		const zones = data["zonesVisited"] ?? [];
+		const classes = data["classes"];
 		const label = data["label"];
 		const importance = data["importance"];
 		const bestEventId = data["bestEventId"];
@@ -2297,6 +2767,7 @@ var TrackStore = class {
 			positions,
 			snapshots,
 			zonesVisited: zones,
+			...classes !== null ? { classes } : {},
 			totalDistance: Number(data["totalDistance"] ?? 0),
 			state: data["state"] ?? "idle",
 			active: false,
@@ -2309,6 +2780,18 @@ var TrackStore = class {
 //#endregion
 //#region src/pipeline-analytics/store/media-store.ts
 var MEDIA_COLLECTION = "pipeline-analytics:media";
+/** Owner-id prefix for a track's buffered FACE crop. Invariant established by
+*  the face recognizer (`face-recognizer.ts`): `faceId === 'face-' + trackId`
+*  (one buffered face per track), so a track's face crops are owned by
+*  `face-<trackId>`. Used by `deleteByTracks` to derive the face crop owners of
+*  a set of tracks without a `trackId` column on media rows. */
+var FACE_MEDIA_OWNER_PREFIX = "face-";
+/** Owner-id prefix for a track's buffered PLATE crop. Invariant established by
+*  the plate recognizer (`plate-recognizer.ts`): `plateId === 'plate-' + trackId`
+*  (one buffered plate per track), so a track's plate crops are owned by
+*  `plate-<trackId>`. Used by `deleteByTracks` to derive the plate crop owners
+*  of a set of tracks without a `trackId` column on media rows. */
+var PLATE_MEDIA_OWNER_PREFIX = "plate-";
 var MEDIA_COLUMNS = [
 	{
 		name: "id",
@@ -2673,6 +3156,28 @@ var MediaStore = class {
 	async deleteForEvents(eventIds) {
 		return this.deleteForOwner("event", eventIds);
 	}
+	/** Delete all media owned by these tracks (keyFrame/snapshot/thumbnail). */
+	async deleteForTracks(trackIds) {
+		return this.deleteForOwner("track", trackIds);
+	}
+	/**
+	* `TrackScopedStore` contract for the retention cascade: delete all media
+	* owned by the given tracks — the tracks' OWN media (`ownerKind:'track'`) plus
+	* the UNassigned face crops (`ownerKind:'face'`, owner `face-<trackId>`).
+	*
+	* NEVER deletes `ownerKind:'identity'` or `ownerKind:'vehicle'` media: an
+	* ENROLLED face/plate has its crop REOWNED to `identity`/`vehicle` at
+	* assignment, so deleting only the `'face'`/`'plate'` owner removes unassigned
+	* crops and leaves the enrolled gallery intact. Event-owned media
+	* (`ownerKind:'event'`) is handled by `EventStore` (which holds the eventId
+	* set). `deleteForOwner` is best-effort per row, so one bad row can't abort the
+	* batch.
+	*/
+	async deleteByTracks(trackIds) {
+		await this.deleteForOwner("track", trackIds);
+		await this.deleteForOwner("face", trackIds.map((id) => FACE_MEDIA_OWNER_PREFIX + id));
+		await this.deleteForOwner("plate", trackIds.map((id) => PLATE_MEDIA_OWNER_PREFIX + id));
+	}
 	/** Retention sweep: delete any media row + blob older than cutoff.
 	*  Returns number of entries removed. */
 	async evictBefore(cutoffMs) {
@@ -2835,9 +3340,11 @@ var COMMON_INDEXES = (prefix) => [{
 var EventStore = class {
 	store;
 	logger;
+	media;
 	constructor(deps) {
 		this.store = deps.store;
 		this.logger = deps.logger;
+		this.media = deps.media;
 	}
 	static async declare(store) {
 		await store.declareCollection.mutate({
@@ -3050,6 +3557,12 @@ var EventStore = class {
 		let bestEventId;
 		let peakBboxAreaFrac = 0;
 		for (const row of rows) {
+			const bbox = row.data["bbox"];
+			if (bbox !== null && typeof bbox === "object") {
+				const bw = "w" in bbox && typeof bbox.w === "number" ? bbox.w : 0;
+				const bh = "h" in bbox && typeof bbox.h === "number" ? bbox.h : 0;
+				if (bw <= 0 || bh <= 0) continue;
+			}
 			const conf = typeof row.data["confidence"] === "number" ? row.data["confidence"] : 0;
 			if (conf <= bestConf) continue;
 			bestConf = conf;
@@ -3239,6 +3752,72 @@ var EventStore = class {
 			]
 		};
 	}
+	/**
+	* Delete every OBJECT_EVENTS_COLLECTION row for a single track and RETURN the
+	* deleted event ids so the caller can delete each event's media in lockstep
+	* (the whole-track delete cascade). Motion/audio collections have no
+	* `trackId` column and are never touched.
+	*
+	* The underlying settings-store `query` cap applies a default row limit
+	* (~500). This drains a page at a time — repeatedly querying up to
+	* `PRUNE_PAGE_SIZE` rows for the track and deleting them — until a page
+	* returns 0 rows, so ALL of the track's events are removed regardless of
+	* count. Mirrors the drain loop in `pruneBefore`, including the
+	* infinite-loop guard (a non-empty page that deletes nothing stops the loop).
+	*/
+	async deleteByTrack(trackId) {
+		const ids = [];
+		for (;;) {
+			const rows = await this.store.query.query({
+				collection: OBJECT_EVENTS_COLLECTION,
+				filter: {
+					where: { trackId },
+					limit: 500
+				}
+			});
+			if (rows.length === 0) break;
+			let deletedInPage = 0;
+			for (const row of rows) {
+				const id = row.id;
+				if (typeof id !== "string") continue;
+				try {
+					await this.store.delete.mutate({
+						collection: OBJECT_EVENTS_COLLECTION,
+						key: id
+					});
+					ids.push(id);
+					deletedInPage++;
+				} catch {}
+			}
+			if (deletedInPage === 0) break;
+		}
+		return ids;
+	}
+	/**
+	* `TrackScopedStore` contract for the retention cascade: delete every object
+	* event of the given tracks AND (folded in) the event-owned media of those
+	* events, so a caller can never skip the media wipe. Motion/audio collections
+	* carry no `trackId` and are untouched. Reuses the paged `deleteByTrack` drain
+	* per track and is per-track ISOLATED — a failure on one track never aborts
+	* the others (mirrors the best-effort contract in §4 of the design).
+	*/
+	async deleteByTracks(trackIds) {
+		const eventIds = [];
+		for (const trackId of trackIds) try {
+			const ids = await this.deleteByTrack(trackId);
+			eventIds.push(...ids);
+		} catch (err) {
+			this.logger.warn("EventStore.deleteByTracks: track failed", { meta: {
+				trackId,
+				error: String(err)
+			} });
+		}
+		if (eventIds.length > 0 && this.media !== void 0) try {
+			await this.media.deleteForEvents(eventIds);
+		} catch (err) {
+			this.logger.warn("EventStore.deleteByTracks: event media delete failed", { meta: { error: String(err) } });
+		}
+	}
 };
 function slimMotion(id, data) {
 	return {
@@ -3305,6 +3884,18 @@ function stripNulls(data) {
 	return out;
 }
 //#endregion
+//#region src/shared/frame/resolve-frame.ts
+/**
+* Resolve the pixels a `FrameHandle` refers to. Local shm read when the
+* handle's `nodeId` matches `deps.ownNodeId`, else routed via
+* `deps.getRemoteFrame`. Returns `null` when the frame is no longer
+* available (slot recycled locally, or the remote node reports no frame).
+*/
+async function resolveFrame(handle, deps) {
+	if (handle.nodeId === deps.ownNodeId) return deps.readers.read(handle);
+	return deps.getRemoteFrame(handle);
+}
+//#endregion
 //#region src/shared/frame/square-safe-crop.ts
 /**
 * Compute a square-safe 16:9 crop region in pixel space.
@@ -3427,6 +4018,34 @@ function caption(className, confidence, label) {
 	return typeof confidence === "number" ? `${base} ${Math.round(confidence * 100)}%` : base;
 }
 /**
+* True when a packed-RGB frame is (near-)uniform in every channel — the
+* signature of a blank / hwaccel-unmapped decode frame. Samples a strided set
+* of pixels and checks each channel's min→max spread stays within a small
+* epsilon; a real image always has spread in at least one channel. Cheap
+* (~512 samples) so it runs on every capture.
+*/
+function isUniformRgbFrame(data, width, height) {
+	const pixels = width * height;
+	if (pixels === 0 || data.length < pixels * 3) return false;
+	const step = Math.max(1, Math.floor(pixels / 512)) * 3;
+	const mins = [
+		255,
+		255,
+		255
+	];
+	const maxs = [
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i + 2 < data.length; i += step) for (let c = 0; c < 3; c++) {
+		const v = data[i + c];
+		mins[c] = Math.min(mins[c], v);
+		maxs[c] = Math.max(maxs[c], v);
+	}
+	return maxs.every((mx, c) => mx - mins[c] <= 6);
+}
+/**
 * Generates object-event + track media FROM the decoded detection-pipeline
 * frame (the `frameHandle`/shm frame the detector ran on), NEVER the device
 * snapshot cap. Per object event it writes: a `crop` (square-safe 16:9
@@ -3450,7 +4069,7 @@ var EventMediaDispatcher = class {
 		if (events.length === 0 && trackFrames.length === 0 && snapshots.length === 0) return empty;
 		let decoded;
 		try {
-			decoded = await require_resolve_frame.resolveFrame(frameHandle, {
+			decoded = await resolveFrame(frameHandle, {
 				ownNodeId: this.deps.ownNodeId,
 				readers: this.deps.readers,
 				getRemoteFrame: this.deps.getRemoteFrame
@@ -3486,9 +4105,21 @@ var EventMediaDispatcher = class {
 			});
 			return empty;
 		}
-		const frameData = Buffer.isBuffer(decoded.data) ? decoded.data : Buffer.from(decoded.data);
+		const frameData = Buffer.from(decoded.data);
 		const fw = decoded.width;
 		const fh = decoded.height;
+		if (isUniformRgbFrame(frameData, fw, fh)) {
+			this.deps.logger.debug("event media: resolved frame uniform (blank/hwaccel) — skipping crop", {
+				tags: { deviceId },
+				meta: {
+					deviceId,
+					shmId: frameHandle.shmId,
+					width: fw,
+					height: fh
+				}
+			});
+			return empty;
+		}
 		for (const ev of events) await this.writeEventMedia(deviceId, frameData, fw, fh, ev, input.cropPadding);
 		for (const tf of trackFrames) await this.writeTrackFrame(deviceId, frameData, fw, fh, tf);
 		const storedSnapshots = [];
@@ -3714,8 +4345,264 @@ var EventMediaDispatcher = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/runtime/slice-throttler.ts
-var SliceThrottler = class {
+//#region src/shared/frame/crop-extractor.ts
+/**
+* Extracts a JPEG-encoded crop from a raw frame buffer using a normalized bounding box.
+* Coordinates are clamped to frame bounds to avoid out-of-range errors.
+*/
+async function extractCrop(frameData, frameWidth, frameHeight, bbox) {
+	const rawLeft = Math.round(bbox.x * frameWidth);
+	const rawTop = Math.round(bbox.y * frameHeight);
+	const rawWidth = Math.round(bbox.w * frameWidth);
+	const rawHeight = Math.round(bbox.h * frameHeight);
+	const left = Math.max(0, Math.min(rawLeft, frameWidth - 1));
+	const top = Math.max(0, Math.min(rawTop, frameHeight - 1));
+	const width = Math.max(1, Math.min(rawWidth, frameWidth - left));
+	const height = Math.max(1, Math.min(rawHeight, frameHeight - top));
+	return {
+		crop: await (0, sharp.default)(frameData, { raw: {
+			width: frameWidth,
+			height: frameHeight,
+			channels: 3
+		} }).extract({
+			left,
+			top,
+			width,
+			height
+		}).jpeg({ quality: 90 }).toBuffer(),
+		width,
+		height
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/embedding/embedding-dispatcher.ts
+function selectCropBbox(detection) {
+	return detection.refinedBbox ?? detection.bbox;
+}
+var EmbeddingDispatcher = class {
+	config;
+	encoder;
+	eventBus;
+	logger;
+	ownNodeId;
+	readers;
+	getRemoteFrame;
+	lastEmbedTime = /* @__PURE__ */ new Map();
+	pendingCrops = /* @__PURE__ */ new Map();
+	flushTimer = null;
+	unsubscribe = null;
+	_processedCount = 0;
+	_totalInferenceMs = 0;
+	constructor(deps) {
+		this.config = deps.config;
+		this.encoder = deps.encoder;
+		this.eventBus = deps.eventBus;
+		this.logger = deps.logger;
+		this.ownNodeId = deps.ownNodeId;
+		this.readers = deps.readers;
+		this.getRemoteFrame = deps.getRemoteFrame;
+	}
+	async start() {
+		if (!this.config.enabled) {
+			this.logger.info("EmbeddingDispatcher disabled");
+			return;
+		}
+		this.unsubscribe = this.eventBus.subscribe({ category: require_dist.EventCategory.DetectionResult }, (event) => {
+			this.handleDetectionResult(event);
+		});
+		if (this.config.cropStrategy === "best-confidence") this.flushTimer = setInterval(() => {
+			this.flushPending();
+		}, 1e3);
+		this.logger.info("EmbeddingDispatcher started", { meta: {
+			strategy: this.config.cropStrategy,
+			maxPerSec: this.config.maxPerSecPerCamera
+		} });
+	}
+	async stop() {
+		this.unsubscribe?.();
+		this.unsubscribe = null;
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = null;
+		}
+		await this.flushPending();
+	}
+	get processedCount() {
+		return this._processedCount;
+	}
+	get avgInferenceMs() {
+		return this._processedCount > 0 ? this._totalInferenceMs / this._processedCount : 0;
+	}
+	get queueDepth() {
+		return this.pendingCrops.size;
+	}
+	async handleDetectionResult(event) {
+		const data = event.data;
+		const deviceId = event.source.id !== void 0 ? String(event.source.id) : "";
+		if (!deviceId) return;
+		const detections = data.analysisResults ?? [];
+		const handle = data.frameHandle;
+		if (!handle) {
+			this.logger.debug("skip: no frameHandle on DetectionResult", {
+				tags: { deviceId: Number(deviceId) },
+				meta: { deviceId }
+			});
+			return;
+		}
+		let decoded;
+		try {
+			decoded = await resolveFrame(handle, {
+				ownNodeId: this.ownNodeId,
+				readers: this.readers,
+				getRemoteFrame: this.getRemoteFrame
+			});
+		} catch (err) {
+			this.logger.debug("skip: resolveFrame threw", {
+				tags: { deviceId: Number(deviceId) },
+				meta: {
+					deviceId,
+					shmId: handle.shmId,
+					error: String(err)
+				}
+			});
+			return;
+		}
+		if (!decoded) {
+			this.logger.debug("skip: frame recycled before resolve", {
+				tags: { deviceId: Number(deviceId) },
+				meta: {
+					deviceId,
+					shmId: handle.shmId
+				}
+			});
+			return;
+		}
+		if (decoded.format !== "rgb") {
+			this.logger.debug("skip: resolved frame is not RGB", {
+				tags: { deviceId: Number(deviceId) },
+				meta: {
+					deviceId,
+					format: decoded.format
+				}
+			});
+			return;
+		}
+		const frameData = Buffer.isBuffer(decoded.data) ? decoded.data : Buffer.from(decoded.data);
+		const frameWidth = decoded.width;
+		const frameHeight = decoded.height;
+		for (const det of detections) {
+			const detection = det.detection;
+			if (!detection) continue;
+			if (this.config.classes.length > 0 && !this.config.classes.includes(detection.class)) continue;
+			if (detection.score < this.config.minConfidence) continue;
+			const now = Date.now();
+			const minInterval = 1e3 / this.config.maxPerSecPerCamera;
+			if (now - (this.lastEmbedTime.get(deviceId) ?? 0) < minInterval) continue;
+			const trackId = detection.trackId ?? `${deviceId}-${now}`;
+			const pending = {
+				trackId,
+				deviceId,
+				class: detection.class,
+				confidence: detection.score,
+				frameData,
+				frameWidth,
+				frameHeight,
+				bbox: selectCropBbox(detection),
+				receivedAt: now
+			};
+			switch (this.config.cropStrategy) {
+				case "first":
+					if (!this.pendingCrops.has(trackId)) {
+						this.pendingCrops.set(trackId, pending);
+						this.processOne(pending);
+					}
+					break;
+				case "best-confidence": {
+					const existing = this.pendingCrops.get(trackId);
+					if (!existing || pending.confidence > existing.confidence) this.pendingCrops.set(trackId, pending);
+					break;
+				}
+				case "track-end":
+					if (det.objectState?.state === "leaving") {
+						this.pendingCrops.set(trackId, pending);
+						this.processOne(pending);
+					} else {
+						const existing = this.pendingCrops.get(trackId);
+						if (!existing || pending.confidence > existing.confidence) this.pendingCrops.set(trackId, pending);
+					}
+					break;
+			}
+		}
+	}
+	async flushPending() {
+		const now = Date.now();
+		const toFlush = [];
+		for (const [trackId, pending] of this.pendingCrops) if (now - pending.receivedAt > 3e3) {
+			toFlush.push(pending);
+			this.pendingCrops.delete(trackId);
+		}
+		await Promise.all(toFlush.map((p) => this.processOne(p)));
+	}
+	async processOne(pending) {
+		try {
+			const { crop, width, height } = await extractCrop(pending.frameData, pending.frameWidth, pending.frameHeight, pending.bbox);
+			const { embedding: _embedding, inferenceMs } = await this.encoder.encode(crop, width, height);
+			const info = await this.encoder.getInfo();
+			this._processedCount++;
+			this._totalInferenceMs += inferenceMs;
+			this.lastEmbedTime.set(pending.deviceId, Date.now());
+			this.pendingCrops.delete(pending.trackId);
+			const embeddingId = `${pending.deviceId}/${pending.trackId}/${Date.now()}`;
+			const payload = {
+				deviceId: Number(pending.deviceId),
+				trackId: pending.trackId,
+				class: pending.class,
+				embeddingId,
+				modelId: info.modelId,
+				embeddingDim: info.embeddingDim,
+				inferenceMs,
+				timestamp: Date.now()
+			};
+			this.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.EnrichmentEmbeddingStored, {
+				type: "addon",
+				id: "pipeline-analytics"
+			}, payload));
+			this.logger.debug("Embedded track", {
+				tags: { deviceId: Number(pending.deviceId) },
+				meta: {
+					class: pending.class,
+					trackId: pending.trackId,
+					inferenceMs: Number(inferenceMs.toFixed(1))
+				}
+			});
+		} catch (err) {
+			this.logger.warn("Failed to embed track", {
+				tags: { deviceId: Number(pending.deviceId) },
+				meta: {
+					trackId: pending.trackId,
+					error: String(err)
+				}
+			});
+		}
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/embedding/embedding-config.ts
+var DEFAULT_EMBEDDING_CONFIG = {
+	enabled: true,
+	modelId: "clip-vit-b32",
+	agentId: "local",
+	runtime: "node",
+	backend: "cpu",
+	classes: [],
+	minConfidence: .5,
+	maxPerSecPerCamera: 1,
+	cropStrategy: "first",
+	retentionDays: 30
+};
+//#endregion
+//#region src/pipeline-analytics/runtime/slice-throttler.ts
+var SliceThrottler = class {
 	opts;
 	lastWrittenAt = /* @__PURE__ */ new Map();
 	lastWritten = /* @__PURE__ */ new Map();
@@ -4590,6 +5477,56 @@ function resolveMediaSettings(raw) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/track-retention-sweep.ts
+/**
+* Periodic track retention sweep (design §6) — the piece that makes retention
+* actually BOUNDED. Without it, `pruneTracksBefore` only runs when something
+* calls it; this sweep ages persisted tracks out on the provider's existing
+* retention interval.
+*
+* `retentionMs` is a PER-DEVICE setting (`trackRetentionDays`, default 7 days;
+* `0` = keep forever → the device is skipped). Enrolled gallery is exempt by the
+* cascade store layer (design §4), not here.
+*
+* Kept as a pure, dependency-injected function so the loop is unit-testable
+* without booting the addon.
+*/
+var DAY_MS = 1440 * 60 * 1e3;
+/** Per-device track retention setting. Default 7 days; 0 = keep forever. */
+var TrackRetentionSettingsSchema = require_dist.object({ trackRetentionDays: require_dist.number().min(0).default(7) });
+var TRACK_RETENTION_DEFAULT_DAYS = TrackRetentionSettingsSchema.parse({}).trackRetentionDays;
+/** Resolve `trackRetentionDays` from a raw per-device store blob — an invalid or
+*  missing value falls back to the default (parse never throws). */
+function resolveTrackRetentionDays(raw) {
+	const parsed = TrackRetentionSettingsSchema.shape.trackRetentionDays.safeParse(raw["trackRetentionDays"]);
+	return parsed.success ? parsed.data : TRACK_RETENTION_DEFAULT_DAYS;
+}
+/** Cutoff timestamp for a retention window. `null` when retention is disabled
+*  (`retentionDays <= 0` → keep forever, the sweep skips the device). */
+function trackRetentionCutoff(nowMs, retentionDays) {
+	if (retentionDays <= 0) return null;
+	return nowMs - retentionDays * DAY_MS;
+}
+/**
+* Sweep every device with persisted tracks: skip retention-disabled devices,
+* prune the rest at `now − retentionMs`. Per-device ISOLATED — one bad device
+* never aborts the sweep. Returns the total tracks pruned across devices.
+*/
+async function sweepTrackRetention(deps) {
+	const devices = await deps.listDeviceIds();
+	const nowMs = deps.now();
+	let totalTracks = 0;
+	for (const deviceId of devices) try {
+		const cutoffMs = trackRetentionCutoff(nowMs, await deps.resolveRetentionDays(deviceId));
+		if (cutoffMs === null) continue;
+		const counts = await deps.pruneTracksBefore(deviceId, cutoffMs);
+		totalTracks += counts.tracks;
+	} catch (err) {
+		deps.onError?.(deviceId, err);
+	}
+	return totalTracks;
+}
+//#endregion
 //#region src/pipeline-analytics/store/identity-store.ts
 /**
 * IdentityStore — per-person identity registry for face recognition.
@@ -4639,7 +5576,7 @@ var IDENTITY_COLUMNS = [
 		type: "TEXT"
 	}
 ];
-var SAMPLE_COLUMNS = [
+var SAMPLE_COLUMNS$1 = [
 	{
 		name: "id",
 		type: "TEXT",
@@ -4700,7 +5637,7 @@ var IdentityStore = class {
 		});
 		await store.declareCollection.mutate({
 			collection: IDENTITY_SAMPLES_COLLECTION,
-			columns: [...SAMPLE_COLUMNS],
+			columns: [...SAMPLE_COLUMNS$1],
 			indexes: [{
 				name: "idx_sample_identity",
 				columns: ["identityId"]
@@ -5135,6 +6072,38 @@ var FaceStore = class {
 			} });
 		}
 	}
+	/**
+	* `TrackScopedStore` contract for the retention cascade: delete the buffered
+	* face rows of the given tracks that are NOT assigned. Reuses the EXACT
+	* `assigned` exemption that `prune`/`pruneAll` apply (see the
+	* `!(r.data.assigned)` predicate above) so ENROLLED faces SURVIVE retention.
+	* Per-track ISOLATED + best-effort per row — one bad track or row never
+	* aborts the batch. (Crop media of these rows is removed by `MediaStore`.)
+	*/
+	async deleteByTracks(trackIds) {
+		for (const trackId of trackIds) try {
+			const eligible = (await this.store.query.query({
+				collection: FACES_COLLECTION,
+				filter: { where: { trackId } }
+			})).filter((r) => !r.data.assigned);
+			for (const row of eligible) try {
+				await this.store.delete.mutate({
+					collection: FACES_COLLECTION,
+					key: row.id
+				});
+			} catch (err) {
+				this.logger.warn("FaceStore.deleteByTracks delete failed", { meta: {
+					faceId: row.id,
+					error: String(err)
+				} });
+			}
+		} catch (err) {
+			this.logger.warn("FaceStore.deleteByTracks query failed", { meta: {
+				trackId,
+				error: String(err)
+			} });
+		}
+	}
 	/** Delete a single buffered face row by id (its crop media is removed by the
 	*  caller — the FaceStore owns rows, not blobs). Best-effort. */
 	async delete(faceId) {
@@ -5406,6 +6375,27 @@ var ObjectEmbeddingStore = class {
 		}
 		return ids;
 	}
+	/**
+	* `TrackScopedStore` contract for the retention cascade: delete the per-track
+	* CLIP search vector for the given tracks. The row id IS the trackId (one row
+	* per track), so this deletes by key directly. Pure EPHEMERAL track state —
+	* the identity MATCHING embeddings (ArcFace) live in a SEPARATE durable store
+	* (`identity-samples`) and are never touched here, so pruning this never
+	* breaks recognition (design §2/§4). Per-track ISOLATED + best-effort.
+	*/
+	async deleteByTracks(trackIds) {
+		for (const trackId of trackIds) try {
+			await this.store.delete.mutate({
+				collection: OBJECT_EMBEDDINGS_COLLECTION,
+				key: trackId
+			});
+		} catch (err) {
+			this.logger.warn("ObjectEmbeddingStore.deleteByTracks failed", { meta: {
+				trackId,
+				error: String(err)
+			} });
+		}
+	}
 };
 //#endregion
 //#region src/pipeline-analytics/pipeline/face-matcher.ts
@@ -5500,6 +6490,14 @@ function updateTrackAggregate(prev, match, opts) {
 //#region src/pipeline-analytics/face-recognizer.ts
 /** At most one "dropping imageless track" log per this interval, per recognizer. */
 var FACE_IMAGELESS_LOG_THROTTLE_MS = 6e4;
+/**
+* arcface model id stamped on a detail-plane face candidate when the gallery is
+* empty (collect-only). The detail-subtree result carries no `embeddingModelId`
+* (the two-plane `DetailResult` schema omits it), so recognition uses the
+* gallery's own model id (all enrolled samples share one) and this constant is
+* only a placeholder for the collect-only case where the id is never compared.
+*/
+var FALLBACK_FACE_MODEL_ID = "arcface";
 var FaceRecognizer = class {
 	deps;
 	gallery = [];
@@ -5527,6 +6525,38 @@ var FaceRecognizer = class {
 			this.deps.logger.warn("FaceRecognizer.refreshGallery failed", { meta: { error: String(err) } });
 		}
 	}
+	/**
+	* Two-plane detail feed: ingest ONE `runDetailSubtree` face result for a
+	* track and run it through the SAME `processFrame` logic (candidate → best
+	* face → gallery match → crop hold). The result is synthesized into a single
+	* `TrackedDetectionOut` candidate so no recognizer logic changes — only the
+	* input source moves from the per-frame plane to this per-track call.
+	*/
+	async ingestFaceDetail(input) {
+		const modelId = this.gallery[0]?.modelId ?? FALLBACK_FACE_MODEL_ID;
+		const candidate = {
+			trackId: input.trackId,
+			className: "face",
+			confidence: input.score,
+			bbox: input.parentBbox,
+			zones: [],
+			state: "moving",
+			embedding: input.embedding,
+			embeddingModelId: modelId,
+			...input.faceBbox !== void 0 ? { faceBbox: input.faceBbox } : {},
+			...input.alignedCropJpeg !== void 0 ? { faceAlignedCrop: input.alignedCropJpeg } : {}
+		};
+		await this.processFrame({
+			deviceId: input.deviceId,
+			timestamp: input.timestamp,
+			frameWidth: input.frameWidth,
+			frameHeight: input.frameHeight,
+			tracked: [candidate],
+			settings: input.settings,
+			cropPadding: input.cropPadding,
+			...input.frameHandle !== void 0 ? { frameHandle: input.frameHandle } : {}
+		});
+	}
 	async processFrame(input) {
 		const { settings } = input;
 		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && t.confidence >= settings.minFaceConfidence);
@@ -5564,7 +6594,8 @@ var FaceRecognizer = class {
 			if (isNewBest || needsCrop) {
 				const cropBbox = c.faceBbox ?? c.bbox;
 				let crop;
-				if (c.faceBbox !== void 0 && input.frameHandle !== void 0) try {
+				if (c.faceAlignedCrop !== void 0) crop = Buffer.from(c.faceAlignedCrop, "base64");
+				else if (c.faceBbox !== void 0 && input.frameHandle !== void 0) try {
 					crop = await this.deps.captureCrop(input.frameHandle, c.faceBbox, input.frameWidth, input.frameHeight, input.cropPadding) ?? void 0;
 				} catch (err) {
 					this.deps.logger.debug("FaceRecognizer crop capture failed", {
@@ -5743,6 +6774,24 @@ var FaceRecognizer = class {
 					score: held.score
 				}
 			});
+			try {
+				this.deps.emitFaceGalleryChanged?.({
+					deviceId,
+					faceId,
+					kind: "buffered"
+				});
+			} catch (err) {
+				this.deps.logger.debug("face-gallery-changed emit failed", {
+					tags: {
+						deviceId,
+						trackId
+					},
+					meta: {
+						faceId,
+						error: String(err)
+					}
+				});
+			}
 		} catch (err) {
 			this.deps.logger.warn("FaceRecognizer faceStore insert failed", {
 				tags: { deviceId },
@@ -5755,103 +6804,667 @@ var FaceRecognizer = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/store/plate-store.ts
-var PLATES_COLLECTION = "pipeline-analytics:plates";
-var PLATE_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "deviceId",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "trackId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "timestamp",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "text",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "score",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "mediaKey",
-		type: "TEXT"
-	},
-	{
-		name: "corrected",
-		type: "BOOLEAN",
-		notNull: true
-	}
-];
-var PLATE_INDEXES = [{
-	name: "idx_plates_device_ts",
-	columns: ["deviceId", "timestamp"]
-}, {
-	name: "idx_plates_track",
-	columns: ["trackId"]
-}];
-var PlateStore = class {
-	store;
-	logger;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-	}
-	static async declare(store) {
-		await store.declareCollection.mutate({
-			collection: PLATES_COLLECTION,
-			columns: [...PLATE_COLUMNS],
-			indexes: [...PLATE_INDEXES]
-		});
-	}
-	/** Upsert one buffered plate read (keyed by `plate.id` = `plate-${trackId}`). */
-	async insert(plate) {
-		const { id, ...rest } = plate;
-		try {
-			await this.store.set.mutate({
-				collection: PLATES_COLLECTION,
-				key: id,
-				value: rest
-			});
-		} catch (err) {
-			this.logger.warn("PlateStore.insert failed", {
-				tags: { deviceId: plate.deviceId },
-				meta: {
-					plateId: id,
-					error: String(err)
+//#region src/pipeline-analytics/detail-scheduler.ts
+/** Default backoff/period when a step's cadence omits `minIntervalMs`. */
+var DEFAULT_MIN_INTERVAL_MS = 1e3;
+/** Default fire cap for a `once` step when its announce omits `maxPerTrack`. */
+var DEFAULT_ONCE_MAX_PER_TRACK = 3;
+/**
+* Pure per-(track, step) scheduling state machine for detail-subtree
+* dispatch. Given a camera's announced child steps (`DetailStepAnnounce[]`,
+* read off `PipelineInferenceResultPayload.detailSteps`), decides WHEN each
+* step should run for a given track — independent of transport, I/O, or
+* timers. The caller drives it with wall-clock `nowMs` and dispatches the
+* returned `DetailRequest[]`.
+*/
+var DetailScheduler = class {
+	tracks = /* @__PURE__ */ new Map();
+	/** Track appeared with class + announce; returns immediate requests. */
+	onTrackStarted(trackId, className, announce, nowMs) {
+		const steps = /* @__PURE__ */ new Map();
+		const requests = [];
+		for (const stepAnnounce of announce) {
+			if (!stepAnnounce.inputClasses.includes(className)) continue;
+			const state = {
+				announce: stepAnnounce,
+				firedCount: 1,
+				lastFiredAt: nowMs,
+				sticky: false,
+				retryPending: false
+			};
+			steps.set(stepAnnounce.stepId, state);
+			requests.push({
+				trackId,
+				stepId: stepAnnounce.stepId,
+				reason: "new-track"
+			});
+		}
+		this.tracks.set(trackId, steps);
+		return requests;
+	}
+	/** Better candidate crop observed for the track. */
+	onCandidateImproved(trackId, nowMs) {
+		const steps = this.tracks.get(trackId);
+		if (!steps) return [];
+		const requests = [];
+		for (const state of steps.values()) {
+			if (state.announce.cadence.trigger !== "improve") continue;
+			if (!this.canFire(state, nowMs)) continue;
+			this.markFired(state, nowMs);
+			requests.push({
+				trackId,
+				stepId: state.announce.stepId,
+				reason: "improve"
+			});
+		}
+		return requests;
+	}
+	/** Periodic tick (call ~1/s). Also carries pending retries for any trigger kind. */
+	tick(nowMs) {
+		const requests = [];
+		for (const [trackId, steps] of this.tracks) for (const state of steps.values()) {
+			if (state.sticky) continue;
+			if (state.retryPending) {
+				if (!this.intervalElapsed(state, nowMs)) continue;
+				if (!this.underMaxPerTrack(state)) {
+					state.retryPending = false;
+					continue;
 				}
+				this.markFired(state, nowMs);
+				requests.push({
+					trackId,
+					stepId: state.announce.stepId,
+					reason: "retry"
+				});
+				continue;
+			}
+			if (state.announce.cadence.trigger !== "periodic") continue;
+			if (!this.canFire(state, nowMs)) continue;
+			this.markFired(state, nowMs);
+			requests.push({
+				trackId,
+				stepId: state.announce.stepId,
+				reason: "periodic"
 			});
 		}
+		return requests;
 	}
-	normalizeRow(r) {
-		const data = r.data;
-		return {
-			id: r.id,
-			...data,
-			score: Number(r.data.score ?? 0),
-			corrected: Boolean(r.data.corrected),
-			mediaKey: data.mediaKey ?? void 0
-		};
+	/**
+	* Result arrived; confidence drives sticky/retry. null = failed (retry per
+	* policy). `_nowMs` is part of the public signature for symmetry with the
+	* other methods but isn't needed here — retry backoff is anchored to
+	* `lastFiredAt` (set when the step was actually dispatched), not to when
+	* its result came back.
+	*/
+	onResult(trackId, stepId, confidence, _nowMs) {
+		const steps = this.tracks.get(trackId);
+		if (!steps) return;
+		const state = steps.get(stepId);
+		if (!state) return;
+		if (state.sticky) return;
+		const { stickyOnConfidence } = state.announce.cadence;
+		if (confidence !== null && stickyOnConfidence !== void 0 && confidence >= stickyOnConfidence) {
+			state.sticky = true;
+			state.retryPending = false;
+			return;
+		}
+		if (confidence === null) {
+			if (this.underMaxPerTrack(state)) state.retryPending = true;
+			return;
+		}
+		if (state.announce.cadence.trigger === "once" && stickyOnConfidence !== void 0) {
+			if (this.underMaxPerTrack(state)) state.retryPending = true;
+		}
 	}
-	/** Recent plate reads for one device (or all when deviceId omitted), newest first. */
-	async listRecentPlates(input) {
-		const where = {};
+	onTrackEnded(trackId) {
+		this.tracks.delete(trackId);
+	}
+	canFire(state, nowMs) {
+		if (state.sticky) return false;
+		if (!this.underMaxPerTrack(state)) return false;
+		return this.intervalElapsed(state, nowMs);
+	}
+	intervalElapsed(state, nowMs) {
+		if (state.lastFiredAt === null) return true;
+		const minIntervalMs = state.announce.cadence.minIntervalMs ?? DEFAULT_MIN_INTERVAL_MS;
+		return nowMs - state.lastFiredAt >= minIntervalMs;
+	}
+	underMaxPerTrack(state) {
+		const maxPerTrack = state.announce.cadence.maxPerTrack ?? (state.announce.cadence.trigger === "once" ? DEFAULT_ONCE_MAX_PER_TRACK : Infinity);
+		return state.firedCount < maxPerTrack;
+	}
+	markFired(state, nowMs) {
+		state.firedCount += 1;
+		state.lastFiredAt = nowMs;
+		state.retryPending = false;
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/detail-dispatcher.ts
+/**
+* Compose the `steps` list sent to `runDetailSubtree` for one request —
+* identity-aware for the face chain.
+*
+* A `face-detection` request ALSO includes `'face-embedding'` (the full
+* detect→recognize chain) EXCEPT when it is a PERIODIC geometry refresh on a
+* track that already carries an identity label: re-embedding a known face every
+* second is wasted ArcFace inference (250-1900ms per call on N100 agents), so
+* that case runs the detector geometry ALONE. Every recognition-bearing reason
+* (new-track / improve / retry) keeps the embedding regardless of the label.
+*
+* Non-face steps are unchanged (`[req.stepId]`). Pairs with the pipeline's
+* strict-`steps` pruning (`pruneChildStepsToRequested`) — including
+* `'face-embedding'` here is what keeps the nested child in the executed chain.
+*/
+function composeDetailSteps(req, hasTrackLabel) {
+	if (req.stepId !== "face-detection") return [req.stepId];
+	return req.reason === "periodic" && hasTrackLabel(req.trackId) ? ["face-detection"] : ["face-detection", "face-embedding"];
+}
+/** Throttle for the per-device "detail call failed" warn — one line / minute. */
+var FAIL_WARN_THROTTLE_MS = 6e4;
+var TrackDetailDispatcher = class {
+	deps;
+	devices = /* @__PURE__ */ new Map();
+	maxInFlight;
+	tickIntervalMs;
+	disposed = false;
+	constructor(deps) {
+		this.deps = deps;
+		this.maxInFlight = deps.maxInFlightPerDevice ?? 2;
+		this.tickIntervalMs = deps.tickIntervalMs ?? 1e3;
+	}
+	/** A track appeared: record its frame, seed its best-confidence, and dispatch
+	*  the scheduler's immediate (new-track) requests. */
+	onTrackStarted(deviceId, trackId, className, announce, frame, nowMs) {
+		if (this.disposed) return;
+		const dev = this.ensureDevice(deviceId);
+		dev.tracks.set(trackId, frame);
+		dev.candidateBest.observe(trackId, frame.confidence, frame.timestamp);
+		const requests = dev.scheduler.onTrackStarted(trackId, className, announce, nowMs);
+		this.enqueue(deviceId, dev, requests);
+		this.ensureTimer(deviceId, dev);
+	}
+	/** A subsequent frame for a live track: refresh its frame + fire
+	*  `improve`-cadence steps when the detector confidence strictly improves.
+	*
+	*  `announce` is the frame's currently-announced detail chain. When a track
+	*  is alive but has NO dispatcher state yet — it existed before `detailSteps`
+	*  first appeared (a mid-track redeploy / config change) — this adopts it as a
+	*  new track so it starts getting scheduled instead of starving for its whole
+	*  life. Idempotent: guarded by the per-track state check, so a track that
+	*  already has state is never reset. */
+	onFrame(deviceId, trackId, announce, frame, nowMs) {
+		if (this.disposed) return;
+		const dev = this.devices.get(deviceId);
+		if (!dev || !dev.tracks.has(trackId)) {
+			if (announce.length > 0) this.onTrackStarted(deviceId, trackId, frame.className, announce, frame, nowMs);
+			return;
+		}
+		dev.tracks.set(trackId, frame);
+		if (!dev.candidateBest.observe(trackId, frame.confidence, frame.timestamp)) return;
+		const requests = dev.scheduler.onCandidateImproved(trackId, nowMs);
+		this.enqueue(deviceId, dev, requests);
+	}
+	/** A track ended (durable TTL expiry): drop its scheduler + frame state. Any
+	*  queued request for it is discarded at dequeue. */
+	onTrackEnded(deviceId, trackId) {
+		const dev = this.devices.get(deviceId);
+		if (!dev) return;
+		dev.scheduler.onTrackEnded(trackId);
+		dev.tracks.delete(trackId);
+		dev.candidateBest.delete(trackId);
+		if (dev.tracks.size === 0) this.clearTimer(dev);
+	}
+	dispose() {
+		this.disposed = true;
+		for (const dev of this.devices.values()) {
+			this.clearTimer(dev);
+			dev.queue.length = 0;
+			dev.tracks.clear();
+			dev.candidateBest.clear();
+		}
+		this.devices.clear();
+	}
+	ensureDevice(deviceId) {
+		let dev = this.devices.get(deviceId);
+		if (!dev) {
+			dev = {
+				scheduler: new DetailScheduler(),
+				tracks: /* @__PURE__ */ new Map(),
+				candidateBest: new BestDetectionTracker(),
+				queue: [],
+				inFlight: 0,
+				timer: null,
+				lastFailWarnAt: 0
+			};
+			this.devices.set(deviceId, dev);
+		}
+		return dev;
+	}
+	ensureTimer(deviceId, dev) {
+		if (dev.timer) return;
+		const timer = setInterval(() => this.tick(deviceId, dev), this.tickIntervalMs);
+		if (typeof timer.unref === "function") timer.unref();
+		dev.timer = timer;
+	}
+	clearTimer(dev) {
+		if (dev.timer) {
+			clearInterval(dev.timer);
+			dev.timer = null;
+		}
+	}
+	tick(deviceId, dev) {
+		if (this.disposed) return;
+		const requests = dev.scheduler.tick(Date.now());
+		this.enqueue(deviceId, dev, requests);
+	}
+	enqueue(deviceId, dev, requests) {
+		if (requests.length === 0) return;
+		for (const r of requests) dev.queue.push(r);
+		this.pump(deviceId, dev);
+	}
+	pump(deviceId, dev) {
+		while (dev.inFlight < this.maxInFlight && dev.queue.length > 0) {
+			const req = dev.queue.shift();
+			if (req === void 0) break;
+			const frame = dev.tracks.get(req.trackId);
+			if (frame === void 0) continue;
+			dev.inFlight += 1;
+			this.dispatch(deviceId, dev, req, frame).finally(() => {
+				dev.inFlight -= 1;
+				this.pump(deviceId, dev);
+			});
+		}
+	}
+	async dispatch(deviceId, dev, req, frame) {
+		const details = await this.runOnce(deviceId, dev, req, frame);
+		let topScore = null;
+		if (details !== null && details.length > 0) {
+			topScore = details.reduce((max, d) => d.score > max ? d.score : max, Number.NEGATIVE_INFINITY);
+			try {
+				await this.deps.routeResults(deviceId, req.trackId, details, frame);
+			} catch (err) {
+				this.deps.logger.warn("detail result routing failed", {
+					tags: { deviceId },
+					meta: {
+						trackId: req.trackId,
+						stepId: req.stepId,
+						error: String(err)
+					}
+				});
+			}
+		}
+		dev.scheduler.onResult(req.trackId, req.stepId, topScore, Date.now());
+	}
+	/**
+	* Run the request once via the frameHandle, and — on a miss (null OR throw)
+	* — retry ONCE with a `cropJpeg` fallback when one can be captured. Returns
+	* the detail list, or `null` when both attempts fail to produce a result.
+	*/
+	async runOnce(deviceId, dev, req, frame) {
+		const parent = {
+			bbox: { ...frame.bbox },
+			className: frame.className
+		};
+		const steps = composeDetailSteps(req, (trackId) => this.deps.hasTrackLabel?.(trackId) ?? false);
+		if (frame.frameHandle !== void 0) try {
+			const primary = await this.deps.runDetailSubtree({
+				deviceId,
+				frameHandle: frame.frameHandle,
+				parent,
+				steps
+			}, frame.nodeId);
+			if (primary !== null) return primary.details;
+		} catch (err) {
+			this.deps.logger.debug("detail primary call failed — trying crop fallback", {
+				tags: { deviceId },
+				meta: {
+					trackId: req.trackId,
+					stepId: req.stepId,
+					error: String(err)
+				}
+			});
+		}
+		if (this.deps.captureCropBase64 !== void 0) try {
+			const cropJpeg = await this.deps.captureCropBase64(frame);
+			if (cropJpeg !== null) {
+				const retry = await this.deps.runDetailSubtree({
+					deviceId,
+					cropJpeg,
+					parent,
+					steps
+				}, frame.nodeId);
+				if (retry !== null) return retry.details;
+			}
+		} catch (err) {
+			this.deps.logger.debug("detail crop-fallback call failed", {
+				tags: { deviceId },
+				meta: {
+					trackId: req.trackId,
+					stepId: req.stepId,
+					error: String(err)
+				}
+			});
+		}
+		this.warnFailThrottled(deviceId, dev, req);
+		return null;
+	}
+	warnFailThrottled(deviceId, dev, req) {
+		const now = Date.now();
+		if (now - dev.lastFailWarnAt < FAIL_WARN_THROTTLE_MS) return;
+		dev.lastFailWarnAt = now;
+		this.deps.logger.warn("runDetailSubtree produced no result (frame + crop both missed)", {
+			tags: { deviceId },
+			meta: {
+				trackId: req.trackId,
+				stepId: req.stepId,
+				reason: req.reason
+			}
+		});
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/overlay-state.ts
+function key(deviceId, trackId) {
+	return `${deviceId}:${trackId}`;
+}
+var OverlayDetailStateStore = class {
+	byTrack = /* @__PURE__ */ new Map();
+	noteFaceDetail(deviceId, trackId, faceBbox, score, capturedAt) {
+		const k = key(deviceId, trackId);
+		const prev = this.byTrack.get(k);
+		this.byTrack.set(k, {
+			...prev,
+			face: {
+				bbox: faceBbox,
+				score,
+				capturedAt
+			}
+		});
+	}
+	notePlateDetail(deviceId, trackId, plateBbox, score, text, capturedAt) {
+		const k = key(deviceId, trackId);
+		const prev = this.byTrack.get(k);
+		this.byTrack.set(k, {
+			...prev,
+			plate: {
+				bbox: plateBbox,
+				score,
+				capturedAt,
+				text
+			}
+		});
+	}
+	get(deviceId, trackId) {
+		return this.byTrack.get(key(deviceId, trackId));
+	}
+	onTrackEnded(deviceId, trackId) {
+		this.byTrack.delete(key(deviceId, trackId));
+	}
+	clearDevice(deviceId) {
+		const prefix = `${deviceId}:`;
+		for (const k of this.byTrack.keys()) if (k.startsWith(prefix)) this.byTrack.delete(k);
+	}
+	clear() {
+		this.byTrack.clear();
+	}
+};
+function toDetectionBbox(bbox) {
+	return {
+		x: bbox.x,
+		y: bbox.y,
+		width: bbox.w,
+		height: bbox.h
+	};
+}
+function buildOverlayDetections(input) {
+	const trackedBySourceId = /* @__PURE__ */ new Map();
+	for (const t of input.tracked) if (t.sourceDetectionId !== void 0) trackedBySourceId.set(t.sourceDetectionId, t);
+	const realDetailKindsByParent = /* @__PURE__ */ new Map();
+	for (const d of input.frameDetections) {
+		if (d.kind !== "detail" || d.parentId === void 0) continue;
+		const set = realDetailKindsByParent.get(d.parentId) ?? /* @__PURE__ */ new Set();
+		set.add(d.macroClass);
+		realDetailKindsByParent.set(d.parentId, set);
+	}
+	const out = [];
+	const synthesized = [];
+	for (const det of input.frameDetections) {
+		const t = det.kind === "first-level" ? trackedBySourceId.get(det.id) : void 0;
+		if (t === void 0) {
+			out.push(det);
+			continue;
+		}
+		const name = input.labelFor(t.trackId) ?? "";
+		const hasName = name.length > 0;
+		const alreadyLabeled = hasName && det.labels.some((l) => l.label === name);
+		out.push({
+			...det,
+			track: {
+				trackId: t.trackId,
+				zones: t.zones
+			},
+			labels: hasName && !alreadyLabeled ? [...det.labels, {
+				label: name,
+				score: 1
+			}] : det.labels
+		});
+		const overlay = input.overlayFor(t.trackId);
+		if (overlay === void 0) continue;
+		const realKinds = realDetailKindsByParent.get(det.id);
+		if (overlay.face !== void 0 && input.nowMs - overlay.face.capturedAt <= 2500 && overlay.face !== void 0 && realKinds?.has("face") !== true) synthesized.push({
+			id: `detail-${t.trackId}-face`,
+			kind: "detail",
+			macroClass: "face",
+			score: overlay.face.score,
+			bbox: toDetectionBbox(overlay.face.bbox),
+			parentId: det.id,
+			labels: hasName ? [{
+				label: name,
+				score: overlay.face.score
+			}] : []
+		});
+		if (overlay.plate !== void 0 && input.nowMs - overlay.plate.capturedAt <= 2500 && overlay.plate !== void 0 && realKinds?.has("plate") !== true) synthesized.push({
+			id: `detail-${t.trackId}-plate`,
+			kind: "detail",
+			macroClass: "plate",
+			score: overlay.plate.score,
+			bbox: toDetectionBbox(overlay.plate.bbox),
+			parentId: det.id,
+			labels: [{
+				label: overlay.plate.text,
+				score: overlay.plate.score
+			}]
+		});
+	}
+	return [...out, ...synthesized];
+}
+//#endregion
+//#region src/pipeline-analytics/media-capture-log.ts
+var DEFAULT_FLUSH_INTERVAL_MS = 6e4;
+var MediaCaptureLogAggregator = class {
+	flushIntervalMs;
+	byDevice = /* @__PURE__ */ new Map();
+	constructor(flushIntervalMs = DEFAULT_FLUSH_INTERVAL_MS) {
+		this.flushIntervalMs = flushIntervalMs;
+	}
+	/**
+	* Record one frame's capture counts. Returns the window aggregate (and
+	* resets the window) once `flushIntervalMs` has elapsed since the window
+	* opened; `null` while still accumulating.
+	*/
+	note(deviceId, counts, nowMs) {
+		const w = this.byDevice.get(deviceId);
+		if (w === void 0) {
+			this.byDevice.set(deviceId, {
+				sinceMs: nowMs,
+				frames: 1,
+				events: counts.events,
+				trackFrames: counts.trackFrames,
+				snapshots: counts.snapshots,
+				faceCrops: counts.faceCrops,
+				plateCrops: counts.plateCrops
+			});
+			return null;
+		}
+		w.frames += 1;
+		w.events += counts.events;
+		w.trackFrames += counts.trackFrames;
+		w.snapshots += counts.snapshots;
+		w.faceCrops += counts.faceCrops;
+		w.plateCrops += counts.plateCrops;
+		if (nowMs - w.sinceMs < this.flushIntervalMs) return null;
+		return this.drain(deviceId, w, nowMs);
+	}
+	/**
+	* Drain a device's pending window (e.g. when its last live track ends),
+	* so short activity bursts still surface an aggregate. Returns `null`
+	* when nothing is pending.
+	*/
+	flush(deviceId, nowMs) {
+		const w = this.byDevice.get(deviceId);
+		if (w === void 0) return null;
+		return this.drain(deviceId, w, nowMs);
+	}
+	drain(deviceId, w, nowMs) {
+		this.byDevice.delete(deviceId);
+		return {
+			frames: w.frames,
+			windowMs: nowMs - w.sinceMs,
+			sums: {
+				events: w.events,
+				trackFrames: w.trackFrames,
+				snapshots: w.snapshots,
+				faceCrops: w.faceCrops,
+				plateCrops: w.plateCrops
+			}
+		};
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/store/plate-store.ts
+var PLATES_COLLECTION = "pipeline-analytics:plates";
+var PLATE_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "trackId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "timestamp",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "text",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "score",
+		type: "REAL",
+		notNull: true
+	},
+	{
+		name: "mediaKey",
+		type: "TEXT"
+	},
+	{
+		name: "corrected",
+		type: "BOOLEAN",
+		notNull: true
+	},
+	{
+		name: "recognizedVehicleId",
+		type: "TEXT"
+	},
+	{
+		name: "assigned",
+		type: "BOOLEAN",
+		notNull: true
+	},
+	{
+		name: "assignedSampleId",
+		type: "TEXT"
+	},
+	{
+		name: "keyFrameMediaKey",
+		type: "TEXT"
+	},
+	{
+		name: "plateBbox",
+		type: "JSON"
+	}
+];
+var PLATE_INDEXES = [{
+	name: "idx_plates_device_ts",
+	columns: ["deviceId", "timestamp"]
+}, {
+	name: "idx_plates_track",
+	columns: ["trackId"]
+}];
+var PlateStore = class {
+	store;
+	logger;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: PLATES_COLLECTION,
+			columns: [...PLATE_COLUMNS],
+			indexes: [...PLATE_INDEXES]
+		});
+	}
+	/** Upsert one buffered plate read (keyed by `plate.id` = `plate-${trackId}`). */
+	async insert(plate) {
+		const { id, ...rest } = plate;
+		try {
+			await this.store.set.mutate({
+				collection: PLATES_COLLECTION,
+				key: id,
+				value: rest
+			});
+		} catch (err) {
+			this.logger.warn("PlateStore.insert failed", {
+				tags: { deviceId: plate.deviceId },
+				meta: {
+					plateId: id,
+					error: String(err)
+				}
+			});
+		}
+	}
+	normalizeRow(r) {
+		const data = r.data;
+		return {
+			id: r.id,
+			...data,
+			score: Number(r.data.score ?? 0),
+			corrected: Boolean(r.data.corrected),
+			assigned: Boolean(r.data.assigned),
+			mediaKey: data.mediaKey ?? void 0,
+			recognizedVehicleId: data.recognizedVehicleId ?? void 0,
+			assignedSampleId: data.assignedSampleId ?? void 0,
+			keyFrameMediaKey: data.keyFrameMediaKey ?? void 0,
+			plateBbox: data.plateBbox ?? void 0
+		};
+	}
+	/** Recent plate reads for one device (or all when deviceId omitted), newest first. */
+	async listRecentPlates(input) {
+		const where = {};
 		if (input.deviceId !== void 0) where["deviceId"] = input.deviceId;
 		return (await this.store.query.query({
 			collection: PLATES_COLLECTION,
@@ -5917,6 +7530,76 @@ var PlateStore = class {
 			} });
 		}
 	}
+	/** Flip `assigned` to true and record the vehicle + enrolled sample. */
+	async markAssigned(plateId, vehicleId, sampleId) {
+		const data = {
+			assigned: true,
+			recognizedVehicleId: vehicleId
+		};
+		if (sampleId !== void 0) data["assignedSampleId"] = sampleId;
+		try {
+			await this.store.update.mutate({
+				collection: PLATES_COLLECTION,
+				id: plateId,
+				data
+			});
+		} catch (err) {
+			this.logger.warn("PlateStore.markAssigned failed", { meta: {
+				plateId,
+				error: String(err)
+			} });
+		}
+	}
+	/** Clear the assignment (assigned=false, null recognizedVehicleId + assignedSampleId). */
+	async clearAssignment(plateId) {
+		try {
+			await this.store.update.mutate({
+				collection: PLATES_COLLECTION,
+				id: plateId,
+				data: {
+					assigned: false,
+					recognizedVehicleId: null,
+					assignedSampleId: null
+				}
+			});
+		} catch (err) {
+			this.logger.warn("PlateStore.clearAssignment failed", { meta: {
+				plateId,
+				error: String(err)
+			} });
+		}
+	}
+	/**
+	* `TrackScopedStore` contract for the retention cascade: delete the buffered
+	* plate rows of the given tracks that are NOT assigned. Mirrors
+	* `FaceStore.deleteByTracks` — ENROLLED (`assigned`) reads SURVIVE retention.
+	* Per-track ISOLATED + best-effort per row — one bad track or row never aborts
+	* the batch. (Crop media of these rows is removed by `MediaStore`.)
+	*/
+	async deleteByTracks(trackIds) {
+		for (const trackId of trackIds) try {
+			const eligible = (await this.store.query.query({
+				collection: PLATES_COLLECTION,
+				filter: { where: { trackId } }
+			})).filter((r) => !r.data.assigned);
+			for (const row of eligible) try {
+				await this.store.delete.mutate({
+					collection: PLATES_COLLECTION,
+					key: row.id
+				});
+			} catch (err) {
+				this.logger.warn("PlateStore.deleteByTracks delete failed", { meta: {
+					plateId: row.id,
+					error: String(err)
+				} });
+			}
+		} catch (err) {
+			this.logger.warn("PlateStore.deleteByTracks query failed", { meta: {
+				trackId,
+				error: String(err)
+			} });
+		}
+	}
 	/**
 	* Retention across ALL devices: delete reads older than `cutoffMs` AND any
 	* beyond the newest `maxPerDevice` per device. Corrected reads are exempt
@@ -5933,7 +7616,7 @@ var PlateStore = class {
 		const byDevice = /* @__PURE__ */ new Map();
 		for (const r of rows) {
 			const data = r.data;
-			if (data.corrected) continue;
+			if (data.corrected || data.assigned) continue;
 			const deviceId = Number(data.deviceId ?? -1);
 			const list = byDevice.get(deviceId) ?? [];
 			list.push({
@@ -5963,10 +7646,320 @@ var PlateStore = class {
 				error: String(err)
 			} });
 		}
-		return deleted;
+		return deleted;
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/store/vehicle-store.ts
+/**
+* VehicleStore — per-vehicle identity registry for license-plate recognition.
+*
+* Two SQL-backed collections (parallel to IdentityStore, text-not-embedding):
+*   - pipeline-analytics:vehicles         — named vehicle records
+*   - pipeline-analytics:vehicle-samples  — enrolled plate reads (text + score)
+*
+* A plate is self-labeling (the OCR text IS the key), so a sample carries
+* `text` + `score` instead of an embedding + modelId + dim — no model-version
+* gate is needed. deleteVehicle cascades: removes all sample rows first.
+*/
+var VEHICLES_COLLECTION = "pipeline-analytics:vehicles";
+var VEHICLE_SAMPLES_COLLECTION = "pipeline-analytics:vehicle-samples";
+var VEHICLE_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "createdAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "sampleCount",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "coverMediaKey",
+		type: "TEXT"
+	}
+];
+var SAMPLE_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "vehicleId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "text",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "score",
+		type: "REAL",
+		notNull: true
+	},
+	{
+		name: "sourcePlateId",
+		type: "TEXT"
+	},
+	{
+		name: "mediaKey",
+		type: "TEXT"
+	},
+	{
+		name: "deviceId",
+		type: "INTEGER"
+	},
+	{
+		name: "addedAt",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+var VehicleStore = class {
+	store;
+	logger;
+	constructor(deps) {
+		this.store = deps.store;
+		this.logger = deps.logger;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: VEHICLES_COLLECTION,
+			columns: [...VEHICLE_COLUMNS],
+			indexes: []
+		});
+		await store.declareCollection.mutate({
+			collection: VEHICLE_SAMPLES_COLLECTION,
+			columns: [...SAMPLE_COLUMNS],
+			indexes: [{
+				name: "idx_vehicle_sample",
+				columns: ["vehicleId"]
+			}]
+		});
+	}
+	async createVehicle(input) {
+		const now = Date.now();
+		const vehicle = {
+			id: (0, node_crypto.randomUUID)(),
+			name: input.name,
+			createdAt: now,
+			updatedAt: now,
+			sampleCount: 0
+		};
+		const { id, ...rest } = vehicle;
+		await this.store.insert.mutate({
+			collection: VEHICLES_COLLECTION,
+			record: {
+				id,
+				data: rest
+			}
+		});
+		return vehicle;
+	}
+	async renameVehicle(id, name) {
+		await this.store.update.mutate({
+			collection: VEHICLES_COLLECTION,
+			id,
+			data: {
+				name,
+				updatedAt: Date.now()
+			}
+		});
+	}
+	async deleteVehicle(id) {
+		const samples = await this.store.query.query({
+			collection: VEHICLE_SAMPLES_COLLECTION,
+			filter: { where: { vehicleId: id } }
+		});
+		for (const s of samples) try {
+			await this.store.delete.mutate({
+				collection: VEHICLE_SAMPLES_COLLECTION,
+				key: s.id
+			});
+		} catch (err) {
+			this.logger.warn("deleteVehicle sample delete failed", { meta: {
+				vehicleId: id,
+				sampleId: s.id,
+				error: String(err)
+			} });
+		}
+		await this.store.delete.mutate({
+			collection: VEHICLES_COLLECTION,
+			key: id
+		});
+	}
+	async listVehicles() {
+		return (await this.store.query.query({
+			collection: VEHICLES_COLLECTION,
+			filter: { orderBy: {
+				field: "createdAt",
+				direction: "asc"
+			} }
+		})).map((r) => {
+			const data = r.data;
+			return {
+				id: r.id,
+				...data,
+				coverMediaKey: data.coverMediaKey ?? void 0
+			};
+		});
+	}
+	async addSample(input) {
+		const sample = {
+			id: (0, node_crypto.randomUUID)(),
+			vehicleId: input.vehicleId,
+			text: input.text,
+			score: input.score,
+			...input.sourcePlateId !== void 0 ? { sourcePlateId: input.sourcePlateId } : {},
+			...input.mediaKey !== void 0 ? { mediaKey: input.mediaKey } : {},
+			...input.deviceId !== void 0 ? { deviceId: input.deviceId } : {},
+			addedAt: Date.now()
+		};
+		const { id, ...rest } = sample;
+		await this.store.insert.mutate({
+			collection: VEHICLE_SAMPLES_COLLECTION,
+			record: {
+				id,
+				data: rest
+			}
+		});
+		const vehicle = (await this.listVehicles()).find((v) => v.id === input.vehicleId);
+		if (vehicle) {
+			const patch = {
+				sampleCount: vehicle.sampleCount + 1,
+				updatedAt: Date.now()
+			};
+			if (vehicle.coverMediaKey == null && input.mediaKey !== void 0) patch["coverMediaKey"] = input.mediaKey;
+			await this.store.update.mutate({
+				collection: VEHICLES_COLLECTION,
+				id: input.vehicleId,
+				data: patch
+			});
+		}
+		return sample;
+	}
+	async listSamples(vehicleId) {
+		return (await this.store.query.query({
+			collection: VEHICLE_SAMPLES_COLLECTION,
+			filter: {
+				where: { vehicleId },
+				orderBy: {
+					field: "addedAt",
+					direction: "asc"
+				}
+			}
+		})).map((r) => {
+			const d = r.data;
+			return {
+				id: r.id,
+				text: String(d.text ?? ""),
+				score: Number(d.score ?? 0),
+				addedAt: Number(d.addedAt ?? 0),
+				...d.mediaKey != null ? { mediaKey: d.mediaKey } : {},
+				...d.deviceId != null ? { deviceId: d.deviceId } : {}
+			};
+		});
+	}
+	async removeSample(vehicleId, sampleId) {
+		await this.store.delete.mutate({
+			collection: VEHICLE_SAMPLES_COLLECTION,
+			key: sampleId
+		});
+		const vehicle = (await this.listVehicles()).find((v) => v.id === vehicleId);
+		if (vehicle) await this.store.update.mutate({
+			collection: VEHICLES_COLLECTION,
+			id: vehicleId,
+			data: {
+				sampleCount: Math.max(0, vehicle.sampleCount - 1),
+				updatedAt: Date.now()
+			}
+		});
+	}
+	async loadGallery() {
+		const rows = await this.store.query.query({
+			collection: VEHICLE_SAMPLES_COLLECTION,
+			filter: {}
+		});
+		const gallery = [];
+		for (const r of rows) {
+			const d = r.data;
+			if (typeof d.text !== "string" || typeof d.vehicleId !== "string") continue;
+			gallery.push({
+				vehicleId: d.vehicleId,
+				text: d.text
+			});
+		}
+		return gallery;
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/pipeline/plate-matcher.ts
+/**
+* plate-matcher — name a plate read against the vehicle gallery by text vicinity.
+*
+* Parallel to face-matcher's `matchEmbedding`, but a plate is self-labeling:
+* distance is `plateDistance` (OCR-confusion-folded Levenshtein), not cosine.
+* There is no model-version gate (text has no embedding drift) and no ambiguity
+* `margin` (Levenshtein has no comparable normalized gap) — a tie is resolved
+* conservatively to NO match. The read's `score` weights how far it may match:
+* a high-confidence read (`score >= lowScoreFloor`) may match at `maxDistance`;
+* a low-confidence read is held to `lowScoreMaxDistance` (exact fold only).
+* "Prefer unassigned over wrong vehicle."
+*/
+/** Calibration placeholders — re-tune against real OCR score distributions. */
+var DEFAULT_PLATE_MATCH_OPTS = {
+	maxDistance: 1,
+	lowScoreFloor: .5,
+	lowScoreMaxDistance: 0
+};
+function matchPlateText(probe, gallery, opts) {
+	const allowed = probe.score >= opts.lowScoreFloor ? opts.maxDistance : opts.lowScoreMaxDistance;
+	const bestByVehicle = /* @__PURE__ */ new Map();
+	for (const s of gallery) {
+		const dist = plateDistance(probe.text, s.text);
+		const prev = bestByVehicle.get(s.vehicleId);
+		if (prev === void 0 || dist < prev) bestByVehicle.set(s.vehicleId, dist);
+	}
+	if (bestByVehicle.size === 0) return null;
+	let bestId = null;
+	let bestDist = Infinity;
+	let tie = false;
+	for (const [vehicleId, dist] of bestByVehicle) {
+		if (dist > allowed) continue;
+		if (dist < bestDist) {
+			bestDist = dist;
+			bestId = vehicleId;
+			tie = false;
+		} else if (dist === bestDist) tie = true;
+	}
+	if (bestId === null || tie) return null;
+	return {
+		vehicleId: bestId,
+		distance: bestDist
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/plate-recognizer.ts
 /**
 * PlateRecognizer — buffers the best license-plate OCR read per vehicle track
@@ -5978,8 +7971,38 @@ var PlateStore = class {
 var PlateRecognizer = class {
 	deps;
 	bestPlate = /* @__PURE__ */ new Map();
+	gallery = [];
+	nameById = /* @__PURE__ */ new Map();
+	matchOpts;
 	constructor(deps) {
 		this.deps = deps;
+		this.matchOpts = deps.matchOpts ?? DEFAULT_PLATE_MATCH_OPTS;
+	}
+	/** Reload the in-memory vehicle gallery + name map (after a gallery mutation). */
+	async refreshGallery() {
+		try {
+			this.gallery = await this.deps.vehicleStore.loadGallery();
+			this.nameById = new Map((await this.deps.vehicleStore.listVehicles()).map((v) => [v.id, v.name]));
+		} catch (err) {
+			this.deps.logger.warn("PlateRecognizer.refreshGallery failed", { meta: { error: String(err) } });
+		}
+	}
+	matchVehicle(text, score) {
+		const m = matchPlateText({
+			text: normalizePlate(text),
+			score
+		}, this.gallery, this.matchOpts);
+		if (m === null) return null;
+		const name = this.nameById.get(m.vehicleId);
+		return name !== void 0 ? {
+			vehicleId: m.vehicleId,
+			name
+		} : null;
+	}
+	/** Live label for a plate read: the recognized vehicle NAME when matched, else
+	*  the raw OCR text (today's behavior). Used by the ingest label path. */
+	resolveLabel(text, score) {
+		return this.matchVehicle(text, score)?.name ?? text;
 	}
 	async processFrame(input) {
 		const minConfidence = input.minConfidence ?? 0;
@@ -6035,6 +8058,8 @@ var PlateRecognizer = class {
 				}
 			});
 		}
+		const match = this.matchVehicle(held.text, held.score);
+		const keyFrameMediaKey = this.deps.getKeyFrameMediaKey?.(trackId);
 		try {
 			await this.deps.plateStore.insert({
 				id: plateId,
@@ -6044,7 +8069,16 @@ var PlateRecognizer = class {
 				text: normalizePlate(held.text),
 				score: held.score,
 				...mediaKey !== void 0 ? { mediaKey } : {},
-				corrected: false
+				corrected: false,
+				assigned: false,
+				...match !== null ? { recognizedVehicleId: match.vehicleId } : {},
+				...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {},
+				plateBbox: held.bbox
+			});
+			this.deps.emitPlateGalleryChanged?.({
+				deviceId,
+				plateId,
+				kind: "buffered"
 			});
 			this.deps.logger.info("plate: buffered to gallery", {
 				tags: {
@@ -6055,7 +8089,8 @@ var PlateRecognizer = class {
 					plateId,
 					text: normalizePlate(held.text),
 					score: held.score,
-					hasCrop: mediaKey !== void 0
+					hasCrop: mediaKey !== void 0,
+					recognizedVehicleId: match?.vehicleId ?? null
 				}
 			});
 		} catch (err) {
@@ -6399,6 +8434,12 @@ function createEventMediaHandler(deps) {
 * surface to turn the refinement pipeline on/off for a camera.
 */
 var TTL_SWEEP_INTERVAL_MS = 5e3;
+/** Padding applied to the parent bbox for the `cropJpeg` retry fallback when a
+*  scheduled detail call's frameHandle lease is already gone. */
+var DETAIL_FALLBACK_CROP_PADDING = .15;
+/** How long the active CLIP model id (from the embedding-encoder) is cached
+*  before re-reading. */
+var CLIP_MODEL_ID_CACHE_TTL_MS = 6e4;
 var SETTINGS_CACHE_TTL_MS = 5e3;
 /** §5 best-frame: a track's `thumbnail` is overwritten only when the current
 *  detection confidence beats the held best by at least this margin (hysteresis
@@ -6426,11 +8467,23 @@ var POST_PROCESSING_NODE_DEFAULT = "hub";
 *  Absent / empty / non-string all fall back to the hub default — the exact
 *  narrowing the old raw read applied inline. */
 var PostProcessingNodeIdSchema = require_dist.string().min(1);
+var EmbeddingEnabledSchema = require_dist.boolean();
 var SILENCE_FLOOR_DBFS = -55;
 var RETENTION_SWEEP_INTERVAL_MS = 5 * 6e4;
+/** Throttle for the "overlay synthesis failed" warn — one line / minute / device. */
+var OVERLAY_SYNTHESIS_WARN_THROTTLE_MS = 6e4;
 var AUDIO_EVENT_HEARTBEAT_MS = 5e3;
 var MOTION_EVENT_HEARTBEAT_MS = 5e3;
 /**
+* Decode a base64 little-endian float32 vector (the `DetailResult.embedding`
+* wire encoding produced by `runDetailSubtree`) back into a plain number[].
+*/
+function decodeEmbeddingBase64(base64) {
+	const bytes = Buffer.from(base64, "base64");
+	const view = new Float32Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 4));
+	return Array.from(view);
+}
+/**
 * Re-home the global analytics sections into the per-device `Analytics`
 * top-tab. Every section defaults to the `Analytics` tab (so the
 * device-manager aggregator groups them) AND is marked
@@ -6478,8 +8531,21 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	faceStore = null;
 	faceRecognizer = null;
 	plateStore = null;
+	vehicleStore = null;
 	plateRecognizer = null;
 	objectEmbeddingStore = null;
+	/** Two-plane detail scheduler/dispatcher: per-track on-demand face/clip/
+	*  classifier/plate enrichment via `pipelineRunner.runDetailSubtree`. Replaces
+	*  the per-frame child consumption the executor no longer emits. */
+	detailDispatcher = null;
+	/** Per-track detail geometry for the live-overlay synthesis (two-plane). */
+	overlayState = new OverlayDetailStateStore();
+	/** Throttle state for the "overlay synthesis failed" warn, one per device. */
+	overlaySynthesisWarnAt = /* @__PURE__ */ new Map();
+	/** Active CLIP image-embedding model id (== the text encoder's), TTL-cached.
+	*  Stamped on object-embedding rows from the detail plane so semantic search's
+	*  same-model gate keeps matching. */
+	clipModelIdCache = null;
 	/** Frame-based event/track media (crop + boxed full-frame) from the
 	*  detection-pipeline DECODED frame — the ONLY image source (never the
 	*  snapshot cap). Null when shm frame access is unavailable. */
@@ -6487,6 +8553,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	/** Shared shm-ring reader cache for resolving `frameHandle`s to pixels.
 	*  Owned here so segments stay open across frames; closed once on shutdown. */
 	frameReaders = null;
+	/** Object/face embedding dispatcher — migrated from the retired
+	*  enrichment-engine addon. Runs ONLY on the post-processing node; on each
+	*  detection it resolves the frame, crops the ROI, and calls the
+	*  embedding-encoder cap (which persists the vector for the search/face
+	*  path). Null on non-post-processing nodes or when disabled. */
+	embeddingDispatcher = null;
 	bindingCache = null;
 	zoneAnalytics = null;
 	audioMetrics = null;
@@ -6537,6 +8609,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		hysteresis: BEST_FRAME_HYSTERESIS,
 		minGapMs: BEST_FRAME_MIN_GAP_MS
 	});
+	/** Windowed per-device aggregation of the "media capture" diagnostic — the
+	*  per-capture line is debug; a 60s per-counter SUM lands at info (~1
+	*  line/min/device instead of one per §5 cadence tick, see media-capture-log.ts). */
+	mediaCaptureLog = new MediaCaptureLogAggregator();
 	/** Best (highest-confidence) CLIP-object detection per track — drives ONE
 	*  tight object-crop capture whose media key is written onto the embedding
 	*  row (so a semantic-search hit's thumbnail IS the embedded crop). Shares the
@@ -6548,6 +8624,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*  at track end so a face row links to the SAME single key frame. Cleared on
 	*  track end. */
 	keyFrameKeyByTrackId = /* @__PURE__ */ new Map();
+	/** Per-track update-gate memory for `PipelineAnalyticsTrackLifecycle`
+	*  `phase:'update'` — the last-emitted best (confidence / label / crop
+	*  area) + emit time, so a material improvement is measured against the
+	*  last emit and debounced. Seeded at `start`, dropped at `end`. */
+	trackLifecycleUpdateMem = /* @__PURE__ */ new Map();
 	/** The shared crop extractor (native-res first, detection-frame fallback),
 	*  captured in the constructor so `processFrame` can crop object thumbnails in
 	*  the same live-frame window as the face/plate/event-media captures. The
@@ -6563,6 +8644,15 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		if (!this._postProcessingNodeState) this._postProcessingNodeState = this.state("postProcessingNodeId", PostProcessingNodeIdSchema, POST_PROCESSING_NODE_DEFAULT);
 		return this._postProcessingNodeState;
 	}
+	/** Master toggle for the migrated object/face EmbeddingDispatcher (default
+	*  ON — the enrichment-engine default was `embeddingEnabled:true`). Read at
+	*  init; a change takes effect on addon restart (same convention as
+	*  `postProcessingNodeId`). */
+	_embeddingEnabledState = null;
+	get embeddingEnabledState() {
+		if (!this._embeddingEnabledState) this._embeddingEnabledState = this.state("embeddingEnabled", EmbeddingEnabledSchema, true);
+		return this._embeddingEnabledState;
+	}
 	/** GLOBAL face-recognition master switch (`enabled` key). Schema +
 	*  fallback derived from the face-settings source of truth. */
 	_faceGlobalEnabledState = null;
@@ -6582,12 +8672,13 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		await IdentityStore.declare(api.settingsStore);
 		await FaceStore.declare(api.settingsStore);
 		await PlateStore.declare(api.settingsStore);
+		await VehicleStore.declare(api.settingsStore);
 		await ObjectEmbeddingStore.declare(api.settingsStore);
 		const logger = this.ctx.logger;
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-Cg_cGqs0.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-Cvhwrf43.js"));
 			storage = new FilesystemStorageProvider(mediaRoot);
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -6603,7 +8694,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		this.eventStore = new EventStore({
 			store: api.settingsStore,
-			logger: logger.child("EventStore")
+			logger: logger.child("EventStore"),
+			media: this.mediaStore
 		});
 		this.identityStore = new IdentityStore({
 			store: api.settingsStore,
@@ -6617,6 +8709,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			store: api.settingsStore,
 			logger: logger.child("PlateStore")
 		});
+		this.vehicleStore = new VehicleStore({
+			store: api.settingsStore,
+			logger: logger.child("VehicleStore")
+		});
 		const rawNodeId = this.ctx.kernel.localNodeId ?? this.ctx.id;
 		const ownNodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] : rawNodeId;
 		{
@@ -6685,7 +8781,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				return null;
 			}
 		};
-		const resolveFrameShared = createSharedFrameResolver((frameHandle) => require_resolve_frame.resolveFrame(frameHandle, {
+		const resolveFrameShared = createSharedFrameResolver((frameHandle) => resolveFrame(frameHandle, {
 			ownNodeId: ownNodeIdForFaces,
 			readers: frameReadersForFaces,
 			getRemoteFrame
@@ -6705,7 +8801,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			bumpCropMetric(false);
 			const decoded = await resolveFrameShared(frameHandle);
 			if (!decoded || decoded.format !== "rgb") return null;
-			const { crop } = await require_resolve_frame.extractCrop(Buffer.isBuffer(decoded.data) ? decoded.data : Buffer.from(decoded.data), decoded.width, decoded.height, paddedNorm);
+			const { crop } = await extractCrop(Buffer.isBuffer(decoded.data) ? decoded.data : Buffer.from(decoded.data), decoded.width, decoded.height, paddedNorm);
 			return crop;
 		};
 		this.captureCrop = captureCrop;
@@ -6726,19 +8822,43 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				}, trackId);
 			},
 			getKeyFrameMediaKey: (trackId) => this.keyFrameKeyByTrackId.get(trackId),
+			emitFaceGalleryChanged: (payload) => this.emitFaceGalleryChanged(payload),
 			logger: logger.child("FaceRecognizer")
 		});
 		this.faceRecognizer.refreshGallery();
 		this.plateRecognizer = new PlateRecognizer({
 			plateStore: this.plateStore,
+			vehicleStore: this.vehicleStore,
 			mediaStore: this.mediaStore,
 			captureCrop,
+			getKeyFrameMediaKey: (trackId) => this.keyFrameKeyByTrackId.get(trackId),
+			emitPlateGalleryChanged: (payload) => this.emitPlateGalleryChanged(payload),
 			logger: logger.child("PlateRecognizer")
 		});
+		this.plateRecognizer.refreshGallery();
 		this.objectEmbeddingStore = new ObjectEmbeddingStore({
 			store: api.settingsStore,
 			logger: logger.child("ObjectEmbeddingStore")
 		});
+		const runnerApi = api.pipelineRunner;
+		this.detailDispatcher = new TrackDetailDispatcher({
+			logger: logger.child("DetailDispatcher"),
+			runDetailSubtree: async (input, nodeId) => {
+				if (!runnerApi?.runDetailSubtree) return null;
+				if (nodeId !== void 0) return runnerApi.runDetailSubtree.mutate(input, require_dist.nodePin(nodeId));
+				return runnerApi.runDetailSubtree.mutate(input);
+			},
+			routeResults: (deviceId, trackId, details, frame) => this.routeDetailResults(deviceId, trackId, details, frame),
+			captureCropBase64: async (frame) => {
+				if (frame.frameHandle === void 0 || !this.captureCrop) return null;
+				const buf = await this.captureCrop(frame.frameHandle, { ...frame.bbox }, frame.frameWidth, frame.frameHeight, DETAIL_FALLBACK_CROP_PADDING);
+				return buf ? buf.toString("base64") : null;
+			},
+			hasTrackLabel: (trackId) => {
+				const label = this.trackStore?.getActiveByTrack(trackId)?.label;
+				return label !== void 0 && label.length > 0;
+			}
+		});
 		this.bindingCache = new BindingCache({
 			api,
 			logger: logger.child("BindingCache")
@@ -6804,12 +8924,37 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				const data = ev.data;
 				this.handleNativeDetection(data);
 			});
+			if (await this.embeddingEnabledState.get()) {
+				const encoderClient = {
+					encode: (crop, width, height) => this.ctx.api.embeddingEncoder.encode.query({
+						crop: new Uint8Array(crop),
+						width,
+						height
+					}),
+					getInfo: () => this.ctx.api.embeddingEncoder.getInfo.query()
+				};
+				this.embeddingDispatcher = new EmbeddingDispatcher({
+					config: {
+						...DEFAULT_EMBEDDING_CONFIG,
+						enabled: true
+					},
+					encoder: encoderClient,
+					eventBus: this.ctx.eventBus,
+					logger: logger.child("EmbeddingDispatcher"),
+					ownNodeId,
+					readers: frameReadersForFaces,
+					getRemoteFrame
+				});
+				await this.embeddingDispatcher.start();
+			} else logger.info("EmbeddingDispatcher disabled via settings (embeddingEnabled=false)");
 		}
 		this.unsubBindings = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.DeviceBindingsChanged }, (ev) => {
 			const data = ev.data;
 			this.bindingCache?.onBindingsChanged(data);
 			if (data.capName === "pipeline-analytics" && data.reason === "wrapper-deactivated") {
 				this.trackStore?.clearDevice(data.deviceId);
+				this.overlayState.clearDevice(data.deviceId);
+				this.overlaySynthesisWarnAt.delete(data.deviceId);
 				this.forgetDeviceProcessors(data.deviceId);
 				this.levelStateByDevice.delete(data.deviceId);
 				this.settingsCacheByDevice.delete(data.deviceId);
@@ -6822,6 +8967,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.unsubDeviceUnreg = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.DeviceUnregistered }, (ev) => {
 			const { deviceId } = ev.data;
 			this.trackStore?.clearDevice(deviceId);
+			this.overlayState.clearDevice(deviceId);
+			this.overlaySynthesisWarnAt.delete(deviceId);
 			this.forgetDeviceProcessors(deviceId);
 			this.levelStateByDevice.delete(deviceId);
 			this.settingsCacheByDevice.delete(deviceId);
@@ -6839,6 +8986,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		}, TTL_SWEEP_INTERVAL_MS);
 		this.retentionSweepTimer = setInterval(() => {
 			this.sweepRetention();
+			this.runTrackRetentionSweep();
 		}, RETENTION_SWEEP_INTERVAL_MS);
 		this.ctx.logger.info("pipeline-analytics subscribers installed");
 		const widgetsProvider = { listWidgets: async () => [
@@ -7079,11 +9227,19 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			mediaStore: this.mediaStore,
 			trackStore: this.trackStore,
 			eventStore: this.eventStore,
-			refreshGallery: () => this.faceRecognizer?.refreshGallery()
+			refreshGallery: () => this.faceRecognizer?.refreshGallery(),
+			emitFaceGalleryChanged: (payload) => this.emitFaceGalleryChanged(payload)
 		});
 		const plateGallery = new PlateGalleryProvider({
 			plateStore: this.plateStore,
-			mediaStore: this.mediaStore
+			vehicleStore: this.vehicleStore,
+			mediaStore: this.mediaStore,
+			trackStore: this.trackStore,
+			eventStore: this.eventStore,
+			refreshGallery: () => {
+				this.plateRecognizer?.refreshGallery();
+			},
+			emitPlateGalleryChanged: (payload) => this.emitPlateGalleryChanged(payload)
 		});
 		return [
 			{
@@ -7132,6 +9288,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.unsubBindings = null;
 		this.unsubDeviceUnreg?.();
 		this.unsubDeviceUnreg = null;
+		await this.embeddingDispatcher?.stop();
+		this.embeddingDispatcher = null;
 		for (const id of this.proxies.keys()) this.releaseProxy(id);
 		if (this.ttlSweepTimer) {
 			clearInterval(this.ttlSweepTimer);
@@ -7143,10 +9301,15 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		}
 		this.zoneAnalytics?.destroy();
 		this.audioMetrics?.destroy();
+		this.detailDispatcher?.dispose();
+		this.detailDispatcher = null;
+		this.overlayState.clear();
+		this.overlaySynthesisWarnAt.clear();
 		this.processors.clear();
 		this.lastActiveTrackIds.clear();
 		this.dropoutSkipsByKey.clear();
 		this.bestFrameTracker.clear();
+		this.trackLifecycleUpdateMem.clear();
 		this.objectEmbeddingBestSelector.clear();
 		this.levelStateByDevice.clear();
 		this.settingsCacheByDevice.clear();
@@ -7167,7 +9330,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	async handleInferenceResult(data) {
 		if (this.shuttingDown) return;
 		const { deviceId, frame } = data;
-		await this.processFrame(deviceId, frame, "pipeline", data.frameHandle);
+		await this.processFrame(deviceId, frame, "pipeline", data.frameHandle, data.detailSteps);
 	}
 	/**
 	* Run one detection frame through the analysis layers for a given
@@ -7177,7 +9340,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* tracking/zone/event state never crosses between sources. Emits the
 	* SAME canonical events, distinguished only by `source`.
 	*/
-	async processFrame(deviceId, frame, source, frameHandle) {
+	async processFrame(deviceId, frame, source, frameHandle, detailSteps) {
 		if (this.shuttingDown) return;
 		if (!await this.bindingCache.isActive(deviceId)) return;
 		const key = this.procKey(deviceId, source);
@@ -7278,6 +9441,24 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						className: t.className
 					}
 				});
+				const startPayload = buildTrackLifecyclePayload({
+					deviceId,
+					trackId: id,
+					phase: "start",
+					classes: [t.className],
+					bestClassName: t.className,
+					bestConfidence: t.confidence,
+					firstSeen: result.timestamp,
+					lastSeen: result.timestamp,
+					...t.label !== void 0 ? { label: t.label } : {}
+				});
+				this.emitTrackLifecycle(startPayload, result.timestamp);
+				this.trackLifecycleUpdateMem.set(id, {
+					lastConfidence: t.confidence,
+					lastEmitAt: result.timestamp,
+					...t.label !== void 0 ? { lastLabel: t.label } : {},
+					lastBboxArea: t.bbox.w * t.bbox.h
+				});
 			}
 		}
 		let lostTrackCount = 0;
@@ -7289,6 +9470,26 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			} });
 		}
 		this.lastActiveTrackIds.set(key, currentTrackIds);
+		if (this.detailDispatcher && detailSteps && detailSteps.length > 0) {
+			const dispatcher = this.detailDispatcher;
+			const steps = detailSteps;
+			for (const t of result.tracked) {
+				const detailFrame = {
+					bbox: { ...t.bbox },
+					frameWidth: result.frameWidth,
+					frameHeight: result.frameHeight,
+					className: t.className,
+					confidence: t.confidence,
+					timestamp: result.timestamp,
+					...frameHandle !== void 0 ? {
+						frameHandle,
+						nodeId: frameHandle.nodeId
+					} : {}
+				};
+				if (prevIds.has(t.trackId)) dispatcher.onFrame(deviceId, t.trackId, steps, detailFrame, result.timestamp);
+				else dispatcher.onTrackStarted(deviceId, t.trackId, t.className, steps, detailFrame, result.timestamp);
+			}
+		}
 		if (newTrackCount > 0 || lostTrackCount > 0 || result.objectEvents.length > 0) {
 			const byState = {};
 			for (const t of result.tracked) byState[t.state] = (byState[t.state] ?? 0) + 1;
@@ -7321,7 +9522,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		const mediaSettings = await this.resolveDeviceMediaSettings(deviceId);
 		if (this.eventMediaDispatcher && frameHandle) {
 			const childCropsByEvent = buildEventChildCrops(result.objectEvents, frame.detections);
-			const eventTargets = result.objectEvents.filter((e) => e.bbox).map((e) => {
+			const eventTargets = result.objectEvents.filter((e) => e.bbox !== void 0 && e.bbox.w > 0 && e.bbox.h > 0).map((e) => {
 				const childCrops = childCropsByEvent.get(e.id);
 				return {
 					eventId: e.id,
@@ -7337,15 +9538,25 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			let plateCrops = 0;
 			for (const crops of childCropsByEvent.values()) for (const c of crops) if (c.kind === "faceCrop") faceCrops += 1;
 			else plateCrops += 1;
-			const snapshotTargets = this.buildSnapshotTargets(result.tracked, result.timestamp, mediaSettings);
+			const snapshotTargets = this.buildSnapshotTargets(deviceId, result.tracked, result.timestamp, mediaSettings);
 			if (eventTargets.length > 0 || firstFrameTargets.length > 0 || snapshotTargets.length > 0) {
-				log.info("media capture", { meta: {
-					source,
+				const captureCounts = {
 					events: eventTargets.length,
 					trackFrames: firstFrameTargets.length,
 					snapshots: snapshotTargets.length,
 					faceCrops,
 					plateCrops
+				};
+				log.debug("media capture", { meta: {
+					source,
+					...captureCounts
+				} });
+				const captureAgg = this.mediaCaptureLog.note(deviceId, captureCounts, Date.now());
+				if (captureAgg !== null) log.info("media capture (window)", { meta: {
+					source,
+					windowSec: Math.round(captureAgg.windowMs / 1e3),
+					frames: captureAgg.frames,
+					...captureAgg.sums
 				} });
 				this.eventMediaDispatcher.captureForFrame({
 					deviceId,
@@ -7408,6 +9619,26 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				zones: e.zones ?? []
 			}
 		});
+		let overlayDetections;
+		try {
+			overlayDetections = buildOverlayDetections({
+				frameDetections: frame.detections,
+				tracked: result.tracked,
+				overlayFor: (trackId) => this.overlayState.get(deviceId, trackId),
+				labelFor: (trackId) => this.trackStore?.getActiveByTrack(trackId)?.label,
+				nowMs: Date.now()
+			});
+		} catch (err) {
+			const now = Date.now();
+			if (now - (this.overlaySynthesisWarnAt.get(deviceId) ?? 0) >= OVERLAY_SYNTHESIS_WARN_THROTTLE_MS) {
+				this.overlaySynthesisWarnAt.set(deviceId, now);
+				this.ctx.logger.warn("overlay synthesis failed — emitting unenriched frame detections", {
+					tags: { deviceId },
+					meta: { error: String(err) }
+				});
+			}
+			overlayDetections = frame.detections;
+		}
 		this.ctx.eventBus.emit({
 			id: `pa-${(0, node_crypto.randomUUID)()}`,
 			timestamp: new Date(result.timestamp),
@@ -7422,7 +9653,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				timestamp: result.timestamp,
 				frameWidth: result.frameWidth,
 				frameHeight: result.frameHeight,
-				detections: result.tracked
+				detections: overlayDetections
 			}
 		});
 	}
@@ -7500,6 +9731,158 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		return settings;
 	}
 	/**
+	* Route one track's `runDetailSubtree` results (two-plane detail dispatch)
+	* into the EXISTING per-track consumers, discriminated by payload SHAPE:
+	*  • embedding + alignedCropJpeg → FACE (arcface): the FaceRecognizer's
+	*    candidate/best-face/gallery/keyFrame path (input source cut-over);
+	*  • embedding only → CLIP object embedding → the object-embedding store
+	*    (semantic search);
+	*  • label only → classifier answer / plate OCR text → the track's
+	*    enrichment label the notifier/UI already read.
+	* Best-effort (D8): a per-detail failure is logged and never propagated.
+	*/
+	async routeDetailResults(deviceId, trackId, details, frame) {
+		for (const d of details) try {
+			const isFaceDetail = d.className === "face";
+			if (isFaceDetail && d.bbox !== void 0) this.overlayState.noteFaceDetail(deviceId, trackId, {
+				x: d.bbox.x,
+				y: d.bbox.y,
+				w: d.bbox.w,
+				h: d.bbox.h
+			}, d.score, frame.timestamp);
+			if (isFaceDetail && d.embedding !== void 0) await this.routeFaceDetail(deviceId, trackId, d, frame);
+			else if (d.embedding !== void 0) await this.routeClipDetail(deviceId, trackId, d, frame.timestamp);
+			else if (d.label !== void 0 && d.label.length > 0) {
+				if (d.className === "plate" && d.bbox !== void 0) this.overlayState.notePlateDetail(deviceId, trackId, {
+					x: d.bbox.x,
+					y: d.bbox.y,
+					w: d.bbox.w,
+					h: d.bbox.h
+				}, d.score, d.label, frame.timestamp);
+				const label = d.className === "plate" ? this.plateRecognizer?.resolveLabel(d.label, d.score) ?? d.label : d.label;
+				await this.applyTrackEnrichmentLabel(deviceId, trackId, label);
+			}
+		} catch (err) {
+			this.ctx.logger.warn("detail result route failed", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					stepId: d.stepId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+	/** Face-embedding detail → the FaceRecognizer (same gate + logic as the
+	*  former per-frame face path; only the input source moved). */
+	async routeFaceDetail(deviceId, trackId, detail, frame) {
+		if (!this.faceRecognizer || detail.embedding === void 0) return;
+		if (!await this.resolveGlobalFaceEnabled()) return;
+		const [settings, media] = await Promise.all([this.resolveDeviceFaceSettings(deviceId), this.resolveDeviceMediaSettings(deviceId)]);
+		await this.faceRecognizer.ingestFaceDetail({
+			deviceId,
+			trackId,
+			timestamp: frame.timestamp,
+			frameWidth: frame.frameWidth,
+			frameHeight: frame.frameHeight,
+			score: detail.score,
+			embedding: decodeEmbeddingBase64(detail.embedding),
+			parentBbox: { ...frame.bbox },
+			...detail.bbox !== void 0 ? { faceBbox: { ...detail.bbox } } : {},
+			...detail.alignedCropJpeg !== void 0 ? { alignedCropJpeg: detail.alignedCropJpeg } : {},
+			settings,
+			cropPadding: media.cropPadding,
+			...frame.frameHandle !== void 0 ? { frameHandle: frame.frameHandle } : {}
+		});
+	}
+	/** CLIP object-embedding detail → the object-embedding store (semantic
+	*  search). Stamps the active encoder's model id so the same-model search
+	*  gate keeps matching. */
+	async routeClipDetail(deviceId, trackId, detail, timestamp) {
+		const store = this.objectEmbeddingStore;
+		if (!store || detail.embedding === void 0) return;
+		const modelId = await this.resolveClipModelId();
+		if (modelId === null) {
+			this.ctx.logger.debug("clip detail dropped — no active embedding model id", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					stepId: detail.stepId
+				}
+			});
+			return;
+		}
+		await store.upsertIfBetter({
+			trackId,
+			deviceId,
+			timestamp,
+			className: detail.className,
+			embedding: decodeEmbeddingBase64(detail.embedding),
+			modelId,
+			confidence: detail.score
+		});
+	}
+	/** Classifier answer / plate OCR text → the track's enrichment label
+	*  (TrackStore + persisted events + importance), mirroring the FaceRecognizer
+	*  label-propagation path. */
+	async applyTrackEnrichmentLabel(deviceId, trackId, label) {
+		try {
+			await this.trackStore?.setLabel(trackId, label);
+		} catch (err) {
+			this.ctx.logger.warn("detail label setLabel failed", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+		try {
+			await this.eventStore?.setLabelForTrack(trackId, label);
+		} catch (err) {
+			this.ctx.logger.warn("detail label setLabelForTrack failed", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+		try {
+			const trackStore = this.trackStore;
+			const eventStore = this.eventStore;
+			if (trackStore && eventStore) await recomputeTrackImportance({
+				trackStore,
+				eventStore
+			}, trackId);
+		} catch (err) {
+			this.ctx.logger.debug("detail label recomputeImportance failed", {
+				tags: { deviceId },
+				meta: {
+					trackId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+	/** Active CLIP image-embedding model id (== the text encoder's), TTL-cached.
+	*  Returns null when the embedding-encoder cap is unavailable. */
+	async resolveClipModelId() {
+		const now = Date.now();
+		if (this.clipModelIdCache && now < this.clipModelIdCache.expiresAt) return this.clipModelIdCache.value;
+		let value = null;
+		try {
+			value = (await this.ctx.api.embeddingEncoder.getInfo.query())?.modelId ?? null;
+		} catch (err) {
+			this.ctx.logger.debug("resolveClipModelId: getInfo failed", { meta: { error: require_dist.errMsg(err) } });
+		}
+		this.clipModelIdCache = {
+			value,
+			expiresAt: now + CLIP_MODEL_ID_CACHE_TTL_MS
+		};
+		return value;
+	}
+	/**
 	* §5 — decide which active tracks need periodic media THIS frame. Pure over
 	* TrackStore.lastSnapshotAt + the per-track best-confidence map:
 	*  • `snapshot` (append) + `lastFrame` (rolling overwrite) fire together on
@@ -7586,12 +9969,67 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			});
 		}));
 	}
-	buildSnapshotTargets(tracked, timestamp, media) {
+	/** Emit a `PipelineAnalyticsTrackLifecycle` event (start / update / end). */
+	emitTrackLifecycle(payload, timestamp) {
+		this.ctx.eventBus.emit({
+			id: `pa-life-${(0, node_crypto.randomUUID)()}`,
+			timestamp: new Date(timestamp),
+			source: {
+				type: "addon",
+				id: "pipeline-analytics",
+				addonId: "pipeline-analytics"
+			},
+			category: require_dist.EventCategory.PipelineAnalyticsTrackLifecycle,
+			data: payload
+		});
+	}
+	/**
+	* Fire a `phase:'update'` lifecycle event when this frame's observation is
+	* a MATERIAL improvement over the last emit (confidence delta, a
+	* newly-resolved identity/plate label, or a materially larger crop),
+	* debounced per `DEFAULT_UPDATE_GATE_CONFIG`. Reuses the already-computed
+	* `isNewBest`; the gate is pure and the per-track memory is advanced in
+	* place. Carries the CURRENT best incl. the improved key-frame media key.
+	*/
+	maybeEmitTrackLifecycleUpdate(deviceId, t, timestamp, isNewBest) {
+		const memory = this.trackLifecycleUpdateMem.get(t.trackId);
+		const decision = evaluateTrackLifecycleUpdate({
+			isNewBest,
+			confidence: t.confidence,
+			now: timestamp,
+			...t.label !== void 0 ? { label: t.label } : {},
+			bboxArea: t.bbox.w * t.bbox.h
+		}, memory, DEFAULT_UPDATE_GATE_CONFIG);
+		this.trackLifecycleUpdateMem.set(t.trackId, decision.memory);
+		if (!decision.emit) return;
+		const track = this.trackStore?.getActiveByTrack(t.trackId);
+		const keyFrameMediaKey = this.keyFrameKeyByTrackId.get(t.trackId);
+		const payload = buildTrackLifecyclePayload({
+			deviceId,
+			trackId: t.trackId,
+			phase: "update",
+			classes: track?.classes ?? [t.className],
+			bestClassName: t.className,
+			bestConfidence: t.confidence,
+			firstSeen: track?.firstSeen ?? timestamp,
+			lastSeen: track?.lastSeen ?? timestamp,
+			...t.label !== void 0 ? { label: t.label } : {},
+			...t.plateText !== void 0 ? { plateText: t.plateText } : {},
+			...track?.zonesVisited !== void 0 ? { zonesVisited: track.zonesVisited } : {},
+			...track?.totalDistance !== void 0 ? { totalDistance: track.totalDistance } : {},
+			...track?.positions !== void 0 ? { positionsCount: track.positions.length } : {},
+			...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {},
+			...t.embeddingModelId !== void 0 ? { embeddingModelId: t.embeddingModelId } : {}
+		});
+		this.emitTrackLifecycle(payload, timestamp);
+	}
+	buildSnapshotTargets(deviceId, tracked, timestamp, media) {
 		const targets = [];
 		for (const t of tracked) {
 			const lastSnap = this.trackStore.lastSnapshotAt(t.trackId);
 			const dueSnapshot = media.saveThumbnails && lastSnap > 0 && timestamp - lastSnap >= media.snapshotIntervalMs;
 			const isNewBest = this.bestFrameTracker.observe(t.trackId, t.confidence, timestamp);
+			this.maybeEmitTrackLifecycleUpdate(deviceId, t, timestamp, isNewBest);
 			if (!dueSnapshot && !isNewBest) continue;
 			targets.push({
 				trackId: t.trackId,
@@ -7857,6 +10295,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						positions: t.positions.length
 					}
 				});
+				const keyFrameMediaKey = this.keyFrameKeyByTrackId.get(t.trackId);
 				const faceEnd = this.faceRecognizer?.onTrackEnd(t.deviceId, t.trackId);
 				const dropKeyFrameKey = () => {
 					this.keyFrameKeyByTrackId.delete(t.trackId);
@@ -7864,11 +10303,16 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				if (faceEnd) faceEnd.finally(dropKeyFrameKey);
 				else dropKeyFrameKey();
 				this.plateRecognizer?.onTrackEnd(t.deviceId, t.trackId);
+				const trackerPeak = this.bestFrameTracker.peak(t.trackId);
+				let endImportance;
+				let endImportanceReason;
+				let endBestEventId;
 				try {
 					const peak = await this.eventStore?.peakForTrack(t.trackId);
 					if (peak) {
+						endBestEventId = peak.bestEventId;
 						const { importance, reason } = computeImportance({
-							peakConfidence: this.bestFrameTracker.peak(t.trackId)?.confidence ?? peak.peakConfidence,
+							peakConfidence: trackerPeak?.confidence ?? peak.peakConfidence,
 							className: t.className,
 							durationMs: duration,
 							peakBboxAreaFrac: peak.peakBboxAreaFrac,
@@ -7876,6 +10320,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 							zonesVisited: t.zonesVisited,
 							...t.label !== void 0 ? { label: t.label } : {}
 						});
+						endImportance = importance;
+						endImportanceReason = reason;
 						await this.trackStore?.setImportance(t.trackId, importance, reason, peak.bestEventId);
 						if (peak.bestEventId !== void 0) await this.eventStore?.setImportanceForTrack(t.trackId, importance);
 					}
@@ -7887,6 +10333,19 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				}
 				this.bestFrameTracker.delete(t.trackId);
 				this.objectEmbeddingBestSelector.delete(t.trackId);
+				this.detailDispatcher?.onTrackEnded(t.deviceId, t.trackId);
+				this.overlayState.onTrackEnded(t.deviceId, t.trackId);
+				if ((this.trackStore?.getActive(t.deviceId).length ?? 0) === 0) {
+					const captureAgg = this.mediaCaptureLog.flush(t.deviceId, Date.now());
+					if (captureAgg !== null) this.ctx.logger.info("media capture (window)", {
+						tags: { deviceId: t.deviceId },
+						meta: {
+							windowSec: Math.round(captureAgg.windowMs / 1e3),
+							frames: captureAgg.frames,
+							...captureAgg.sums
+						}
+					});
+				}
 				this.ctx.eventBus.emit({
 					id: `pa-end-${t.trackId}`,
 					timestamp: new Date(t.lastSeen),
@@ -7903,6 +10362,26 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						durationMs: duration
 					}
 				});
+				const endPayload = buildTrackLifecyclePayload({
+					deviceId: t.deviceId,
+					trackId: t.trackId,
+					phase: "end",
+					classes: t.classes ?? [t.className],
+					bestClassName: t.className,
+					bestConfidence: trackerPeak?.confidence ?? 0,
+					firstSeen: t.firstSeen,
+					lastSeen: t.lastSeen,
+					...t.label !== void 0 ? { label: t.label } : {},
+					zonesVisited: t.zonesVisited,
+					totalDistance: t.totalDistance,
+					positionsCount: t.positions.length,
+					...endImportance !== void 0 ? { importance: endImportance } : {},
+					...endImportanceReason !== void 0 ? { importanceReason: endImportanceReason } : {},
+					...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {},
+					...endBestEventId !== void 0 ? { bestEventId: endBestEventId } : {}
+				});
+				this.emitTrackLifecycle(endPayload, t.lastSeen);
+				this.trackLifecycleUpdateMem.delete(t.trackId);
 			}
 		} catch (err) {
 			if (this.shuttingDown) return;
@@ -7994,6 +10473,62 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		if (!frame) return;
 		await this.processFrame(payload.cameraId, frame, "onboard");
 	}
+	/**
+	* Best-effort bus notification for a gallery face-row change (buffer /
+	* assign / unassign / delete). Passed into the `FaceRecognizer` and
+	* `FaceGalleryProvider` as their `emitFaceGalleryChanged` dep. Telemetry
+	* (D8): a lost/failed emit only delays the admin-ui live-refresh — never
+	* allowed to fail the caller's mutation.
+	*/
+	emitFaceGalleryChanged(payload) {
+		try {
+			this.ctx.eventBus.emit({
+				id: `pa-${(0, node_crypto.randomUUID)()}`,
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "addon",
+					id: "pipeline-analytics",
+					addonId: "pipeline-analytics"
+				},
+				category: require_dist.EventCategory.PipelineAnalyticsFaceGalleryChanged,
+				data: payload
+			});
+		} catch (err) {
+			this.ctx.logger.debug("face-gallery-changed emit failed", { meta: {
+				deviceId: payload.deviceId,
+				faceId: payload.faceId,
+				error: String(err)
+			} });
+		}
+	}
+	/**
+	* Best-effort bus notification for a gallery plate-row change (buffer /
+	* assign / unassign / delete). Passed into the `PlateRecognizer` and
+	* `PlateGalleryProvider` as their `emitPlateGalleryChanged` dep. Telemetry
+	* (D8): a lost/failed emit only delays the admin-ui live-refresh — never
+	* allowed to fail the caller's mutation.
+	*/
+	emitPlateGalleryChanged(payload) {
+		try {
+			this.ctx.eventBus.emit({
+				id: `pa-${(0, node_crypto.randomUUID)()}`,
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "addon",
+					id: "pipeline-analytics",
+					addonId: "pipeline-analytics"
+				},
+				category: require_dist.EventCategory.PipelineAnalyticsPlateGalleryChanged,
+				data: payload
+			});
+		} catch (err) {
+			this.ctx.logger.debug("plate-gallery-changed emit failed", { meta: {
+				deviceId: payload.deviceId,
+				plateId: payload.plateId,
+				error: String(err)
+			} });
+		}
+	}
 	/** Composite key for the per-(device, source) processor + track maps. */
 	procKey(deviceId, source) {
 		return `${deviceId}:${source}`;
@@ -8093,6 +10628,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	}
 	async clearTracks(input) {
 		this.trackStore?.clearDevice(input.deviceId);
+		this.overlayState.clearDevice(input.deviceId);
+		this.overlaySynthesisWarnAt.delete(input.deviceId);
 		const prefix = `${input.deviceId}:`;
 		for (const k of this.lastActiveTrackIds.keys()) if (k.startsWith(prefix)) this.lastActiveTrackIds.delete(k);
 	}
@@ -8269,6 +10806,168 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		return counts;
 	}
 	/**
+	* The widened, extensible track-deletion cascade registry (design §3): every
+	* leaf store that holds track-scoped rows, ORDERED leaves-first (the track
+	* root is deleted internally, last, by `cascadeDeleteTracks`). eventStore
+	* folds in its event-owned media; mediaStore removes track/face/plate crops
+	* (never identity); faceStore removes unassigned (non-enrolled) reads;
+	* objectEmbeddingStore removes the per-track CLIP vector. The plate leg is
+	* deferred until the plate `assigned` enrollment model lands (design §11.3).
+	* Returns null when the required stores aren't ready.
+	*/
+	buildTrackCascadeRegistry() {
+		const eventStore = this.eventStore;
+		const mediaStore = this.mediaStore;
+		const trackStore = this.trackStore;
+		if (!eventStore || !mediaStore || !trackStore) return null;
+		const registry = [eventStore, mediaStore];
+		if (this.faceStore) registry.push(this.faceStore);
+		if (this.plateStore) registry.push(this.plateStore);
+		if (this.objectEmbeddingStore) registry.push(this.objectEmbeddingStore);
+		return {
+			registry,
+			trackStore
+		};
+	}
+	/**
+	* Clear the addon-level per-track in-memory scheduler/overlay state that a
+	* natural track-end (see `sweepExpiredTracks`) clears — otherwise a pruned
+	* track keeps drawing overlay boxes and the dispatcher keeps scheduling detail
+	* work until it ends on its own. Fired per successfully-cascaded track by all
+	* three retention entry points (design §5).
+	*/
+	clearLiveTrackState(deviceId, trackId) {
+		this.detailDispatcher?.onTrackEnded(deviceId, trackId);
+		this.overlayState.onTrackEnded(deviceId, trackId);
+	}
+	async deleteTracks(input) {
+		const cascade = this.buildTrackCascadeRegistry();
+		if (!cascade) return {
+			deleted: 0,
+			failed: [...input.trackIds]
+		};
+		const { deleted, failed } = await runTrackCascadeBatch({
+			registry: cascade.registry,
+			trackStore: cascade.trackStore,
+			deviceId: input.deviceId,
+			onTrackCleanup: (deviceId, trackId) => this.clearLiveTrackState(deviceId, trackId),
+			onFailure: (trackId, err) => {
+				this.ctx.logger.debug("deleteTracks failed", { meta: {
+					trackId,
+					error: String(err)
+				} });
+			}
+		}, input.trackIds);
+		if (deleted > 0) this.ctx.logger.info("analytics tracks deleted", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				deviceId: input.deviceId,
+				deleted,
+				failed: failed.length
+			}
+		});
+		return {
+			deleted,
+			failed
+		};
+	}
+	/**
+	* Track-centric time-based retention (design §5.1). Drains every persisted
+	* track for the device whose `lastSeen < cutoffMs`, page by page, through the
+	* widened cascade — enrolled faces/plates + identity media are exempt (design
+	* §4). `tracks` is the authoritative count; leaf families are best-effort 0
+	* under the void `TrackScopedStore` contract (see cap doc).
+	*/
+	async pruneTracksBefore(input) {
+		const empty = {
+			tracks: 0,
+			events: 0,
+			media: 0,
+			faces: 0,
+			plates: 0,
+			embeddings: 0
+		};
+		const cascade = this.buildTrackCascadeRegistry();
+		if (!cascade) return empty;
+		const PAGE = 200;
+		let totalDeleted = 0;
+		for (;;) {
+			if (this.shuttingDown) break;
+			const ids = await cascade.trackStore.listIdsBefore(input.deviceId, input.cutoffMs, PAGE);
+			if (ids.length === 0) break;
+			const { deleted } = await runTrackCascadeBatch({
+				registry: cascade.registry,
+				trackStore: cascade.trackStore,
+				deviceId: input.deviceId,
+				onTrackCleanup: (deviceId, trackId) => this.clearLiveTrackState(deviceId, trackId),
+				onFailure: (trackId, err) => {
+					this.ctx.logger.debug("pruneTracksBefore track failed", { meta: {
+						trackId,
+						error: String(err)
+					} });
+				}
+			}, ids);
+			totalDeleted += deleted;
+			if (deleted === 0) break;
+		}
+		if (totalDeleted > 0) this.ctx.logger.info("analytics track retention prune", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				deviceId: input.deviceId,
+				cutoffMs: input.cutoffMs,
+				tracks: totalDeleted
+			}
+		});
+		return {
+			...empty,
+			tracks: totalDeleted
+		};
+	}
+	/**
+	* Operator "clean slate" for a device (design §5.3): prune EVERY persisted
+	* track via the same cascade as `pruneTracksBefore` with `cutoffMs = now`.
+	* Enrolled gallery + identity media are exempt.
+	*/
+	async wipeAllAnalytics(input) {
+		return this.pruneTracksBefore({
+			deviceId: input.deviceId,
+			cutoffMs: Date.now()
+		});
+	}
+	/**
+	* Periodic per-device track retention sweep (design §6): for every device
+	* that has persisted tracks, prune those older than its `trackRetentionDays`
+	* window (default 7 days; 0 = keep forever → skipped). Runs on the shared
+	* retention interval. Enrolled gallery is exempt by the cascade store layer.
+	*/
+	async runTrackRetentionSweep() {
+		if (this.shuttingDown || !this.trackStore) return;
+		const trackStore = this.trackStore;
+		try {
+			const total = await sweepTrackRetention({
+				listDeviceIds: () => trackStore.listDeviceIds(),
+				resolveRetentionDays: async (deviceId) => {
+					return resolveTrackRetentionDays(await this.ctx?.settings?.readDeviceStore(deviceId) ?? {});
+				},
+				pruneTracksBefore: (deviceId, cutoffMs) => this.pruneTracksBefore({
+					deviceId,
+					cutoffMs
+				}),
+				now: () => Date.now(),
+				onError: (deviceId, err) => {
+					this.ctx.logger.debug("track retention sweep (device) failed", { meta: {
+						deviceId,
+						error: String(err)
+					} });
+				}
+			});
+			if (total > 0) this.ctx.logger.info("analytics track retention sweep", { meta: { tracks: total } });
+		} catch (err) {
+			if (this.shuttingDown) return;
+			this.ctx.logger.debug("runTrackRetentionSweep failed", { meta: { error: String(err) } });
+		}
+	}
+	/**
 	* Decode a stored event image into `EventMedia` for the data-plane handler.
 	* Preference order: `crop` (square-safe 16:9 preview) → `fullFrameBoxed`
 	* (native-res boxed frame) → any available file. Returns `null` if the
@@ -8329,6 +11028,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					label: "Post-processing node",
 					description: "Node id that persists events + media (e.g. \"hub\"). Leave \"hub\" unless you intentionally move post-processing to an agent. Takes effect on addon restart.",
 					default: POST_PROCESSING_NODE_DEFAULT
+				}, {
+					type: "boolean",
+					key: "embeddingEnabled",
+					label: "Object/face embeddings",
+					description: "Compute object/face embeddings from detection crops (feeds similarity search + face recognition). Runs on the post-processing node. Takes effect on addon restart.",
+					default: true
 				}]
 			},
 			{
@@ -8435,9 +11140,20 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			{
 				id: "retention",
 				title: "Retention",
-				description: "How long each event kind is kept in the SQL store. Media files follow the minimum of these.",
+				description: "How long analytics history is kept in the SQL store. Media files follow the minimum of these.",
 				columns: 3,
 				fields: [
+					{
+						type: "number",
+						key: "trackRetentionDays",
+						label: "Tracks",
+						description: "Age out persisted tracks and everything derived from them (events, media, faces, embeddings) beyond this window. 0 = keep forever. Enrolled faces/plates are never pruned.",
+						min: 0,
+						max: 365,
+						step: 1,
+						default: TRACK_RETENTION_DEFAULT_DAYS,
+						unit: "days"
+					},
 					{
 						type: "number",
 						key: "retentionMotionDays",