@camstack/addon-post-analysis 1.2.154 → 1.2.156

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as audioMetricsCapability, A as NcSnoozeInputSchema, At as errMsg, B as SCENE_DEFAULT_ANCHOR_THRESHOLD, Bt as boolean, C as NC_TAXONOMY, D as NcRuleSchema, Dt as vectorDimFromBase64, E as NcRulePatchSchema, Et as systemEventFilterApplies, F as OpsLogEntrySchema, Ft as isDeviceScopedCap, G as TimelapseRuleInputSchema, Gt as partialRecord, H as SCENE_DIVERGED, Ht as literal, It as nodePin, J as TrackSourceSchema, Jt as unknown, K as TimelapseRulePatchSchema, Kt as record, L as RECORDING_EXPORT_MAX_READ_BYTES, Lt as sleep, M as NcSnoozeSuppressedSchema, Mt as DeviceType, N as NcSystemEventKindSchema, Nt as createEvent, O as NcRuleTargetSchema, Ot as videoclipsCapability, P as NcTaxonomySchema, Pt as hydrateSchema, Q as assertTimelapseCadences, R as RetrainStatusSchema, Rt as _enum, St as readTimelapseGeneratedAt, T as NcRuleInputSchema, Tt as subKindsOf, U as SceneMonitorSchema, Ut as number, V as SCENE_DEFAULT_UNCOVERED_POLICY, Vt as discriminatedUnion, W as TIMELAPSE_DENSE_FLOOR_SEC, Wt as object, X as addonWidgetsSourceCapability, Y as VISIT_MERGE_GAP_MS, Yt as EventCategory, Z as alarmPanelCapability, _ as MACRO_LABELS, a as COCO_TO_MACRO, at as deriveRecordingMode, b as NC_CONDITION_CATALOG, bt as plateGalleryCapability, ct as evaluateSensorEdge, d as DeclaredDevices, et as audioModeOf, f as EVENT_KIND_BY_CAP, ft as isDetectionMacroClass, g as LabelAttributionSchema, gt as notificationRulesCapability, h as FailureCounters, ht as kebabToCamel, i as CLUSTER_MODEL_SCOPED_STEPS, it as defineCustomActions, j as NcSnoozeSchema, jt as BaseAddon, k as NcScheduleSchema, kt as zoneAnalyticsCapability, l as DETECTION_MACRO_CLASSES, lt as faceGalleryCapability, m as FULL_IMAGE_BBOX, mt as isSourceCap, n as AnalyticsGroupRecordSchema, nt as cosineSimilarity$1, o as DEFAULT_EVENT_COLOR, p as EVENT_PAD_MS, pt as isScheduleActive, q as TimelapseRuleSchema, qt as string, r as BaseDevice, rt as customAction, st as encodeVectorBase64, t as AnalyticsGroupDetailSchema, tt as buildEventKindDescriptor, ut as failureContributionCapability, v as MediaFileKindEnum, vt as pickClusterStepModels, w as NcConditionDescriptorSchema, wt as sceneMonitorCapability, x as NC_DEFAULT_SNOOZE_MINUTES, xt as readDeviceStateFrom, y as NC_ALARM_SYSTEM_EVENT_KINDS, yt as pipelineAnalyticsCapability, zt as array } from "../dist-D6iC--Gh.mjs";
+import { $ as audioMetricsCapability, A as NcSnoozeInputSchema, At as errMsg, B as SCENE_DEFAULT_ANCHOR_THRESHOLD, Bt as boolean, C as NC_TAXONOMY, D as NcRuleSchema, Dt as vectorDimFromBase64, E as NcRulePatchSchema, Et as systemEventFilterApplies, F as OpsLogEntrySchema, Ft as isDeviceScopedCap, G as TimelapseRuleInputSchema, Gt as partialRecord, H as SCENE_DIVERGED, Ht as literal, It as nodePin, J as TrackSourceSchema, Jt as unknown, K as TimelapseRulePatchSchema, Kt as record, L as RECORDING_EXPORT_MAX_READ_BYTES, Lt as sleep, M as NcSnoozeSuppressedSchema, Mt as DeviceType, N as NcSystemEventKindSchema, Nt as createEvent, O as NcRuleTargetSchema, Ot as videoclipsCapability, P as NcTaxonomySchema, Pt as hydrateSchema, Q as assertTimelapseCadences, R as RetrainStatusSchema, Rt as _enum, St as readTimelapseGeneratedAt, T as NcRuleInputSchema, Tt as subKindsOf, U as SceneMonitorSchema, Ut as number, V as SCENE_DEFAULT_UNCOVERED_POLICY, Vt as discriminatedUnion, W as TIMELAPSE_DENSE_FLOOR_SEC, Wt as object, X as addonWidgetsSourceCapability, Y as VISIT_MERGE_GAP_MS, Yt as EventCategory, Z as alarmPanelCapability, _ as MACRO_LABELS, a as COCO_TO_MACRO, at as deriveRecordingMode, b as NC_CONDITION_CATALOG, bt as plateGalleryCapability, ct as evaluateSensorEdge, d as DeclaredDevices, et as audioModeOf, f as EVENT_KIND_BY_CAP, ft as isDetectionMacroClass, g as LabelAttributionSchema, gt as notificationRulesCapability, h as FailureCounters, ht as kebabToCamel, i as CLUSTER_MODEL_SCOPED_STEPS, it as defineCustomActions, j as NcSnoozeSchema, jt as BaseAddon, k as NcScheduleSchema, kt as zoneAnalyticsCapability, l as DETECTION_MACRO_CLASSES, lt as faceGalleryCapability, m as FULL_IMAGE_BBOX, mt as isSourceCap, n as AnalyticsGroupRecordSchema, nt as cosineSimilarity$1, o as DEFAULT_EVENT_COLOR, p as EVENT_PAD_MS, pt as isScheduleActive, q as TimelapseRuleSchema, qt as string, r as BaseDevice, rt as customAction, st as encodeVectorBase64, t as AnalyticsGroupDetailSchema, tt as buildEventKindDescriptor, ut as failureContributionCapability, v as MediaFileKindEnum, vt as pickClusterStepModels, w as NcConditionDescriptorSchema, wt as sceneMonitorCapability, x as NC_DEFAULT_SNOOZE_MINUTES, xt as readDeviceStateFrom, y as NC_ALARM_SYSTEM_EVENT_KINDS, yt as pipelineAnalyticsCapability, zt as array } from "../dist-DqNo8CCq.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs from "node:fs";
 import { promises } from "node:fs";
@@ -107,6 +107,7 @@ function actionTtlMs(subject) {
 		case "alarm": return subject.action === "disarm" ? ALARM_DISARM_TTL_MS : DEFAULT_ACTION_TTL_MS;
 		case "sequence": return DEFAULT_ACTION_TTL_MS;
 		case "addon-update": return DEFAULT_ACTION_TTL_MS;
+		case "server-update": return DEFAULT_ACTION_TTL_MS;
 	}
 }
 var NcActionTokenRegistry = class {
@@ -176,9 +177,9 @@ var NcActionTokenRegistry = class {
 /**
 * What a spent grant DID, in the operator's own terms.
 *
-* Per `kind`, because the three families answer different questions and one
+* Per `kind`, because the families answer different questions and one
 * generic "Done" would leave a snooze indistinguishable from an open gate on
-* the page a tap lands on. The switch is exhaustive by construction — a fourth
+* the page a tap lands on. The switch is exhaustive by construction — a new
 * grant family will not compile until it has a sentence here.
 */
 function describeGrant(grant) {
@@ -187,6 +188,7 @@ function describeGrant(grant) {
 		case "snooze": return grant.classes === void 0 || grant.classes.length === 0 ? `Silenced for ${grant.minutes} min` : `Silenced for ${grant.minutes} min — ${grant.classes.join(", ")}`;
 		case "alarm": return grant.action === "disarm" ? "Alarm disarmed" : `Alarm armed${grant.mode !== void 0 ? ` (${grant.mode})` : ""}`;
 		case "addon-update": return `${grant.packages.length} addon update(s) on ${grant.nodeId}`;
+		case "server-update": return `Server update on ${grant.nodeId}`;
 	}
 }
 /** The audit line's `meta`, per family. A snooze that logged a `sequence` it
@@ -222,6 +224,10 @@ function grantMeta(grant) {
 			nodeId: grant.nodeId,
 			packages: grant.packages
 		};
+		case "server-update": return {
+			...common,
+			nodeId: grant.nodeId
+		};
 	}
 }
 /** What the human standing in front of the page is told. */
@@ -5508,6 +5514,37 @@ function buildAddonUpdateButtons(input) {
 	}];
 }
 //#endregion
+//#region src/notification-center/server-update-buttons.ts
+/** The id this button travels under — in the callback and in the audit line. */
+var SERVER_UPDATE_BUTTON_ID = "server-update-apply";
+function serverUpdateButtonRefusal(subject, recipient) {
+	if (subject.kind !== "server-update-available") return "not-a-server-update";
+	if (subject.nodeId === void 0) return "several-nodes";
+	if (recipient.ownerUserId === void 0) return "unowned-target";
+	return null;
+}
+/**
+* The button, or none.
+*
+* Returns an array rather than a nullable, so the caller composes it with the
+* other families by spreading — and so "which buttons survived" has one shape.
+*/
+function buildServerUpdateButtons(input) {
+	const subject = input.subject;
+	if (serverUpdateButtonRefusal(subject, input.recipient) !== null) return [];
+	const nodeId = subject.nodeId ?? "";
+	return [{
+		id: SERVER_UPDATE_BUTTON_ID,
+		label: input.label({ nodeId }),
+		url: input.mintUrl({
+			actionId: SERVER_UPDATE_BUTTON_ID,
+			nodeId
+		}),
+		destructive: true,
+		mode: "background"
+	}];
+}
+//#endregion
 //#region src/notification-center/audio-rule-matcher.ts
 /**
 * AudioWatcher — the Notification Center's matcher for audio rules
@@ -8589,6 +8626,13 @@ var en_default = {
 	"action.addon-update.partial": "{{nodeId}}: {{applied}} updated, {{skipped}} already current, {{failed}} failed",
 	"action.addon-update.uptodate": "Already up to date on {{nodeId}} — nothing to do",
 	"action.addon-update.unknown": "Could not read what needs updating on {{nodeId}} — nothing was changed. Open CamStack.",
+	"button.server-update.apply": "Update server on {{nodeId}}",
+	"action.server-update.title": "Server update",
+	"action.server-update.started": "Updating server on {{nodeId}}…",
+	"action.server-update.restarting": "Server update staged on {{nodeId}} — the node is restarting. You will hear when it comes back.",
+	"action.server-update.uptodate": "Already up to date on {{nodeId}} — nothing to do",
+	"action.server-update.unknown": "Could not read whether {{nodeId}} still needs a server update — nothing was changed. Open CamStack.",
+	"action.server-update.failed": "Server update on {{nodeId}} was refused — nothing was changed. Open CamStack.",
 	"summary.title": "Summary — {{rule}}",
 	"summary.body.window": "{{from}}→{{to}}",
 	"summary.body.events": {
@@ -8827,6 +8871,13 @@ var it_default = {
 	"action.addon-update.partial": "{{nodeId}}: {{applied}} aggiornati, {{skipped}} già aggiornati, {{failed}} falliti",
 	"action.addon-update.uptodate": "Già aggiornato su {{nodeId}} — niente da fare",
 	"action.addon-update.unknown": "Non è stato possibile leggere cosa aggiornare su {{nodeId}} — non è stato cambiato nulla. Apri CamStack.",
+	"button.server-update.apply": "Aggiorna server su {{nodeId}}",
+	"action.server-update.title": "Aggiornamento server",
+	"action.server-update.started": "Aggiornamento server su {{nodeId}}…",
+	"action.server-update.restarting": "Aggiornamento server predisposto su {{nodeId}} — il nodo si riavvia. Ti avviseremo quando torna.",
+	"action.server-update.uptodate": "Già aggiornato su {{nodeId}} — niente da fare",
+	"action.server-update.unknown": "Non è stato possibile leggere se {{nodeId}} ha ancora bisogno di un aggiornamento server — non è stato cambiato nulla. Apri CamStack.",
+	"action.server-update.failed": "L'aggiornamento server su {{nodeId}} è stato rifiutato — non è stato cambiato nulla. Apri CamStack.",
 	"summary.title": "Riepilogo — {{rule}}",
 	"summary.body.window": "{{from}}→{{to}}",
 	"summary.body.events": {
@@ -20367,6 +20418,41 @@ var NotificationCenter = class NotificationCenter {
 				packages: systemEvent?.packageNames ?? []
 			}
 		});
+		const serverRefusal = systemEvent === void 0 ? "not-a-server-update" : serverUpdateButtonRefusal(systemEvent, recipient);
+		const serverButtons = systemEvent === void 0 ? [] : buildServerUpdateButtons({
+			subject: systemEvent,
+			recipient,
+			label: ({ nodeId }) => this.texts.text({
+				key: "button.server-update.apply",
+				vars: { nodeId }
+			}),
+			mintUrl: ({ actionId, nodeId }) => {
+				const id = randomUUID();
+				drafts.push({
+					id,
+					ttlMs: actionTtlMs({ kind: "server-update" }),
+					grant: (expiresAt) => ({
+						kind: "server-update",
+						id,
+						nodeId,
+						deviceId: input.deviceId,
+						actionId,
+						targetId: input.targetId,
+						expiresAt
+					})
+				});
+				return id;
+			}
+		});
+		if (serverRefusal === "several-nodes" || serverRefusal === "unowned-target") this.logger.info("server-update notification carries no apply button", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				ruleId: input.ruleId,
+				reason: serverRefusal,
+				targetId: input.targetId,
+				nodeIds: systemEvent?.nodeIds ?? []
+			}
+		});
 		if (alarmKind !== null && panel === null) this.logger.info("alarm notification carries no buttons — this node owns no panel", {
 			tags: { deviceId: input.deviceId },
 			meta: {
@@ -20378,7 +20464,8 @@ var NotificationCenter = class NotificationCenter {
 			...sequenceButtons,
 			...snoozeButtons,
 			...alarmButtons,
-			...updateButtons
+			...updateButtons,
+			...serverButtons
 		];
 		if (out.length === 0) return [];
 		const now = this.now();
@@ -20500,6 +20587,7 @@ var NotificationCenter = class NotificationCenter {
 			case "alarm": return this.applyGrantedAlarm(grant);
 			case "sequence": return this.runGrantedSequence(grant);
 			case "addon-update": return this.applyGrantedAddonUpdate(grant);
+			case "server-update": return this.applyGrantedServerUpdate(grant);
 		}
 	}
 	/**
@@ -20610,6 +20698,80 @@ var NotificationCenter = class NotificationCenter {
 		if (applied.length === 0 && failed.length > 0) throw new Error(`no package updated on ${grant.nodeId} (${failed.join(", ")})`);
 	}
 	/**
+	* Stage the server update one notification was about.
+	*
+	* The shape matches the addon-update runner, with one extra constraint: the
+	* **start announcement leaves BEFORE apply**. Applying the hub kills this
+	* process; a tap that went into silence because the process died mid-apply
+	* is worse than no button. The reboot itself is confirmed by the existing
+	* `server-updated` event on reconnect — this method does not wait for it.
+	*
+	* Throws when nothing was staged and something went wrong, so the plane's
+	* line says the run failed rather than reporting a spent token as a success.
+	*/
+	async applyGrantedServerUpdate(grant) {
+		const apply = this.deps.applyServerUpdate;
+		const check = this.deps.checkServerUpdate;
+		if (apply === void 0 || check === void 0) throw new Error("no server updater is wired on this node");
+		let stillAvailable;
+		try {
+			stillAvailable = await check(grant.nodeId);
+		} catch (err) {
+			this.logger.warn("server update button changed nothing — could not read whether an update is still needed", { meta: {
+				nodeId: grant.nodeId,
+				error: String(err)
+			} });
+			await this.announceServerUpdate(grant, "unknown", { nodeId: grant.nodeId });
+			throw err instanceof Error ? err : new Error(String(err));
+		}
+		if (!stillAvailable) {
+			this.logger.info("server update button applied nothing — already current", { meta: { nodeId: grant.nodeId } });
+			await this.announceServerUpdate(grant, "uptodate", { nodeId: grant.nodeId });
+			return;
+		}
+		await this.announceServerUpdate(grant, "started", { nodeId: grant.nodeId });
+		let result;
+		try {
+			result = await apply({ nodeId: grant.nodeId });
+		} catch (err) {
+			this.logger.warn("server update from a notification button threw", { meta: {
+				nodeId: grant.nodeId,
+				error: String(err)
+			} });
+			await this.announceServerUpdate(grant, "failed", { nodeId: grant.nodeId });
+			throw err instanceof Error ? err : new Error(String(err));
+		}
+		if (!result.ok) {
+			this.logger.warn("server update from a notification button was refused", { meta: {
+				nodeId: grant.nodeId,
+				error: result.error
+			} });
+			await this.announceServerUpdate(grant, "failed", { nodeId: grant.nodeId });
+			throw new Error(result.error);
+		}
+		this.logger.info("server update staged from a notification button", { meta: { nodeId: grant.nodeId } });
+		await this.announceServerUpdate(grant, "restarting", { nodeId: grant.nodeId });
+	}
+	/**
+	* One sentence about a server-update tap, to the target the notification
+	* went to. Best-effort — `deliverAnnouncement` never throws — because an
+	* announcement that failed must not turn a staging that HAPPENED into a run
+	* the plane reports as failed.
+	*/
+	async announceServerUpdate(grant, sentence, vars) {
+		const targetId = grant.targetId;
+		if (targetId === void 0) return;
+		await this.dispatcher.deliverAnnouncement({
+			reason: `server-update-${sentence}`,
+			targetId,
+			title: this.texts.text({ key: "action.server-update.title" }),
+			body: this.texts.text({
+				key: `action.server-update.${sentence}`,
+				vars
+			})
+		});
+	}
+	/**
 	* One sentence about an update tap, to the target the notification went to.
 	*
 	* Best-effort by construction — `deliverAnnouncement` never throws and never
@@ -26073,7 +26235,7 @@ var DEFAULT_MEDIA_LOCATION = "eventMedia";
 * whose contract is disposal.** The gallery's row lives on the data volume;
 * its blob belongs there too, and now does. See D197.
 */
-var GALLERY_MEDIA_LOCATION = "galleryMedia";
+var GALLERY_MEDIA_LOCATION = "addon-data";
 /**
 * The location a new blob is written to, derived from its owner kind.
 *
@@ -26970,7 +27132,7 @@ var MediaStore = class {
 			for (const row of rows) {
 				const data = row.data;
 				const from = mediaRowLocation(data);
-				if (from === "galleryMedia") continue;
+				if (from === "addon-data") continue;
 				const relativePath = String(data["path"] ?? "");
 				const deviceId = Number(data["deviceId"]);
 				if (relativePath.length === 0) continue;
@@ -35913,6 +36075,7 @@ async function runMediaReclaim(input) {
 		byteBudget -= report.bytesReclaimed;
 		nextCursors.set(key, report.stoppedBy === "exhausted" ? 0 : report.nextCursor);
 		devices.push(report);
+		input.onDevice?.(report);
 		if (report.examined > 0 || report.refused > 0) input.deps.logger.info("media reclaim window", {
 			tags: { deviceId },
 			meta: {
@@ -35947,33 +36110,10 @@ async function runMediaReclaim(input) {
 		cursors: nextCursors
 	};
 }
-//#endregion
-//#region src/pipeline-analytics/retention/media-reclaim-actions.ts
-/**
-* The operator button for the debug-media reclaim.
-*
-* The mechanism ships armed with nothing: **arming it is the operator's
-* call**. `mode` omitted means `report` — it counts, logs one line per camera
-* and returns rows/bytes per device, and deletes nothing. `reclaim` is a word
-* that has to be typed.
-*
-* Everything about the shape is borrowed from `orphan-audit-actions.ts`, which
-* earned it: dry-run default, explicit pacing, explicit blast radius, and a
-* report you can read instead of a log line you have to find.
-*/
-/**
-* `report` counts; `reclaim` deletes.
-*
-* `.default('report')` is load-bearing: the settings form sends `{}` for a
-* button with no fields, and the safe reading of an unstated intent is the one
-* that destroys nothing.
-*/
-var MediaReclaimActionModeSchema = _enum(["report", "reclaim"]).default("report");
-var MediaReclaimScopeSchema = _enum(["motion-still", "track-filmstrip"]);
 var MediaReclaimActionInputSchema = object({
-	mode: MediaReclaimActionModeSchema,
+	mode: _enum(["report", "reclaim"]).default("report"),
 	/** Which populations to walk. Omitted = both. */
-	scopes: array(MediaReclaimScopeSchema).min(1).optional(),
+	scopes: array(_enum(["motion-still", "track-filmstrip"])).min(1).optional(),
 	/** Restrict to these cameras. Omitted = every camera in retention scope. */
 	deviceIds: array(number().int()).min(1).optional(),
 	/** Start every device from the top instead of resuming its cursor. */
@@ -36000,39 +36140,28 @@ var MediaReclaimActionInputSchema = object({
 	*/
 	graceMinutes: number().int().min(1).max(10080).optional()
 });
-var MediaReclaimDeviceReportSchema = object({
-	deviceId: number(),
-	scope: MediaReclaimScopeSchema,
-	examined: number(),
-	eligible: number(),
-	reclaimed: number(),
-	bytesReclaimed: number(),
-	/** Rows kept because the owning track is pinned (`staging`/`favourited`). */
-	held: number(),
-	/** Rows kept because the owner could not be shown to be a motion event. */
-	unresolved: number(),
-	withinGrace: number(),
-	/** Deletes that REFUSED — the blob survived or the volume could not answer.
-	*  The row was kept and the cursor did not pass it. */
-	refused: number(),
-	stoppedBy: string(),
-	/** Where the NEXT pass resumes. `0` = this device+scope was walked to the end. */
-	nextCursor: number()
+var MediaReclaimStartedSchema = object({
+	started: boolean(),
+	alreadyRunning: boolean()
 });
-var mediaReclaimActions = defineCustomActions({ "retention.mediaReclaim": customAction(MediaReclaimActionInputSchema, object({
-	/** `false` when a pass was already in flight — nothing was done. */
-	ran: boolean(),
-	mode: _enum(["report", "reclaim"]),
-	devices: array(MediaReclaimDeviceReportSchema),
+var MediaReclaimStatusSchema = object({
+	running: boolean(),
+	mode: _enum(["report", "reclaim"]).nullable(),
 	totalExamined: number(),
 	totalEligible: number(),
 	totalReclaimed: number(),
 	totalBytesReclaimed: number(),
 	totalRefused: number(),
-	durationMs: number(),
-	/** Every device+scope reported `exhausted` — there is nothing left to do. */
-	complete: boolean()
-}), { auth: "admin" }) });
+	devicesDone: number(),
+	complete: boolean().nullable(),
+	startedAtMs: number().nullable(),
+	finishedAtMs: number().nullable(),
+	error: string().nullable()
+});
+var mediaReclaimActions = defineCustomActions({
+	"retention.mediaReclaim": customAction(MediaReclaimActionInputSchema, MediaReclaimStartedSchema, { auth: "admin" }),
+	"retention.mediaReclaimStatus": customAction(object({}), MediaReclaimStatusSchema, { auth: "admin" })
+});
 var OrphanAuditActionInputSchema = object({
 	mode: _enum(["report", "reclaim"]).default("report"),
 	/**
@@ -41087,6 +41216,7 @@ function createLocationAwareMediaStorage(deps) {
 	const roots = /* @__PURE__ */ new Map();
 	let defaultBypassInvalidated = false;
 	const rootOf = async (locationId) => {
+		if (deps.galleryLocationId !== void 0 && deps.galleryRoot !== void 0 && locationId === deps.galleryLocationId) return deps.galleryRoot;
 		const cached = roots.get(locationId);
 		if (cached !== void 0) return cached;
 		const root = await deps.resolveRoot(locationId);
@@ -43593,7 +43723,7 @@ var PhotoAnalysisSessions = class {
 *     a magnet that recognises every degraded probe as its owner, and 22 of 50
 *     live samples were enrolled that way on 2026-08-18;
 *  3. both blobs are written under `ownerKind: 'identity'`, which is what puts
-*     them on `galleryMedia` — the location a footage wipe cannot reach (D197);
+*     them in the addon data dir — the location a footage wipe cannot reach (D197);
 *  4. the row is written last, and if it does not land BOTH blobs are reclaimed.
 *     An orphan under `identity` is exempt from every sweep this repo has, so
 *     it would otherwise live forever.
@@ -64112,6 +64242,20 @@ var TIMELAPSE_TRACK_QUERY_LIMIT = 2e3;
 * window rather than a random slice of it.
 */
 var TIMELAPSE_EVENT_QUERY_LIMIT = 1e4;
+var IDLE_MEDIA_RECLAIM = {
+	running: false,
+	mode: null,
+	totalExamined: 0,
+	totalEligible: 0,
+	totalReclaimed: 0,
+	totalBytesReclaimed: 0,
+	totalRefused: 0,
+	devicesDone: 0,
+	complete: null,
+	startedAtMs: null,
+	finishedAtMs: null,
+	error: null
+};
 var PIPELINE_ANALYTICS_ADDON_ID = "pipeline-analytics";
 /** Artefact index ⇄ shelf reconcile cadence. Hourly: the two only drift on the
 *  bounds' own timescale (14 days / 2000 entries / 2 GiB). */
@@ -65227,9 +65371,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	*  In RAM like the audit's: the pass is resumable from zero at no cost
 	*  beyond re-walking a head that is already empty. */
 	mediaReclaimCursors = /* @__PURE__ */ new Map();
-	/** Single-flight latch — two concurrent passes would double the disk
-	*  pressure the pacing exists to avoid. */
-	mediaReclaimRunning = false;
+	/** Live state of the detached debug-media reclaim — see `reclaimDebugMedia`. */
+	mediaReclaimState = { ...IDLE_MEDIA_RECLAIM };
 	/**
 	* The vector-index leg's resume cursor, kept in its OWN field.
 	*
@@ -65669,6 +65812,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 		const routed = createLocationAwareMediaStorage({
 			base: storage,
 			defaultLocation: "eventMedia",
+			galleryLocationId: GALLERY_MEDIA_LOCATION,
+			galleryRoot: path.join(this.ctx.dataDir, "gallery"),
 			resolveRoot: (locationId) => this.ctx.api.storage.resolve.query({
 				location: locationId,
 				relativePath: ""
@@ -66345,6 +66490,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					};
 				}
 			},
+			checkServerUpdate: async (nodeId) => {
+				const result = await this.ctx.api.serverManagement.checkServerUpdate.mutate({ nodeId });
+				if (result.error) throw new Error(result.error);
+				return result.updateAvailable;
+			},
+			applyServerUpdate: async ({ nodeId }) => {
+				try {
+					const result = await this.ctx.api.serverManagement.applyServerUpdate.mutate({ nodeId });
+					if (!result.accepted) return {
+						ok: false,
+						error: result.message
+					};
+					return { ok: true };
+				} catch (err) {
+					return {
+						ok: false,
+						error: errMsg(err)
+					};
+				}
+			},
 			readDeviceStates: async (ids) => {
 				const out = /* @__PURE__ */ new Map();
 				for (const id of ids) try {
@@ -67277,19 +67442,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 	async reconcileGalleryMediaLocation() {
 		const mediaStore = this.mediaStore;
 		if (!mediaStore) return;
-		try {
-			await this.ctx.api.storage.resolve.query({
-				location: GALLERY_MEDIA_LOCATION,
-				relativePath: ""
-			});
-		} catch (err) {
-			this.ctx.logger.error("gallery media location is NOT available — enrolling a face, a plate or a scene reference will FAIL until it is", { meta: {
-				location: GALLERY_MEDIA_LOCATION,
-				error: errMsg(err),
-				hint: "the declaration is seeded when a storage-provider registers; restart this node so the manifest is re-read (D197). Refusing the write is deliberate — the alternative is the footage volume, which is where the last gallery was lost."
-			} });
-			return;
-		}
 		try {
 			const result = await mediaStore.relocateExemptMediaToGallery();
 			if (result.relocated === 0 && result.missing === 0 && result.failed === 0) return;
@@ -72358,42 +72510,58 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 			"embedding.reembedFaces": async (input) => this.runFaceReembedPass(input),
 			"embedding.reembedFacesStatus": async () => this.getFaceReembedStatus(),
 			"retention.orphanAudit": async (input) => this.runOrphanAuditNow(input),
-			"retention.mediaReclaim": async (input) => this.runMediaReclaimNow(input)
+			"retention.mediaReclaim": async (input) => this.reclaimDebugMedia(input),
+			"retention.mediaReclaimStatus": async () => this.getMediaReclaimStatus()
 		};
 	}
 	/**
-	* One operator-driven debug-media reclaim pass — the entry point behind
-	* `retention.mediaReclaim`.
-	*
-	* DRY RUN BY DEFAULT. Draining the standing 111 GB means running this with
-	* `mode: 'reclaim'` repeatedly until `complete` is true; each run resumes
-	* from the per-device cursors this method keeps, and a run that is cut short
-	* has still only forgotten rows whose blobs it proved gone.
+	* Start a debug-media reclaim pass. DETACHED.
 	*
-	* Single-flight: a second call while a pass is in flight returns
-	* `ran: false` rather than doubling the disk pressure the pacing exists to
-	* avoid.
+	* Returns `{ started }` immediately. The walk is tens of minutes at 2 MB/s;
+	* awaiting it is a timeout, not a verdict. Poll {@link getMediaReclaimStatus}.
+	* Dry-run unless `mode: 'reclaim'`. A second call while one is in flight is
+	* `alreadyRunning`, not a second walk on the same spindle.
 	*/
-	async runMediaReclaimNow(rawInput) {
+	async reclaimDebugMedia(rawInput) {
 		const input = MediaReclaimActionInputSchema.parse(rawInput);
+		if (this.mediaReclaimState.running) {
+			this.ctx.logger.info("debug-media reclaim already running — request ignored");
+			return {
+				started: false,
+				alreadyRunning: true
+			};
+		}
 		const mediaStore = this.mediaStore;
 		const eventStore = this.eventStore;
 		const trackStore = this.trackStore;
-		const empty = {
-			ran: false,
+		if (!mediaStore || !eventStore || !trackStore) {
+			this.ctx.logger.warn("reclaimDebugMedia: analytics stores unavailable");
+			return {
+				started: false,
+				alreadyRunning: false
+			};
+		}
+		this.mediaReclaimState = {
+			...IDLE_MEDIA_RECLAIM,
+			running: true,
 			mode: input.mode,
-			devices: [],
-			totalExamined: 0,
-			totalEligible: 0,
-			totalReclaimed: 0,
-			totalBytesReclaimed: 0,
-			totalRefused: 0,
-			durationMs: 0,
-			complete: false
+			startedAtMs: Date.now()
+		};
+		this.ctx.logger.info("debug-media reclaim starting", { meta: {
+			mode: input.mode,
+			restart: input.restart === true
+		} });
+		this.executeMediaReclaim(input, mediaStore, eventStore, trackStore);
+		return {
+			started: true,
+			alreadyRunning: false
 		};
-		if (!mediaStore || !eventStore || !trackStore) return empty;
-		if (this.mediaReclaimRunning) return empty;
-		this.mediaReclaimRunning = true;
+	}
+	/**
+	* The walk itself. Called DETACHED from {@link reclaimDebugMedia}; never
+	* await this from an RPC.
+	*/
+	async executeMediaReclaim(input, mediaStore, eventStore, trackStore) {
 		try {
 			const limits = {
 				mode: input.mode,
@@ -72411,6 +72579,19 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				scopes,
 				limits,
 				cursors: input.restart === true ? /* @__PURE__ */ new Map() : this.mediaReclaimCursors,
+				onDevice: (device) => {
+					const s = this.mediaReclaimState;
+					if (!s.running) return;
+					this.mediaReclaimState = {
+						...s,
+						totalExamined: s.totalExamined + device.examined,
+						totalEligible: s.totalEligible + device.eligible,
+						totalReclaimed: s.totalReclaimed + device.reclaimed,
+						totalBytesReclaimed: s.totalBytesReclaimed + device.bytesReclaimed,
+						totalRefused: s.totalRefused + device.refused,
+						devicesDone: s.devicesDone + 1
+					};
+				},
 				deps: {
 					page: ({ deviceId, scope, afterMs, limit }) => mediaStore.pageByKindForDevice({
 						deviceId,
@@ -72437,15 +72618,39 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 				bytesReclaimed: report.totalBytesReclaimed,
 				detail: `debug-media reclaim (${scopes.join("+")}): ${report.totalReclaimed} rows, ${report.totalRefused} refused, complete=${report.complete}`
 			});
-			return {
-				ran: true,
-				...report,
-				devices: [...report.devices]
+			this.mediaReclaimState = {
+				...this.mediaReclaimState,
+				running: false,
+				totalExamined: report.totalExamined,
+				totalEligible: report.totalEligible,
+				totalReclaimed: report.totalReclaimed,
+				totalBytesReclaimed: report.totalBytesReclaimed,
+				totalRefused: report.totalRefused,
+				complete: report.complete,
+				finishedAtMs: Date.now()
 			};
-		} finally {
-			this.mediaReclaimRunning = false;
+			this.ctx.logger.info("debug-media reclaim finished", { meta: {
+				mode: report.mode,
+				examined: report.totalExamined,
+				reclaimed: report.totalReclaimed,
+				bytesReclaimed: report.totalBytesReclaimed,
+				complete: report.complete
+			} });
+		} catch (err) {
+			this.mediaReclaimState = {
+				...this.mediaReclaimState,
+				running: false,
+				finishedAtMs: Date.now(),
+				error: err instanceof Error ? err.message : String(err),
+				complete: false
+			};
+			this.ctx.logger.warn("debug-media reclaim failed", { meta: { error: String(err) } });
 		}
 	}
+	/** Progress of the detached reclaim — the only way to observe a long pass. */
+	async getMediaReclaimStatus() {
+		return { ...this.mediaReclaimState };
+	}
 	/** Progress of the detached rebuild — the only way to observe a long pass. */
 	async getObjectEmbeddingRebuildStatus() {
 		const state = this.rebuildState;

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-CnB4y-xY.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-rrVQlXbu.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.2.154",
+  "version": "1.2.156",
   "description": "Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",
@@ -110,13 +110,6 @@
             "cardinality": "multi",
             "description": "Detection snapshots, thumbnails and crops.",
             "defaultsTo": "recordings"
-          },
-          {
-            "id": "galleryMedia",
-            "displayName": "Enrolled Gallery",
-            "cardinality": "single",
-            "description": "Enrolled face and plate reference crops, and scene reference photographs. Deliberately NOT on the recordings volume: these images survive every retention sweep, so they must also survive a footage wipe, a quota eviction and a recordings disk swap. Small — a few KB per enrolled sample.",
-            "defaultRoot": "data"
           }
         ],
         "icon": "assets/icon.svg",