@camstack/addon-post-analysis 1.2.76 → 1.2.77

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BsBjSNIo.js");
+const require_dist = require("../dist-Bs6oboqZ.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -4821,6 +4821,7 @@ var SceneMonitorProvider = class {
 			direction,
 			verdict: result.verdict,
 			latched,
+			emit: monitor.emit,
 			condition: result.currentCondition,
 			confidence: result.lastConfidence,
 			timestamp: result.checkedAt
@@ -6485,6 +6486,110 @@ function maskPolygonOverlap(mask, maskWidth, maskHeight, bbox, polygon, _frameWi
 	if (totalMaskPixels === 0) return 0;
 	return insidePolygon / totalMaskPixels;
 }
+var NcSceneStateCache = class {
+	deps;
+	entries = /* @__PURE__ */ new Map();
+	noted = /* @__PURE__ */ new Map();
+	ids = [];
+	now;
+	constructor(deps) {
+		this.deps = deps;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	/**
+	* The scene ids worth reading — recomputed from the rule set, so a cluster
+	* with no scene-gated rule does no work at all and logs nothing.
+	*/
+	setWatched(ids) {
+		this.ids = [...new Set(ids)].sort();
+	}
+	watched() {
+		return this.ids;
+	}
+	/**
+	* "This scene, in this process, is in this state, NOW."
+	*
+	* Synchronous by contract — the caller is the scene provider's own edge tap
+	* and the next rule evaluation must already see it.
+	*/
+	note(observation) {
+		this.noted.set(observation.sceneId, {
+			observation,
+			at: this.now()
+		});
+	}
+	/** Hot-path read. No I/O, no await — this is called per event. */
+	get(sceneId) {
+		const now = this.now();
+		const noted = this.noted.get(sceneId);
+		if (noted !== void 0) {
+			if (now - noted.at <= 3e5) return noted.observation;
+			this.noted.delete(sceneId);
+		}
+		const entry = this.entries.get(sceneId);
+		if (entry === void 0) return void 0;
+		if (now - entry.at > 3e5) return void 0;
+		return entry.observation;
+	}
+	/**
+	* Re-read every watched scene. Never throws: a gate that could fail the
+	* evaluation tick would take the notification pipeline with it.
+	*
+	* On failure the previous entries are KEPT — their timestamps are not
+	* touched, so they age out on their own rather than vanishing at once.
+	*/
+	refresh() {
+		if (this.ids.length === 0) {
+			this.entries = /* @__PURE__ */ new Map();
+			this.noted.clear();
+			return;
+		}
+		let observations;
+		try {
+			observations = this.deps.readScenes();
+		} catch (err) {
+			this.deps.logger.warn("scene-state refresh failed — keeping the previous states until they age out", { meta: {
+				watched: this.ids.length,
+				error: String(err)
+			} });
+			return;
+		}
+		const at = this.now();
+		const wanted = new Set(this.ids);
+		const next = /* @__PURE__ */ new Map();
+		for (const observation of observations) {
+			if (!wanted.has(observation.sceneId)) continue;
+			next.set(observation.sceneId, {
+				observation,
+				at
+			});
+		}
+		this.entries = next;
+		for (const sceneId of this.ids) {
+			if (next.has(sceneId)) continue;
+			this.deps.logger.info("scene gate: no state for a watched scene", { meta: { sceneId } });
+		}
+	}
+};
+/**
+* Does this observation satisfy the rule's scene condition?
+*
+* Exported and pure so the semantics can be tested without a cache, a provider
+* or a rule — and so there is exactly ONE place that decides what `latched`
+* absent means. See `NcSceneConditionSchema` for the reasoning behind each
+* branch.
+*/
+function sceneConditionSatisfied(condition, observation) {
+	if (condition.latched ?? observation.emit === "latched") return observation.latched === (condition.requiredState === "diverged");
+	return observation.verdict === condition.requiredState;
+}
+/** One-line "why", for the suppression log. Never a bare boolean: a drop the
+*  operator cannot explain is the failure this whole feature is one misstep
+*  away from. */
+function sceneGateReason(condition, observation) {
+	if (observation === void 0) return "no mirrored state for this scene";
+	return condition.latched ?? observation.emit === "latched" ? `latched=${observation.latched} (wanted ${condition.requiredState})` : `verdict=${observation.verdict} (wanted ${condition.requiredState})`;
+}
 //#endregion
 //#region src/notification-center/zone-ownership.ts
 var UNCHANGED = { kind: "unchanged" };
@@ -6821,6 +6926,7 @@ function presentConditionIds(c) {
 	if (c.packagePhase !== void 0 && c.packagePhase !== "both") ids.push("packagePhase");
 	if (c.customZones !== void 0 && c.customZones.length > 0) ids.push("customZones");
 	if (c.occupancy !== void 0) ids.push("occupancy");
+	if (c.scene !== void 0) ids.push("scene");
 	return ids;
 }
 /**
@@ -7000,7 +7106,7 @@ function matchesSystemEvent(condition, subject) {
 	if (condition.packageNames !== void 0 && (subject.packageName === void 0 || !condition.packageNames.includes(subject.packageName))) return false;
 	return true;
 }
-function evaluateRule(rule, subject, deviceState, zoneOwners) {
+function evaluateRule(rule, subject, deviceState, zoneOwners, sceneStates) {
 	if (subject.kind === "system-event") {
 		if (rule.delivery !== "system-event") return fail("delivery");
 		const condition = rule.conditions.systemEvent;
@@ -7041,6 +7147,11 @@ function evaluateRule(rule, subject, deviceState, zoneOwners) {
 		if (current === void 0) return fail("deviceState");
 		if (!toLowerSet(c.deviceState.states).has(current.trim().toLowerCase())) return fail("deviceState");
 	}
+	if (c.scene !== void 0) {
+		const observation = sceneStates?.(c.scene.sceneId);
+		if (observation === void 0) return fail("scene");
+		if (!sceneConditionSatisfied(c.scene, observation)) return fail("scene");
+	}
 	if (c.devices !== void 0 && c.devices.length > 0 && !matchesDeviceScope(c.devices, subject)) return fail("devices");
 	if (c.source !== void 0 && c.source !== "any") {
 		if ((subject.source ?? "pipeline") !== c.source) return fail("source");
@@ -17644,6 +17755,22 @@ var NotificationCenter = class NotificationCenter {
 	/** States the `deviceState` rule gate reads. Refreshed on the reload tick;
 	*  read with no I/O on the persist hook. */
 	deviceStates;
+	/** Scene verdicts + latches the `scene` rule gate reads. Same contract as
+	*  {@link deviceStates}: refreshed on the reload tick and on the provider's
+	*  in-process edge tap, read with no I/O on the persist hook (D49). */
+	sceneStates;
+	/**
+	* The last scene-gate answer REPORTED per rule, so the suppression line is
+	* written on CHANGE rather than on every event.
+	*
+	* A branch that drops work silently must log it, and a gate that logged on
+	* every detection on a busy camera would be a line nobody reads — which is
+	* the same silence by a different route.
+	*/
+	sceneGateReported = /* @__PURE__ */ new Map();
+	/** The watched scene id set, as last REPORTED — so the line is written when it
+	*  changes and not on every reload tick. `null` = never reported. */
+	sceneWatchSignature = null;
 	/** WHO each device id is (name + type). The system-event intake reads it with
 	*  no I/O; the reload tick refreshes it — see `device-directory.ts`. */
 	deviceDirectory;
@@ -18043,6 +18170,11 @@ var NotificationCenter = class NotificationCenter {
 			readStates: deps.readDeviceStates ?? (async () => /* @__PURE__ */ new Map()),
 			...deps.now !== void 0 ? { now: deps.now } : {}
 		});
+		this.sceneStates = new NcSceneStateCache({
+			logger: this.logger.child("scene-state"),
+			readScenes: deps.readSceneStates ?? (() => []),
+			...deps.now !== void 0 ? { now: deps.now } : {}
+		});
 		this.deviceDirectory = new NcDeviceDirectory({
 			logger: this.logger.child("device-directory"),
 			listDevices: deps.listDeviceIdentities ?? (async () => {
@@ -18242,6 +18374,7 @@ var NotificationCenter = class NotificationCenter {
 		await this.deviceDirectory.refresh();
 		await this.hydrateLiveness();
 		await this.zoneOwners.refresh();
+		this.sceneStates.refresh();
 		this.evaluationActive = true;
 		await this.outbox.load();
 		await this.seedCooldowns();
@@ -19006,6 +19139,73 @@ var NotificationCenter = class NotificationCenter {
 		if (identity.isCamera && identity.detectionActive === false) return "detection-off";
 	}
 	/**
+	* SAY that the scene gate suppressed this rule.
+	*
+	* A branch that drops work silently logs it — the three-hour media blackout
+	* produced not one line, and a gate is the same shape of failure: from the
+	* operator's side "the rule stopped notifying" and "the pipeline stopped
+	* working" look identical. `rule did not match` covers it at DEBUG, which is
+	* not a level this installation runs at.
+	*
+	* On CHANGE only, per rule: the alternative is one line per detection on a
+	* busy camera, which is silence by a different route. The `deviceId` tag is
+	* the SUBJECT's — that is the camera whose notification went missing, and the
+	* question is always asked per-camera. The SCENE's own device is named in the
+	* meta beside its id, because the two are frequently different cameras.
+	*/
+	reportSceneSuppression(rule, subject) {
+		const condition = rule.conditions.scene;
+		if (condition === void 0) return;
+		const observation = this.sceneStates.get(condition.sceneId);
+		const reason = sceneGateReason(condition, observation);
+		if (this.sceneGateReported.get(rule.id) === reason) return;
+		this.sceneGateReported.set(rule.id, reason);
+		this.logger.info("rule suppressed by its scene condition", {
+			tags: { deviceId: subject.deviceId },
+			meta: {
+				ruleId: rule.id,
+				rule: rule.name,
+				sceneId: condition.sceneId,
+				sceneLabel: observation?.label,
+				sceneDeviceId: observation?.deviceId ?? condition.deviceId,
+				requiredState: condition.requiredState,
+				reason
+			}
+		});
+	}
+	/**
+	* A confirmed scene transition, straight from the provider in this process.
+	*
+	* Synchronous on purpose and for the same reason {@link onAlarmPublish} is:
+	* the reload tick would otherwise be the only writer, and a rule gated on
+	* "while the bin is out" would keep its old answer for up to thirty seconds
+	* after the bin came back. The tick stays as reconciliation.
+	*
+	* A DIRECT CALL, not a bus subscription. `EnrichmentSceneStateChanged` is
+	* still emitted for the badge and for anyone else, but D8 events are
+	* droppable telemetry and a gate fed by droppable telemetry is a gate that is
+	* sometimes wrong and never says so.
+	*
+	* This never OPENS a gate that the mirror had shut for lack of an entry: it
+	* writes an observation the caller actually made. It is `refresh` that
+	* removes entries, and it never empties on a failed read (D49).
+	*/
+	onSceneEdge(observation) {
+		this.sceneStates.note(observation);
+	}
+	/**
+	* Reconcile the scene mirror now.
+	*
+	* The scene provider is constructed AFTER this centre starts (it needs the
+	* media store and the embedding encoder), so the boot refresh reads an empty
+	* provider. The addon calls this once the provider has hydrated, rather than
+	* leaving every scene-gated rule shut for a whole reload tick after every
+	* respawn.
+	*/
+	refreshSceneStates() {
+		this.sceneStates.refresh();
+	}
+	/**
 	* Everything the panel reports, on every publish.
 	*
 	* Synchronous on purpose. The state half refreshes the `deviceState` gate's
@@ -19304,8 +19504,9 @@ var NotificationCenter = class NotificationCenter {
 		let noOwnerReported = false;
 		const rejections = [];
 		for (const rule of candidates) {
-			const evaluation = evaluateRule(rule, subject, (id) => this.deviceStates.get(id), (id) => this.zoneOwners.get(id));
+			const evaluation = evaluateRule(rule, subject, (id) => this.deviceStates.get(id), (id) => this.zoneOwners.get(id), (sceneId) => this.sceneStates.get(sceneId));
 			if (!evaluation.matched) {
+				if (evaluation.failedCondition === "scene") this.reportSceneSuppression(rule, subject);
 				rejections.push(`${rule.name}:${evaluation.failedCondition ?? "unknown"}`);
 				outcomes.push({
 					ruleId: rule.id,
@@ -19330,6 +19531,7 @@ var NotificationCenter = class NotificationCenter {
 				});
 				continue;
 			}
+			this.sceneGateReported.delete(rule.id);
 			this.runRuleActions(rule, subject, kind, controls);
 			const admission = this.admitToGroup(rule, subject, now);
 			if (admission.outcome === "unchanged") {
@@ -19961,10 +20163,13 @@ var NotificationCenter = class NotificationCenter {
 		this.reportAudioWatch(audioWatch);
 		const gated = [];
 		const zoneScoped = [];
+		const sceneIds = [];
 		for (const rule of this.rules.list()) {
 			if (!rule.enabled) continue;
 			const ds = rule.conditions.deviceState;
 			if (ds !== void 0) gated.push(ds.deviceId);
+			const scene = rule.conditions.scene;
+			if (scene !== void 0) sceneIds.push(scene.sceneId);
 			const zones = rule.conditions.zones;
 			const devices = rule.conditions.devices;
 			if (zones !== void 0 && zones.ids.length > 0 && devices !== void 0) zoneScoped.push(...devices);
@@ -19973,6 +20178,15 @@ var NotificationCenter = class NotificationCenter {
 		if (panel !== null) gated.push(...alarmContactWatchList(this.rules.list(), panel.deviceId, panel.availableModes()));
 		this.deviceStates.setWatched(gated);
 		this.zoneOwners.setWatched(zoneScoped);
+		this.sceneStates.setWatched(sceneIds);
+		const signature = [...new Set(sceneIds)].sort().join(",");
+		if (signature !== this.sceneWatchSignature) {
+			this.sceneWatchSignature = signature;
+			this.logger.info("scene gate watched set", { meta: {
+				scenes: this.sceneStates.watched(),
+				gatedRules: sceneIds.length
+			} });
+		}
 	}
 	/**
 	* Feed every excluded sensor's mirrored state back to the panel.
@@ -20109,6 +20323,7 @@ var NotificationCenter = class NotificationCenter {
 		await this.deviceStates.refresh();
 		await this.deviceDirectory.refresh();
 		await this.zoneOwners.refresh();
+		this.sceneStates.refresh();
 		this.observeAlarmContacts();
 		await this.occupancyStore.pruneExcept(this.activeOccupancyKeys());
 	}
@@ -20406,12 +20621,17 @@ var NotificationCenter = class NotificationCenter {
 			const fresh = await this.deps.readDeviceZoneIds(zoneScope);
 			zoneLookup = (id) => fresh.get(id) ?? this.zoneOwners.get(id);
 		} catch {}
+		let sceneLookup = (id) => this.sceneStates.get(id);
+		if (rule.conditions.scene !== void 0 && this.deps.readSceneStates !== void 0) try {
+			const fresh = new Map(this.deps.readSceneStates().map((o) => [o.sceneId, o]));
+			sceneLookup = (id) => fresh.get(id) ?? this.sceneStates.get(id);
+		} catch {}
 		const occupancy = rule.conditions.occupancy;
-		if (rule.delivery === "device-event" && occupancy !== void 0) return this.occupancyDryRun(rule, occupancy, lookup, zoneLookup);
+		if (rule.delivery === "device-event" && occupancy !== void 0) return this.occupancyDryRun(rule, occupancy, lookup, zoneLookup, sceneLookup);
 		const results = [];
 		for (const subject of subjects.sort((a, b) => b.timestamp - a.timestamp)) {
 			if (results.length >= TEST_RULE_MAX_RESULTS) break;
-			const evaluation = evaluateRule(rule, subject, lookup, zoneLookup);
+			const evaluation = evaluateRule(rule, subject, lookup, zoneLookup, sceneLookup);
 			results.push({
 				recordId: subject.recordId,
 				recordKind: subject.kind === "track-end" ? "track" : subject.kind === "audio-event" || subject.kind === "audio-window" ? "object-event" : subject.kind === "occupancy-event" ? "device-event" : subject.kind,
@@ -20435,7 +20655,7 @@ var NotificationCenter = class NotificationCenter {
 	* from the ordinary `evaluateRule` on the ordinary subject — this method
 	* chooses the cameras and writes the sentence, nothing else.
 	*/
-	async occupancyDryRun(rule, occupancy, lookup, zoneLookup) {
+	async occupancyDryRun(rule, occupancy, lookup, zoneLookup, sceneLookup) {
 		const read = this.deps.readOccupancySnapshots;
 		if (read === void 0) return [];
 		const now = this.now();
@@ -20478,7 +20698,7 @@ var NotificationCenter = class NotificationCenter {
 				});
 				continue;
 			}
-			const evaluation = evaluateRule(rule, probe.subject, lookup, zoneLookup);
+			const evaluation = evaluateRule(rule, probe.subject, lookup, zoneLookup, sceneLookup);
 			results.push({
 				...common,
 				recordId: probe.subject.recordId,
@@ -20733,6 +20953,10 @@ function planRuleTest(input) {
 		conditionId: "deviceState",
 		note: `This rule only fires while device #${c.deviceState.deviceId} is in one of its chosen states. That gate reads the REAL device and cannot be simulated — put the device in that state first, or the test fails closed exactly as production would.`
 	});
+	if (c.scene !== void 0) notes.push({
+		conditionId: "scene",
+		note: `This rule only fires while scene ${c.scene.sceneId} is ${c.scene.requiredState}. That gate reads the scene's REAL state and cannot be simulated — the test answers with whatever the scene is right now, and fails closed while it cannot judge or has not been read yet, exactly as production would.`
+	});
 	if (c.customZones !== void 0 && c.customZones.length > 0) notes.push({
 		conditionId: "customZones",
 		note: "The subject is placed over the first drawn polygon so the condition passes. A rule that needs a specific polygon should be checked in the simulator, where the box can be moved."
@@ -23242,6 +23466,88 @@ var embeddingActions = require_dist.defineCustomActions({
 	"embedding.wipe": require_dist.customAction(NoInputSchema, WipeResultSchema, { auth: "admin" })
 });
 //#endregion
+//#region src/pipeline-analytics/retention/orphan-audit-actions.ts
+/**
+* The operator button for the orphan audit.
+*
+* The audit engine, its five bounds and its resumable cursor already existed
+* and had run in `report` mode for weeks; what it had no way to be was
+* *asked*. Its only trigger was a 6-hourly timer reading a durable setting, so
+* draining a standing backlog meant flipping a persistent mode, waiting up to
+* six hours, and remembering to flip it back — with nothing returned to look
+* at. On 2026-08-14 the backlog was 74,700 media rows / 18.9 GB plus 23,296
+* object events and 4,543 CLIP vectors (D161), and that is not a thing to
+* drain by leaving a switch on.
+*
+* Three properties this action does NOT leave to the caller's care:
+*
+*  1. **Dry run is the default.** `mode` omitted means `report`: it counts,
+*     logs and returns, and deletes nothing — regardless of what the durable
+*     `orphanAuditMode` setting says. `reclaim` is a word that has to be
+*     typed. The engine's own default is the same for the same reason.
+*  2. **It is paced.** `pageSize` bounds one read, `maxRowsPerScope` bounds
+*     one pass, `maxReclaimPerScope` bounds the damage, and the engine yields
+*     the thread between pages — `better-sqlite3` is synchronous and shares
+*     hub-main with every live frame.
+*  3. **It answers.** The report comes back per collection with rows AND
+*     bytes, so "did it do anything" is not a question anyone has to infer
+*     from a log line.
+*/
+/**
+* `report` counts; `reclaim` deletes.
+*
+* `.default('report')` is load-bearing, not decoration: the settings form
+* sends `{}` for a button with no fields, and the safe interpretation of an
+* unstated intent here is the one that destroys nothing.
+*/
+var OrphanAuditActionModeSchema = require_dist._enum(["report", "reclaim"]).default("report");
+var OrphanAuditActionInputSchema = require_dist.object({
+	mode: OrphanAuditActionModeSchema,
+	/**
+	* Start every scope from the top instead of resuming its persisted cursor.
+	*
+	* What draining a backlog wants, and never the default — the cursor exists
+	* so a 6-hourly pass makes progress instead of re-walking the same head.
+	*/
+	restart: require_dist.boolean().optional(),
+	/** Rows read per statement. Smaller = more yields = a gentler pass. */
+	pageSize: require_dist.number().int().min(50).max(5e3).optional(),
+	/** Rows EXAMINED per collection in this pass — the pacing bound. */
+	maxRowsPerScope: require_dist.number().int().min(1).max(2e5).optional(),
+	/** Rows DELETED per collection in this pass — the blast-radius bound. */
+	maxReclaimPerScope: require_dist.number().int().min(1).max(1e5).optional(),
+	/**
+	* Minutes of immunity for a recent row. Protective ONLY — raising it can
+	* exclusively save rows, never select them, which is what keeps this off
+	* the one-age-keyed-sweep guard's books.
+	*/
+	graceMinutes: require_dist.number().int().min(1).max(10080).optional()
+});
+var OrphanAuditScopeReportSchema = require_dist.object({
+	collection: require_dist.string(),
+	examined: require_dist.number(),
+	orphans: require_dist.number(),
+	reclaimed: require_dist.number(),
+	bytesReclaimed: require_dist.number(),
+	exempt: require_dist.number(),
+	withinGrace: require_dist.number(),
+	unresolvable: require_dist.number(),
+	stoppedBy: require_dist.string(),
+	/** Where the NEXT pass resumes. `0` = the scope was walked to the end. */
+	nextCursor: require_dist.number()
+});
+var OrphanAuditActionResultSchema = require_dist.object({
+	/** `false` when a pass was already in flight — nothing was done. */
+	ran: require_dist.boolean(),
+	mode: require_dist._enum(["report", "reclaim"]),
+	scopes: require_dist.array(OrphanAuditScopeReportSchema),
+	totalOrphans: require_dist.number(),
+	totalReclaimed: require_dist.number(),
+	totalBytesReclaimed: require_dist.number(),
+	durationMs: require_dist.number()
+});
+var orphanAuditActions = require_dist.defineCustomActions({ "retention.orphanAudit": require_dist.customAction(OrphanAuditActionInputSchema, OrphanAuditActionResultSchema, { auth: "admin" }) });
+//#endregion
 //#region src/pipeline-analytics/map-with-concurrency.ts
 /**
 * Apply `mapper` to every item with at most `limit` in flight at once.
@@ -25978,6 +26284,72 @@ function decideZeroMediaPolicy(input, config = DEFAULT_ZERO_MEDIA_POLICY_CONFIG)
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/delete-track-cascade.ts
+var EMPTY_CASCADE_TALLY = {
+	tracks: 0,
+	events: 0,
+	media: 0,
+	faces: 0,
+	plates: 0,
+	embeddings: 0,
+	bytesReclaimed: 0
+};
+/** Fold a leaf store's receipts into a running tally. */
+function addLeafCounts(tally, counts) {
+	let next = tally;
+	for (const c of counts) {
+		const bytesReclaimed = next.bytesReclaimed + c.bytes;
+		switch (c.family) {
+			case "events":
+				next = {
+					...next,
+					events: next.events + c.rows,
+					bytesReclaimed
+				};
+				break;
+			case "media":
+				next = {
+					...next,
+					media: next.media + c.rows,
+					bytesReclaimed
+				};
+				break;
+			case "faces":
+				next = {
+					...next,
+					faces: next.faces + c.rows,
+					bytesReclaimed
+				};
+				break;
+			case "plates":
+				next = {
+					...next,
+					plates: next.plates + c.rows,
+					bytesReclaimed
+				};
+				break;
+			case "embeddings":
+				next = {
+					...next,
+					embeddings: next.embeddings + c.rows,
+					bytesReclaimed
+				};
+				break;
+		}
+	}
+	return next;
+}
+/** Sum two tallies (per-track results into a per-device one). */
+function mergeCascadeTallies(a, b) {
+	return {
+		tracks: a.tracks + b.tracks,
+		events: a.events + b.events,
+		media: a.media + b.media,
+		faces: a.faces + b.faces,
+		plates: a.plates + b.plates,
+		embeddings: a.embeddings + b.embeddings,
+		bytesReclaimed: a.bytesReclaimed + b.bytesReclaimed
+	};
+}
 /**
 * Extensible whole-track deletion cascade. Runs every registered
 * `TrackScopedStore` (each removes its ephemeral rows + owned media for the
@@ -25994,8 +26366,16 @@ function decideZeroMediaPolicy(input, config = DEFAULT_ZERO_MEDIA_POLICY_CONFIG)
 *   ]
 */
 async function cascadeDeleteTracks(registry, trackStore, trackIds) {
-	for (const store of registry) await store.deleteByTracks(trackIds);
-	for (const trackId of trackIds) await trackStore.deletePersisted(trackId);
+	let tally = EMPTY_CASCADE_TALLY;
+	for (const store of registry) tally = addLeafCounts(tally, await store.deleteByTracks(trackIds));
+	for (const trackId of trackIds) {
+		await trackStore.deletePersisted(trackId);
+		tally = {
+			...tally,
+			tracks: tally.tracks + 1
+		};
+	}
+	return tally;
 }
 /**
 * The one registry, in the one order — leaves first, root deleted internally
@@ -26026,14 +26406,28 @@ function buildAnalyticsCascadeRegistry(stores) {
 * embeddings) is opted in by the CALLER's registry, not by this legacy shim.
 */
 async function cascadeDeleteTrack(stores, trackId) {
-	await cascadeDeleteTracks([{ deleteByTracks: async (ids) => {
+	return cascadeDeleteTracks([{ deleteByTracks: async (ids) => {
+		let events = 0;
+		let media = 0;
 		for (const id of ids) {
 			const eventIds = await stores.eventStore.deleteByTrack(id);
-			if (eventIds.length > 0) await stores.mediaStore.deleteForEvents([...eventIds]);
+			events += eventIds.length;
+			if (eventIds.length > 0) media += await stores.mediaStore.deleteForEvents([...eventIds]);
 		}
-	} }, { deleteByTracks: async (ids) => {
-		await stores.mediaStore.deleteForTracks([...ids]);
-	} }], stores.trackStore, [trackId]);
+		return [{
+			family: "events",
+			rows: events,
+			bytes: 0
+		}, {
+			family: "media",
+			rows: media,
+			bytes: 0
+		}];
+	} }, { deleteByTracks: async (ids) => [{
+		family: "media",
+		rows: await stores.mediaStore.deleteForTracks([...ids]),
+		bytes: 0
+	}] }], stores.trackStore, [trackId]);
 }
 /**
 * Widened batch whole-track deletion — the ONE engine behind the three §5 entry
@@ -26044,9 +26438,10 @@ async function cascadeDeleteTrack(stores, trackId) {
 */
 async function runTrackCascadeBatch(deps, trackIds) {
 	let deleted = 0;
+	let tally = EMPTY_CASCADE_TALLY;
 	const failed = [];
 	for (const trackId of trackIds) try {
-		await cascadeDeleteTracks(deps.registry, deps.trackStore, [trackId]);
+		tally = mergeCascadeTallies(tally, await cascadeDeleteTracks(deps.registry, deps.trackStore, [trackId]));
 		deps.onTrackCleanup(deps.deviceId, trackId);
 		deleted += 1;
 	} catch (err) {
@@ -26055,7 +26450,8 @@ async function runTrackCascadeBatch(deps, trackIds) {
 	}
 	return {
 		deleted,
-		failed
+		failed,
+		tally
 	};
 }
 //#endregion
@@ -33678,21 +34074,33 @@ var MediaStore = class {
 	* Best-effort per row; returns the number of index rows removed.
 	*/
 	async deleteForOwner(ownerKind, ownerIds) {
+		return (await this.gated(() => this.deleteForOwnerUnchecked(ownerKind, ownerIds))).rows;
+	}
+	/**
+	* The same delete, reporting the BYTES it released as well as the row count.
+	*
+	* `sizeBytes` is already on the index row, so the number costs nothing — it
+	* was simply never returned, which is why every retention ops-log row this
+	* addon has ever written says `bytesReclaimed: 0` (D161).
+	*/
+	async deleteForOwnerCounted(ownerKind, ownerIds) {
 		return this.gated(() => this.deleteForOwnerUnchecked(ownerKind, ownerIds));
 	}
 	async deleteForOwnerUnchecked(ownerKind, ownerIds) {
-		let removed = 0;
+		let rows = 0;
+		let bytes = 0;
 		for (const ownerId of ownerIds) {
-			const rows = await this.store.query.query({
+			const found = await this.store.query.query({
 				collection: MEDIA_COLLECTION,
 				filter: { where: {
 					ownerKind,
 					ownerId
 				} }
 			});
-			for (const row of rows) {
+			for (const row of found) {
 				const rowData = row.data;
 				const path = String(rowData["path"] ?? "");
+				const sizeBytes = Number(rowData["sizeBytes"]);
 				try {
 					if (path) await this.storage.delete({
 						location: mediaRowLocation(rowData),
@@ -33704,7 +34112,8 @@ var MediaStore = class {
 						collection: MEDIA_COLLECTION,
 						key: row.id
 					});
-					removed++;
+					rows++;
+					if (Number.isFinite(sizeBytes)) bytes += sizeBytes;
 				} catch (err) {
 					this.logger.debug("media delete-for-owner failed", { meta: {
 						key: row.id,
@@ -33713,7 +34122,10 @@ var MediaStore = class {
 				}
 			}
 		}
-		return removed;
+		return {
+			rows,
+			bytes
+		};
 	}
 	/**
 	* On-demand footprint aggregation for the events-management UI: sum
@@ -33852,11 +34264,20 @@ var MediaStore = class {
 	* batch.
 	*/
 	async deleteByTracks(trackIds) {
-		await this.gated(async () => {
-			await this.deleteForOwnerUnchecked("track", trackIds);
-			await this.deleteForOwnerUnchecked("face", trackIds.map((id) => FACE_MEDIA_OWNER_PREFIX + id));
+		const own = await this.gated(async () => {
+			const tracks = await this.deleteForOwnerUnchecked("track", trackIds);
+			const faces = await this.deleteForOwnerUnchecked("face", trackIds.map((id) => FACE_MEDIA_OWNER_PREFIX + id));
+			return {
+				rows: tracks.rows + faces.rows,
+				bytes: tracks.bytes + faces.bytes
+			};
 		});
-		await this.deleteForOwner("plate", trackIds.map((id) => PLATE_MEDIA_OWNER_PREFIX + id));
+		const plates = await this.deleteForOwnerCounted("plate", trackIds.map((id) => PLATE_MEDIA_OWNER_PREFIX + id));
+		return [{
+			family: "media",
+			rows: own.rows + plates.rows,
+			bytes: own.bytes + plates.bytes
+		}];
 	}
 	/**
 	* A stable page of media INDEX rows for the orphan audit — no blobs, no
@@ -38294,11 +38715,21 @@ var EventStore = class {
 				error: String(err)
 			} });
 		}
+		let mediaRows = 0;
 		if (eventIds.length > 0 && this.media !== void 0) try {
-			await this.media.deleteForEvents(eventIds);
+			mediaRows = await this.media.deleteForEvents(eventIds);
 		} catch (err) {
 			this.logger.warn("EventStore.deleteByTracks: event media delete failed", { meta: { error: String(err) } });
 		}
+		return [{
+			family: "events",
+			rows: eventIds.length,
+			bytes: 0
+		}, {
+			family: "media",
+			rows: mediaRows,
+			bytes: 0
+		}];
 	}
 };
 function slimMotion(id, data) {
@@ -38689,6 +39120,7 @@ var FaceStore = class {
 	* aborts the batch. (Crop media of these rows is removed by `MediaStore`.)
 	*/
 	async deleteByTracks(trackIds) {
+		let removed = 0;
 		for (const trackId of trackIds) try {
 			const eligible = (await this.store.query.query({
 				collection: FACES_COLLECTION,
@@ -38699,6 +39131,7 @@ var FaceStore = class {
 					collection: FACES_COLLECTION,
 					key: row.id
 				});
+				removed++;
 			} catch (err) {
 				this.logger.warn("FaceStore.deleteByTracks delete failed", { meta: {
 					faceId: row.id,
@@ -38711,6 +39144,11 @@ var FaceStore = class {
 				error: String(err)
 			} });
 		}
+		return [{
+			family: "faces",
+			rows: removed,
+			bytes: 0
+		}];
 	}
 	/** Delete a single buffered face row by id (its crop media is removed by the
 	*  caller — the FaceStore owns rows, not blobs). Best-effort. */
@@ -39646,6 +40084,7 @@ var PlateStore = class {
 	* the batch. (Crop media of these rows is removed by `MediaStore`.)
 	*/
 	async deleteByTracks(trackIds) {
+		let removed = 0;
 		for (const trackId of trackIds) try {
 			const eligible = (await this.store.query.query({
 				collection: PLATES_COLLECTION,
@@ -39656,6 +40095,7 @@ var PlateStore = class {
 					collection: PLATES_COLLECTION,
 					key: row.id
 				});
+				removed++;
 			} catch (err) {
 				this.logger.warn("PlateStore.deleteByTracks delete failed", { meta: {
 					plateId: row.id,
@@ -39668,6 +40108,11 @@ var PlateStore = class {
 				error: String(err)
 			} });
 		}
+		return [{
+			family: "plates",
+			rows: removed,
+			bytes: 0
+		}];
 	}
 	/**
 	* Hold the unassigned plate buffer to `maxPerDevice` newest reads per camera.
@@ -40789,6 +41234,36 @@ var TrackStore = class {
 	dropActive(trackId) {
 		this.active.delete(trackId);
 	}
+	/**
+	* Close a still-ACTIVE track NOW: persist its row, then drop the in-RAM
+	* entry. The early-close counterpart of {@link expireStale}, for a caller
+	* that knows the track is over before its TTL says so.
+	*
+	* **This exists because {@link dropActive} orphans everything the track
+	* owns.** A track's media, object events and CLIP vector are keyed by trackId
+	* and written throughout its life; the ROW is what retention cascades from,
+	* and it is written only here or at expiry. Forgetting a lived-in track
+	* therefore leaves a full media set — key frame, thumbnail, first/last frame,
+	* the snapshot filmstrip — with no owner any sweep can ever reach. Measured on
+	* the live hub 2026-08-14: 74,700 such media rows, 18.9 GB, growing
+	* ~1.15 GB/day, plus 23,296 object events and 4,543 CLIP vectors (D161).
+	*
+	* `dropActive` is still correct for a birth RETRACTED before it lived —
+	* nothing has been written under that id yet. It is never correct for a track
+	* that ran.
+	*
+	* Returns whether an active entry was found. THROWS if the persist fails: the
+	* caller must log it, because a swallowed failure here IS the leak.
+	*/
+	async closeActive(trackId) {
+		const t = this.active.get(trackId);
+		if (t === void 0) return false;
+		t.active = false;
+		const record = cloneTrack(t);
+		await this.persistCompleted(record);
+		this.active.delete(trackId);
+		return true;
+	}
 	/** 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) {
@@ -42139,6 +42614,7 @@ async function auditScope(scope, deps, limits, cursor) {
 				} });
 			}
 		}
+		if (deps.breathe) await deps.breathe();
 		if (ceilingHit) {
 			stoppedBy = "reclaim-ceiling";
 			offset += rows.length - reclaimedInPage;
@@ -46914,7 +47390,11 @@ var ObjectEmbeddingStore = class {
 	* breaks recognition (design §2/§4).
 	*/
 	async deleteByTracks(trackIds) {
-		if (trackIds.length === 0) return;
+		if (trackIds.length === 0) return [{
+			family: "embeddings",
+			rows: 0,
+			bytes: 0
+		}];
 		try {
 			await this.vectorStore.deleteByIds.mutate({
 				index: OBJECT_CLIP_INDEX,
@@ -46925,7 +47405,17 @@ var ObjectEmbeddingStore = class {
 				count: trackIds.length,
 				error: String(err)
 			} });
+			return [{
+				family: "embeddings",
+				rows: 0,
+				bytes: 0
+			}];
 		}
+		return [{
+			family: "embeddings",
+			rows: trackIds.length,
+			bytes: 0
+		}];
 	}
 };
 /** Build the vector-store metadata for one embedding. */
@@ -47799,7 +48289,8 @@ var NO_PUBLICATION = {
 var customActions = {
 	...ncActions,
 	...embeddingActions,
-	...debugActions
+	...debugActions,
+	...orphanAuditActions
 };
 /**
 * Assist threshold when the caller does not pin one. Packages have their own
@@ -48777,7 +49268,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				customActions: {
 					...ncActions,
 					...embeddingActions,
-					...debugActions
+					...debugActions,
+					...orphanAuditActions
 				},
 				actionHandlers: {
 					...ncHandlers,
@@ -49495,6 +49987,14 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				}
 				return out;
 			},
+			readSceneStates: () => (this.sceneProvider?.listAllEnabled() ?? []).map(({ deviceId, monitor }) => ({
+				sceneId: monitor.id,
+				deviceId,
+				label: monitor.label,
+				verdict: monitor.verdict,
+				latched: monitor.latched,
+				emit: monitor.emit
+			})),
 			readOccupancySnapshots: async (deviceIds) => {
 				const za = this.zoneAnalytics;
 				if (za === null) return /* @__PURE__ */ new Map();
@@ -50293,6 +50793,16 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					data: payload
 				});
 			},
+			onSceneEdge: (edge) => {
+				this.notificationCenter?.onSceneEdge({
+					sceneId: edge.monitorId,
+					deviceId: edge.deviceId,
+					label: edge.monitorLabel,
+					verdict: edge.verdict,
+					latched: edge.latched,
+					emit: edge.emit
+				});
+			},
 			currentCondition: async (deviceId) => resolveCondition({
 				...await this.sceneConditionContext(deviceId),
 				now: /* @__PURE__ */ new Date()
@@ -50301,6 +50811,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		provider.hydrate();
 		this.sceneProvider = provider;
+		this.notificationCenter?.refreshSceneStates();
 		if (!this.isPostProcessingNode) {
 			log.info("scene evaluation INERT on this node — CRUD only");
 			return;
@@ -52762,7 +53273,17 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		};
 		if (plausible) this.stationaryRegistry?.promote(entry);
 		processor.dropTrack(track.trackId);
-		this.trackStore?.dropActive(track.trackId);
+		this.trackStore?.closeActive(track.trackId).catch((err) => {
+			this.ctx.logger.warn("stationary promotion: closing the source track failed — its media, events and vector are now unowned", {
+				tags: { deviceId },
+				meta: {
+					deviceId,
+					trackId: track.trackId,
+					entryId: entry.id,
+					error: String(err)
+				}
+			});
+		});
 		const faceEnd = this.faceRecognizer?.onTrackEnd(deviceId, track.trackId);
 		const dropKeyFrame = () => {
 			this.residents.dropKeyFrameKey(track.trackId);
@@ -53352,19 +53873,19 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* stops at a per-scope row ceiling, RESUMES from a persisted cursor next run,
 	* and refuses to start if the previous run has not finished.
 	*/
-	async runOrphanAuditPass() {
-		if (this.shuttingDown) return;
+	async runOrphanAuditPass(overrides) {
+		if (this.shuttingDown) return null;
 		if (this.orphanAuditRunning) {
 			this.ctx.logger.info("analytics orphan audit skipped — previous run still in flight");
-			return;
+			return null;
 		}
 		const trackStore = this.trackStore;
 		const eventStore = this.eventStore;
 		const mediaStore = this.mediaStore;
-		if (!trackStore || !eventStore || !mediaStore) return;
+		if (!trackStore || !eventStore || !mediaStore) return null;
 		this.orphanAuditRunning = true;
 		try {
-			const limits = await this.orphanAuditLimits();
+			const limits = await this.orphanAuditLimits(overrides);
 			const deps = {
 				page: async (collection, offset, limit) => {
 					if (collection === "pipeline-analytics:media") return mediaStore.pageForAudit(offset, limit);
@@ -53396,13 +53917,14 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					});
 				},
 				now: () => Date.now(),
-				logger: this.ctx.logger
+				logger: this.ctx.logger,
+				breathe: () => new Promise((resolve) => setImmediate(resolve))
 			};
 			const { report, cursors } = await runOrphanAudit({
 				scopes: buildOrphanScopes(),
 				deps,
 				limits,
-				cursors: this.orphanAuditCursors
+				cursors: overrides?.restart === true ? /* @__PURE__ */ new Map() : this.orphanAuditCursors
 			});
 			this.orphanAuditCursors = cursors;
 			for (const scope of report.scopes) {
@@ -53437,8 +53959,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				bytesReclaimed: report.totalBytesReclaimed,
 				detail: `orphan audit (${report.mode}): ${report.totalOrphans} orphaned rows across ${report.scopes.length} collections, ${report.totalReclaimed} reclaimed in ${report.durationMs}ms`
 			});
+			return report;
 		} catch (err) {
 			this.ctx.logger.warn("analytics orphan audit failed", { meta: { error: String(err) } });
+			return null;
 		} finally {
 			this.orphanAuditRunning = false;
 		}
@@ -53501,15 +54025,65 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* raising them is raising the blast radius of a bug, and that should take a
 	* release.
 	*/
-	async orphanAuditLimits() {
+	async orphanAuditLimits(overrides) {
 		const mode = await this.orphanAuditModeState.get();
 		const pageSize = await this.orphanAuditPageSizeState.get();
+		const graceMinutes = overrides?.graceMinutes;
 		return {
-			mode: mode === "reclaim" ? "reclaim" : "report",
-			graceMs: DEFAULT_ORPHAN_LIMITS.graceMs,
-			pageSize,
-			maxRowsPerScope: DEFAULT_ORPHAN_LIMITS.maxRowsPerScope,
-			maxReclaimPerScope: DEFAULT_ORPHAN_LIMITS.maxReclaimPerScope
+			mode: overrides !== void 0 ? overrides.mode ?? "report" : mode === "reclaim" ? "reclaim" : "report",
+			graceMs: graceMinutes === void 0 ? DEFAULT_ORPHAN_LIMITS.graceMs : graceMinutes * 6e4,
+			pageSize: overrides?.pageSize ?? pageSize,
+			maxRowsPerScope: overrides?.maxRowsPerScope ?? DEFAULT_ORPHAN_LIMITS.maxRowsPerScope,
+			maxReclaimPerScope: overrides?.maxReclaimPerScope ?? DEFAULT_ORPHAN_LIMITS.maxReclaimPerScope
+		};
+	}
+	/**
+	* One operator-driven orphan-audit pass — the entry point behind
+	* `retention.orphanAudit`.
+	*
+	* DRY RUN BY DEFAULT: an input with no `mode` reports and deletes nothing,
+	* whatever `orphanAuditMode` is set to. Reclaiming is a word the caller has to
+	* type. Draining the standing 18.9 GB means running this with
+	* `mode: 'reclaim'` repeatedly until `totalOrphans` reaches 0 (D161).
+	*/
+	async runOrphanAuditNow(overrides) {
+		const report = await this.runOrphanAuditPass(overrides);
+		if (report === null) return {
+			ran: false,
+			mode: overrides.mode ?? "report",
+			scopes: [],
+			totalOrphans: 0,
+			totalReclaimed: 0,
+			totalBytesReclaimed: 0,
+			durationMs: 0
+		};
+		this.ctx.logger.info("analytics orphan audit (operator)", { meta: {
+			mode: report.mode,
+			orphans: report.totalOrphans,
+			reclaimed: report.totalReclaimed,
+			bytesReclaimed: report.totalBytesReclaimed,
+			durationMs: report.durationMs,
+			restart: overrides.restart === true
+		} });
+		return {
+			ran: true,
+			mode: report.mode,
+			scopes: report.scopes.map((scope) => ({
+				collection: scope.collection,
+				examined: scope.examined,
+				orphans: scope.orphans,
+				reclaimed: scope.reclaimed,
+				bytesReclaimed: scope.bytesReclaimed,
+				exempt: scope.exempt,
+				withinGrace: scope.withinGrace,
+				unresolvable: scope.unresolvable,
+				stoppedBy: scope.stoppedBy,
+				nextCursor: scope.nextCursor
+			})),
+			totalOrphans: report.totalOrphans,
+			totalReclaimed: report.totalReclaimed,
+			totalBytesReclaimed: report.totalBytesReclaimed,
+			durationMs: report.durationMs
 		};
 	}
 	/**
@@ -53709,7 +54283,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					indexed
 				};
 			},
-			"embedding.wipe": async () => this.wipeObjectEmbeddings()
+			"embedding.wipe": async () => this.wipeObjectEmbeddings(),
+			"retention.orphanAudit": async (input) => this.runOrphanAuditNow(input)
 		};
 	}
 	/** Progress of the detached rebuild — the only way to observe a long pass. */
@@ -53968,8 +54543,14 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* 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).
+	* §4).
+	*
+	* **Every family count here is REAL.** It used to return `tracks` and a
+	* literal 0 for every leaf, because `TrackScopedStore.deleteByTracks` returned
+	* `void` — so `bytesReclaimed: 0` went onto all 3,732 ops-log rows this addon
+	* had ever written and 18.9 GB of leaked media read as "nothing to reclaim"
+	* (D161). The bytes ride {@link lastPruneBytes} rather than
+	* `TrackCascadeCounts`, which is a cap output shape.
 	*/
 	async pruneTracksBefore(input) {
 		const empty = {
@@ -53980,26 +54561,32 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			plates: 0,
 			embeddings: 0
 		};
+		this.lastPruneBytes = 0;
 		const cascade = this.buildTrackCascadeRegistry();
 		if (!cascade) return empty;
+		let tally = EMPTY_CASCADE_TALLY;
 		const { deleted: totalDeleted, skipped } = await drainTracksBefore({
 			stopped: () => this.shuttingDown,
 			listIdsBefore: (offset, limit) => cascade.trackStore.listIdsBefore(input.deviceId, input.cutoffMs, limit, offset),
-			cascade: (ids) => 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", {
-						tags: { deviceId: input.deviceId },
-						meta: {
-							trackId,
-							error: String(err)
-						}
-					});
-				}
-			}, ids)
+			cascade: async (ids) => {
+				const result = 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", {
+							tags: { deviceId: input.deviceId },
+							meta: {
+								trackId,
+								error: String(err)
+							}
+						});
+					}
+				}, ids);
+				tally = mergeCascadeTallies(tally, result.tally);
+				return { deleted: result.deleted };
+			}
 		});
 		if (skipped > 0) this.ctx.logger.warn("analytics track retention skipped undeletable rows", {
 			tags: { deviceId: input.deviceId },
@@ -54010,20 +54597,41 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				pruned: totalDeleted
 			}
 		});
+		this.lastPruneBytes = tally.bytesReclaimed;
 		if (totalDeleted > 0) this.ctx.logger.info("analytics track retention prune", {
 			tags: { deviceId: input.deviceId },
 			meta: {
 				deviceId: input.deviceId,
 				cutoffMs: input.cutoffMs,
-				tracks: totalDeleted
+				tracks: totalDeleted,
+				events: tally.events,
+				media: tally.media,
+				faces: tally.faces,
+				plates: tally.plates,
+				embeddings: tally.embeddings,
+				bytesReclaimed: tally.bytesReclaimed
 			}
 		});
 		return {
 			...empty,
-			tracks: totalDeleted
+			tracks: totalDeleted,
+			events: tally.events,
+			media: tally.media,
+			faces: tally.faces,
+			plates: tally.plates,
+			embeddings: tally.embeddings
 		};
 	}
 	/**
+	* Bytes released by the most recent {@link pruneTracksBefore}.
+	*
+	* A field rather than a return value because `TrackCascadeCounts` is a cap
+	* OUTPUT shape and widening it is a codegen change; the ops-log row already
+	* has a `bytesReclaimed` column and this is what fills it. Reset to 0 at the
+	* top of every prune, so a stale value can never be reported as a fresh one.
+	*/
+	lastPruneBytes = 0;
+	/**
 	* 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.
@@ -54077,8 +54685,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 						reason: "retention",
 						deviceId,
 						itemsAffected: counts.tracks,
-						bytesReclaimed: 0,
-						detail: `track retention cascade: ${counts.tracks} tracks, ${counts.events} events, ${counts.media} media`
+						bytesReclaimed: this.lastPruneBytes,
+						detail: `track retention cascade: ${counts.tracks} tracks, ${counts.events} events, ${counts.media} media, ${counts.faces} faces, ${counts.plates} plates, ${counts.embeddings} vectors`
 					});
 					return counts;
 				},