@camstack/addon-post-analysis 1.2.154 → 1.2.155

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-Ds6x9Agm.js");
+const require_dist = require("../dist-CXY233l4.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -113,6 +113,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 {
@@ -182,9 +183,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) {
@@ -193,6 +194,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
@@ -228,6 +230,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. */
@@ -5515,6 +5521,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
@@ -8596,6 +8633,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": {
@@ -8834,6 +8878,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": {
@@ -20389,6 +20440,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 = (0, node_crypto.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: {
@@ -20400,7 +20486,8 @@ var NotificationCenter = class NotificationCenter {
 			...sequenceButtons,
 			...snoozeButtons,
 			...alarmButtons,
-			...updateButtons
+			...updateButtons,
+			...serverButtons
 		];
 		if (out.length === 0) return [];
 		const now = this.now();
@@ -20522,6 +20609,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);
 		}
 	}
 	/**
@@ -20632,6 +20720,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
@@ -26095,7 +26257,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.
 *
@@ -26992,7 +27154,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;
@@ -35938,6 +36100,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: {
@@ -35977,14 +36140,12 @@ async function runMediaReclaim(input) {
 /**
 * 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.
+* The pass is tens of minutes. The button STARTS it and returns
+* `{ started, alreadyRunning }` immediately — the same shape as the CLIP
+* rebuild button. Progress is `retention.mediaReclaimStatus`. Awaiting the
+* walk is how this door hit the 60 s UDS deadline.
 *
-* 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.
+* `mode` omitted means `report`. `reclaim` is a word that has to be typed.
 */
 /**
 * `report` counts; `reclaim` deletes.
@@ -36025,40 +36186,28 @@ var MediaReclaimActionInputSchema = require_dist.object({
 	*/
 	graceMinutes: require_dist.number().int().min(1).max(10080).optional()
 });
-var MediaReclaimDeviceReportSchema = require_dist.object({
-	deviceId: require_dist.number(),
-	scope: MediaReclaimScopeSchema,
-	examined: require_dist.number(),
-	eligible: require_dist.number(),
-	reclaimed: require_dist.number(),
-	bytesReclaimed: require_dist.number(),
-	/** Rows kept because the owning track is pinned (`staging`/`favourited`). */
-	held: require_dist.number(),
-	/** Rows kept because the owner could not be shown to be a motion event. */
-	unresolved: require_dist.number(),
-	withinGrace: require_dist.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: require_dist.number(),
-	stoppedBy: require_dist.string(),
-	/** Where the NEXT pass resumes. `0` = this device+scope was walked to the end. */
-	nextCursor: require_dist.number()
+var MediaReclaimStartedSchema = require_dist.object({
+	started: require_dist.boolean(),
+	alreadyRunning: require_dist.boolean()
 });
-var MediaReclaimActionResultSchema = require_dist.object({
-	/** `false` when a pass was already in flight — nothing was done. */
-	ran: require_dist.boolean(),
-	mode: require_dist._enum(["report", "reclaim"]),
-	devices: require_dist.array(MediaReclaimDeviceReportSchema),
+var MediaReclaimStatusSchema = require_dist.object({
+	running: require_dist.boolean(),
+	mode: require_dist._enum(["report", "reclaim"]).nullable(),
 	totalExamined: require_dist.number(),
 	totalEligible: require_dist.number(),
 	totalReclaimed: require_dist.number(),
 	totalBytesReclaimed: require_dist.number(),
 	totalRefused: require_dist.number(),
-	durationMs: require_dist.number(),
-	/** Every device+scope reported `exhausted` — there is nothing left to do. */
-	complete: require_dist.boolean()
+	devicesDone: require_dist.number(),
+	complete: require_dist.boolean().nullable(),
+	startedAtMs: require_dist.number().nullable(),
+	finishedAtMs: require_dist.number().nullable(),
+	error: require_dist.string().nullable()
+});
+var mediaReclaimActions = require_dist.defineCustomActions({
+	"retention.mediaReclaim": require_dist.customAction(MediaReclaimActionInputSchema, MediaReclaimStartedSchema, { auth: "admin" }),
+	"retention.mediaReclaimStatus": require_dist.customAction(require_dist.object({}), MediaReclaimStatusSchema, { auth: "admin" })
 });
-var mediaReclaimActions = require_dist.defineCustomActions({ "retention.mediaReclaim": require_dist.customAction(MediaReclaimActionInputSchema, MediaReclaimActionResultSchema, { auth: "admin" }) });
 //#endregion
 //#region src/pipeline-analytics/retention/orphan-audit-actions.ts
 /**
@@ -41151,6 +41300,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);
@@ -43657,7 +43807,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.
@@ -64177,6 +64327,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). */
@@ -65292,9 +65456,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  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.
 	*
@@ -65734,6 +65897,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		const routed = createLocationAwareMediaStorage({
 			base: storage,
 			defaultLocation: "eventMedia",
+			galleryLocationId: GALLERY_MEDIA_LOCATION,
+			galleryRoot: node_path.default.join(this.ctx.dataDir, "gallery"),
 			resolveRoot: (locationId) => this.ctx.api.storage.resolve.query({
 				location: locationId,
 				relativePath: ""
@@ -66410,6 +66575,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					};
 				}
 			},
+			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: require_dist.errMsg(err)
+					};
+				}
+			},
 			readDeviceStates: async (ids) => {
 				const out = /* @__PURE__ */ new Map();
 				for (const id of ids) try {
@@ -67342,19 +67527,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	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: require_dist.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;
@@ -72423,42 +72595,58 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			"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()
 		};
-		if (!mediaStore || !eventStore || !trackStore) return empty;
-		if (this.mediaReclaimRunning) return empty;
-		this.mediaReclaimRunning = true;
+		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
+		};
+	}
+	/**
+	* 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,
@@ -72476,6 +72664,19 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				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,
@@ -72502,15 +72703,39 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				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;