@camstack/addon-post-analysis 1.2.290 → 1.2.292

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry--sFeijO7.js");
+const require_clip_model_registry = require("../clip-model-registry-CTY5co6P.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -39677,7 +39677,12 @@ var RebuildInputSchema = require_clip_model_registry.object({
 	* Milliseconds between tracks; omit for the default, `0` to run flat out.
 	* A rebuild shares hub-main's only thread with every live request.
 	*/
-	pacingMs: require_clip_model_registry.number().int().nonnegative().optional()
+	pacingMs: require_clip_model_registry.number().int().nonnegative().optional(),
+	/**
+	* Re-embed ONLY tracks already in the pinned space — to redo vectors cut
+	* from the wrong box (D664). Requires `maxTracks`.
+	*/
+	force: require_clip_model_registry.boolean().optional()
 });
 var RebuildStartedSchema = require_clip_model_registry.object({
 	started: require_clip_model_registry.boolean(),
@@ -39697,7 +39702,20 @@ var RebuildStatusSchema = require_clip_model_registry.object({
 	scanned: require_clip_model_registry.number(),
 	rebuilt: require_clip_model_registry.number(),
 	missingKeyFrame: require_clip_model_registry.number(),
+	/** No object event at all — its own number since D664. */
+	missingEvent: require_clip_model_registry.number(),
 	missingBbox: require_clip_model_registry.number(),
+	/** Which rule placed each judged track's box (D664). */
+	boxSource: require_clip_model_registry.object({
+		subjectBox: require_clip_model_registry.number(),
+		positions: require_clip_model_registry.number(),
+		event: require_clip_model_registry.number(),
+		refused: require_clip_model_registry.number()
+	}),
+	alreadyInSpace: require_clip_model_registry.number(),
+	/** Whether the current / last pass was a `force` pass (D664). */
+	force: require_clip_model_registry.boolean().nullable(),
+	forcedInSpace: require_clip_model_registry.number(),
 	/** Refused by the executing node (unreadable key frame / bad box), not broken. */
 	notRunnable: require_clip_model_registry.number(),
 	/** The pass STOPPED: no node in the cluster could serve the pinned model. */
@@ -40972,7 +40990,7 @@ function toPixelBox(b) {
 		h: b.height
 	};
 }
-function refused(reason, detail) {
+function refused$1(reason, detail) {
 	return {
 		kind: "refused",
 		reason,
@@ -41000,8 +41018,8 @@ function comparableFaces(input) {
 /** Refuse before choosing when nothing in the photo can become the sample. */
 function precondition(input) {
 	const enrollable = input.faces.filter((f) => f.enrollable && f.embedding !== void 0);
-	if (enrollable.length === 0) return refused("no-enrollable-face", `${input.faces.length} face(s) found, none enrollable (${input.faces.map((f) => f.refusedReason ?? "unknown").join(", ")})`);
-	if (!enrollable.some((f) => isEnrollableIn(f, input.modelId))) return refused("model-mismatch", `faces were embedded by ${[...new Set(enrollable.map((f) => f.modelId))].join(", ")}, the old sample by ${input.modelId} — re-embed the gallery first`);
+	if (enrollable.length === 0) return refused$1("no-enrollable-face", `${input.faces.length} face(s) found, none enrollable (${input.faces.map((f) => f.refusedReason ?? "unknown").join(", ")})`);
+	if (!enrollable.some((f) => isEnrollableIn(f, input.modelId))) return refused$1("model-mismatch", `faces were embedded by ${[...new Set(enrollable.map((f) => f.modelId))].join(", ")}, the old sample by ${input.modelId} — re-embed the gallery first`);
 	return null;
 }
 function chooseByIou(input, oldBox, scored) {
@@ -41010,13 +41028,13 @@ function chooseByIou(input, oldBox, scored) {
 		face,
 		iou: iou$3(box, toPixelBox(face.bbox))
 	})).filter((c) => c.iou >= PHOTO_REENROL_MIN_IOU);
-	if (overlapping.length === 0) return refused("no-iou-match", `no face overlaps the old box at IoU ≥ ${PHOTO_REENROL_MIN_IOU}`);
-	if (overlapping.length > 1) return refused("ambiguous", `${overlapping.length} faces overlap the old box (IoU ${overlapping.map((c) => c.iou.toFixed(2)).join(", ")})`);
+	if (overlapping.length === 0) return refused$1("no-iou-match", `no face overlaps the old box at IoU ≥ ${PHOTO_REENROL_MIN_IOU}`);
+	if (overlapping.length > 1) return refused$1("ambiguous", `${overlapping.length} faces overlap the old box (IoU ${overlapping.map((c) => c.iou.toFixed(2)).join(", ")})`);
 	const [only] = overlapping;
-	if (only === void 0) return refused("no-iou-match", "no overlapping face");
-	if (!isEnrollableIn(only.face, input.modelId)) return refused("no-enrollable-face", `the face on the old box is not enrollable (${only.face.refusedReason ?? `model ${only.face.modelId ?? "none"}`})`);
+	if (only === void 0) return refused$1("no-iou-match", "no overlapping face");
+	if (!isEnrollableIn(only.face, input.modelId)) return refused$1("no-enrollable-face", `the face on the old box is not enrollable (${only.face.refusedReason ?? `model ${only.face.modelId ?? "none"}`})`);
 	const cosine = scored.find((s) => s.face === only.face)?.cosine;
-	if (cosine === void 0 || cosine < .5) return refused("below-floor", `the overlapping face scores cosine ${cosine?.toFixed(3) ?? "n/a"} < ${PHOTO_REENROL_COSINE_FLOOR}`);
+	if (cosine === void 0 || cosine < .5) return refused$1("below-floor", `the overlapping face scores cosine ${cosine?.toFixed(3) ?? "n/a"} < ${PHOTO_REENROL_COSINE_FLOOR}`);
 	return {
 		kind: "chosen",
 		face: only.face,
@@ -41027,10 +41045,10 @@ function chooseByIou(input, oldBox, scored) {
 }
 function chooseByCosine(input, scored) {
 	const [best, runnerUp] = [...scored].toSorted((a, b) => b.cosine - a.cosine);
-	if (best === void 0) return refused("model-mismatch", "no face has a comparable vector");
-	if (best.cosine < .5) return refused("below-floor", `best cosine ${best.cosine.toFixed(3)} < ${PHOTO_REENROL_COSINE_FLOOR}`);
-	if (runnerUp !== void 0 && runnerUp.cosine >= .5 && best.cosine - runnerUp.cosine < .1) return refused("ambiguous", `two faces clear the floor within ${PHOTO_REENROL_AMBIGUITY_MARGIN}: ${best.cosine.toFixed(3)} vs ${runnerUp.cosine.toFixed(3)}`);
-	if (!isEnrollableIn(best.face, input.modelId)) return refused("ambiguous", `the closest face (cosine ${best.cosine.toFixed(3)}) is not enrollable (${best.face.refusedReason ?? "unknown"}) — the enrollable ones may be someone else`);
+	if (best === void 0) return refused$1("model-mismatch", "no face has a comparable vector");
+	if (best.cosine < .5) return refused$1("below-floor", `best cosine ${best.cosine.toFixed(3)} < ${PHOTO_REENROL_COSINE_FLOOR}`);
+	if (runnerUp !== void 0 && runnerUp.cosine >= .5 && best.cosine - runnerUp.cosine < .1) return refused$1("ambiguous", `two faces clear the floor within ${PHOTO_REENROL_AMBIGUITY_MARGIN}: ${best.cosine.toFixed(3)} vs ${runnerUp.cosine.toFixed(3)}`);
+	if (!isEnrollableIn(best.face, input.modelId)) return refused$1("ambiguous", `the closest face (cosine ${best.cosine.toFixed(3)}) is not enrollable (${best.face.refusedReason ?? "unknown"}) — the enrollable ones may be someone else`);
 	return {
 		kind: "chosen",
 		face: best.face,
@@ -47036,6 +47054,42 @@ function pairRiders(detections) {
 	return pairs;
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/tracker/low-score-continuation.ts
+var LOW_SCORE_CONTINUATION_FLOOR_DEFAULT = .35;
+var LOW_SCORE_CONTINUATION_CLASSES = new Set(["person", "animal"]);
+/** `[x1, y1, x2, y2]` (the discard trail's tuple) → the tracker's rectangle. */
+function toRect(bbox) {
+	const [x1, y1, x2, y2] = bbox;
+	return {
+		x: x1,
+		y: y1,
+		w: x2 - x1,
+		h: y2 - y1
+	};
+}
+/**
+* The continuation candidates of one frame. `floor === null` means the tier is
+* off for this camera and nothing is selected.
+*/
+function selectLowScoreContinuations(discarded, floor) {
+	if (floor === null || discarded === void 0) return [];
+	const out = [];
+	for (const d of discarded) {
+		if (d.reason !== "below-threshold") continue;
+		if (d.score < floor) continue;
+		if (!LOW_SCORE_CONTINUATION_CLASSES.has(d.macroClass)) continue;
+		const bbox = toRect(d.bbox);
+		if (bbox.w <= 0 || bbox.h <= 0) continue;
+		out.push({
+			class: d.macroClass,
+			originalClass: d.macroClass,
+			score: d.score,
+			bbox
+		});
+	}
+	return out;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/track-id.ts
 /**
 * A track's identity: short, random, and mintable inside a frame.
@@ -47184,6 +47238,30 @@ function reacquireReachPx(bbox, elapsedMs) {
 	const elapsed = Math.max(0, elapsedMs);
 	return clampRange(diag * REACH_DIAGONALS_PER_SEC * (elapsed / 1e3), diag * REACH_MIN_DIAGONALS, diag * REACH_MAX_DIAGONALS);
 }
+/**
+* Resurrection reach, in box DIAGONALS per second of gap (D665).
+*
+* A corpse is reached only after `maxMissedMs` (4 s) without a box, so the
+* rescue rate above — which is at its 1.5-diagonal ceiling by 1 s — says
+* nothing useful here. A subject the detector has not boxed for four seconds
+* is, on this fleet's evidence, one that stood still or stood half-hidden,
+* not one striding across the frame (a striding person is detected): 0.25
+* diagonals per second is a slow walk for a mid-field person and a pause for
+* a near one. At the 4 s floor of the graveyard band it gives 1.0 diagonal;
+* camera 590's refused returns sat at 1.05–1.82× the old flat 0.75 reach,
+* i.e. 0.79–1.37 diagonals, which this covers from about 5.5 s of gap.
+*/
+var RESURRECTION_REACH_DIAGONALS_PER_SEC = .25;
+/** Never tighter than the flat `rescueCentroidFactor` default it replaces. */
+var RESURRECTION_REACH_MIN_DIAGONALS = .75;
+/**
+* How far from a corpse's last box a detection may sit and still resurrect it
+* on the proximity clause, for a corpse last seen `gapMs` ago.
+*/
+function resurrectionReachPx(bbox, gapMs) {
+	const diag = Math.hypot(bbox.w, bbox.h);
+	return clampRange(diag * RESURRECTION_REACH_DIAGONALS_PER_SEC * (Math.max(0, gapMs) / 1e3), diag * RESURRECTION_REACH_MIN_DIAGONALS, diag * 2);
+}
 //#endregion
 //#region src/pipeline-analytics/pipeline/tracker/rescue-growth.ts
 /**
@@ -47332,7 +47410,10 @@ var DEFAULT_TRACKER_CONFIG = {
 	byteTrackLowIouThreshold: .2,
 	minSpawnAreaEnabled: true,
 	classSpawnAreaFracs: { person: 5e-4 },
-	classGroupAssoc: true
+	classGroupAssoc: true,
+	lowScoreContinuationEnabled: true,
+	lowScoreContinuationMaxMs: 8e3,
+	resurrectionTimeScaled: true
 };
 /** Macro-classes the duplicate resolver may collapse across (people in
 *  non-upright poses misdetected as animals). Any other cross-class pair is
@@ -47340,6 +47421,15 @@ var DEFAULT_TRACKER_CONFIG = {
 var PERSON_CLASS = "person";
 var ANIMAL_CLASS = "animal";
 var MAX_PATH_LENGTH = 300;
+function emptyLowScoreStats() {
+	return {
+		offered: 0,
+		continued: 0,
+		resumed: 0,
+		sustainCapDrops: 0,
+		shadowed: 0
+	};
+}
 /** No stationary-held detections on this frame — the default for every caller
 *  that has no gate (replay, tests, the non-pipeline planes). */
 var EMPTY_INDEX_SET = /* @__PURE__ */ new Set();
@@ -47411,6 +47501,8 @@ var SortTracker = class SortTracker {
 	trackLossSampler = new TrackLossSampler();
 	/** Sink for fragmentation diagnostics — see {@link setSpawnBesideCoastingObserver}. */
 	spawnBesideObserver = null;
+	/** Running counts behind {@link drainLowScoreStats} (D665). */
+	lowScoreStats = emptyLowScoreStats();
 	constructor(config = {}) {
 		this.config = {
 			...DEFAULT_TRACKER_CONFIG,
@@ -47471,7 +47563,7 @@ var SortTracker = class SortTracker {
 			if (SortTracker.spawnBesideFamily(track.class) !== family) continue;
 			const tc = bboxCentroid(track.bbox);
 			const dist = Math.hypot(tc.x - dc.x, tc.y - dc.y);
-			const reach = this.reacquireReach(track, timestamp, true);
+			const reach = this.reacquireReach(track, timestamp, "rescue");
 			if (dist > reach * 2) continue;
 			if (dist < bestDist) {
 				best = track;
@@ -47518,7 +47610,7 @@ var SortTracker = class SortTracker {
 	explainDecline(track, det, detections, frameArea, timestamp, centroidDist) {
 		if (track.class !== det.class) return det.nativeRecovery !== void 0 ? "native-measured-class" : "cross-class";
 		if (iou$2(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return "already-claimed";
-		if (centroidDist <= this.reacquireReach(track, timestamp, true)) {
+		if (centroidDist <= this.reacquireReach(track, timestamp, "rescue")) {
 			if (!this.isPlausibleBirth(det, frameArea)) return "already-claimed";
 			if (!this.config.reacquireTimeScaled) return "plausible-birth-veto";
 			return this.isUnambiguousReach(track, det, detections) ? "already-claimed" : "crowd-guard";
@@ -47973,34 +48065,38 @@ var SortTracker = class SortTracker {
 	* this gate crossed the group, and it is where a `person` at 0.86 took over
 	* an animal's id (camera 615, 17:11:01).
 	*/
-	looseMatch(track, det, timestamp, timeScaled = true) {
+	looseMatch(track, det, timestamp, pass = "rescue") {
 		if (track.class !== det.class) return null;
 		if (iou$2(track.bbox, det.bbox) >= this.config.rescueIouThreshold) return "iou";
 		const tc = bboxCentroid(track.bbox);
 		const dc = bboxCentroid(det.bbox);
-		if (Math.hypot(tc.x - dc.x, tc.y - dc.y) <= this.reacquireReach(track, timestamp, timeScaled)) return "centroid";
+		if (Math.hypot(tc.x - dc.x, tc.y - dc.y) <= this.reacquireReach(track, timestamp, pass)) return "centroid";
 		if (growthAdjacentMatch(track.bbox, det.bbox, this.growthContext(track, timestamp))) return "growth";
 		return null;
 	}
 	/**
 	* The proximity budget the `centroid` clause is measured against.
 	*
-	* On the RESCUE pass (`timeScaled`) it is {@link reacquireReachPx} — a
-	* multiple of the track's diagonal that grows with the elapsed gap and stops
-	* at a ceiling, because a live coasting track's whereabouts genuinely become
-	* less certain the longer it has gone unseen (D399).
-	*
-	* On the RESURRECTION pass it stays the flat `rescueCentroidFactor × diagonal`
-	* it always was. That pass re-attaches a CORPSE, and it exists for one thing:
-	* "a flickering stationary object keeps its identity". Elapsed time is not the
-	* variable there — a stationary subject does not travel further because it
-	* blinked for longer — and the corpse is strictly weaker evidence than a live
-	* track, which is the same reasoning `resurrectionCrowdedIouThreshold` already
-	* encodes.
-	*/
-	reacquireReach(track, timestamp, timeScaled) {
+	* On the RESCUE pass it is {@link reacquireReachPx} — a multiple of the
+	* track's diagonal that grows with the elapsed gap and stops at a ceiling,
+	* because a live coasting track's whereabouts genuinely become less certain
+	* the longer it has gone unseen (D399).
+	*
+	* On the RESURRECTION pass it is {@link resurrectionReachPx} (D665): the same
+	* idea on the graveyard's own time scale — 0.25 diagonals per second of gap,
+	* never below the flat 0.75 it replaces, never above 2. Until D665 this pass
+	* kept the flat `rescueCentroidFactor × diagonal` on the argument that it
+	* exists for "a flickering stationary object", and a stationary subject does
+	* not travel further because it blinked for longer. True of the object it
+	* was written for; not of the pass as it runs: on camera 590 (2026-09-27)
+	* 38% of all re-splits were PEOPLE returning after 4–12 s, further than the
+	* flat gate, with frames flowing the whole time. `resurrectionTimeScaled`
+	* off restores the flat gate.
+	*/
+	reacquireReach(track, timestamp, pass) {
 		const diag = Math.hypot(track.bbox.w, track.bbox.h);
-		if (!timeScaled || !this.config.reacquireTimeScaled) return this.config.rescueCentroidFactor * diag;
+		if (pass === "resurrection") return this.config.resurrectionTimeScaled ? resurrectionReachPx(track.bbox, timestamp - track.lastSeen) : this.config.rescueCentroidFactor * diag;
+		if (!this.config.reacquireTimeScaled) return this.config.rescueCentroidFactor * diag;
 		return reacquireReachPx(track.bbox, timestamp - track.lastSeen);
 	}
 	/**
@@ -48050,6 +48146,23 @@ var SortTracker = class SortTracker {
 			nearestPx: nearest
 		};
 	}
+	/**
+	* The resurrection counterpart of {@link isUnambiguousReach}: no other
+	* same-class subject is live or resurrectable beside `corpse`
+	* ({@link sameClassPeerCount} over the SURVIVING set, which is what the crowd
+	* guard counts), and `det` is the only box of that class on the frame —
+	* the sub-floor `lowScore` boxes included.
+	*/
+	isSoleSubjectResurrection(corpse, det, detections, surviving, lowScore) {
+		if (this.sameClassPeerCount(corpse, surviving) > 0) return false;
+		for (const other of detections) if (other !== det && other.class === corpse.class) return false;
+		for (const other of lowScore) {
+			if (other.class !== corpse.class) continue;
+			if (iou$2(other.bbox, det.bbox) >= this.config.byteTrackLowIouThreshold) continue;
+			return false;
+		}
+		return true;
+	}
 	isUnambiguousReach(track, det, detections) {
 		if (this.sameClassPeerCount(track, this.tracks) > 0) return false;
 		for (const other of detections) {
@@ -48204,6 +48317,64 @@ var SortTracker = class SortTracker {
 			used.add(pair.detIdx);
 		}
 	}
+	/** A CONFIDENT box fed `track` (match, resurrection): the emitted box
+	*  follows it again, and a hold that ends this way is an id the tier kept. */
+	markConfident(track, bbox, timestamp) {
+		track.confidentBbox = bbox;
+		track.confidentSeenAt = timestamp;
+		if (track.lowScoreHeld) {
+			track.lowScoreHeld = false;
+			this.lowScoreStats.resumed++;
+		}
+	}
+	/**
+	* The low-score continuation stage (D665): greedy, highest IoU first, of the
+	* sub-floor boxes against the CONFIRMED tracks nothing claimed this frame,
+	* same class, on the predicted box at `byteTrackLowIouThreshold`.
+	*
+	* A bound box moves the track's association state only — `bbox`, `lastSeen`,
+	* `age` — so the next confident box meets the subject where it is. Not
+	* `hits` (it confirms nothing), not `score`, `class`, the vote, the path or
+	* the velocity (it describes nothing downstream may act on). A track past
+	* `lowScoreContinuationMaxMs` since its last confident box is not offered.
+	*/
+	continueOnLowScore(established, lowScore, timestamp, matchedTracks, matched) {
+		const claimed = [...matched.values()].map((d) => d.bbox);
+		const candidates = lowScore.filter((det) => {
+			const shadow = claimed.some((b) => iou$2(b, det.bbox) >= this.config.byteTrackLowIouThreshold);
+			if (shadow) this.lowScoreStats.shadowed++;
+			return !shadow;
+		});
+		const pairs = [];
+		for (const track of established) {
+			if (matchedTracks.has(track)) continue;
+			if (timestamp - track.confidentSeenAt > this.config.lowScoreContinuationMaxMs) continue;
+			const pbox = this.predicted(track, timestamp);
+			for (const det of candidates) {
+				if (det.class !== track.class) continue;
+				const score = iou$2(pbox, det.bbox);
+				if (score >= this.config.byteTrackLowIouThreshold) pairs.push({
+					track,
+					det,
+					score
+				});
+			}
+		}
+		pairs.sort((a, b) => b.score - a.score);
+		const usedTracks = /* @__PURE__ */ new Set();
+		const usedDets = /* @__PURE__ */ new Set();
+		for (const pair of pairs) {
+			if (usedTracks.has(pair.track) || usedDets.has(pair.det)) continue;
+			usedTracks.add(pair.track);
+			usedDets.add(pair.det);
+			pair.track.bbox = pair.det.bbox;
+			pair.track.lastSeen = timestamp;
+			pair.track.lastSeenFrameSeq = this.frameSeq;
+			pair.track.age = 0;
+			pair.track.lowScoreHeld = true;
+			this.lowScoreStats.continued++;
+		}
+	}
 	update(detections, timestamp, frameContext) {
 		this.frameSeq++;
 		const frameArea = frameContext ? frameContext.frameWidth * frameContext.frameHeight : 0;
@@ -48261,6 +48432,9 @@ var SortTracker = class SortTracker {
 		this.rescueAssociate(established, PROXIMITY, detections, lowSet, frameArea, timestamp, used, matchedTracks, matched, continuationOnly);
 		this.rescueAssociate(provisional, new Set([...OVERLAP, ...PROXIMITY]), detections, lowSet, frameArea, timestamp, used, matchedTracks, matched, continuationOnly);
 		if (this.config.byteTrackEnabled && lowIdxs.length > 0) for (const tier of [established, provisional]) this.greedyAssociate(tier, detections, lowIdxs, this.config.byteTrackLowIouThreshold, timestamp, used, matchedTracks, matched, continuationOnly);
+		const lowScore = frameContext?.lowScore ?? [];
+		this.lowScoreStats.offered += lowScore.length;
+		if (this.config.lowScoreContinuationEnabled && lowScore.length > 0) this.continueOnLowScore(established, lowScore, timestamp, matchedTracks, matched);
 		for (const [track, det] of matched) {
 			if (track.class !== det.class) this.reportRefusal("cross-class-absorbed", det, {
 				against: track,
@@ -48291,6 +48465,7 @@ var SortTracker = class SortTracker {
 			track.hits++;
 			track.lastSeen = timestamp;
 			track.lastSeenFrameSeq = this.frameSeq;
+			this.markConfident(track, det.bbox, timestamp);
 			if (dtMs > 0) {
 				track.velocity = {
 					dx: (newCenter.x - prevCenter.x) / dtMs,
@@ -48315,10 +48490,15 @@ var SortTracker = class SortTracker {
 			}
 			const occluded = this.config.occlusionEnabled && occluders.some((ob) => containment(this.predicted(track, timestamp), ob.bbox) >= this.config.occlusionContainment);
 			track.age++;
-			if (timestamp - track.lastSeen > (occluded ? this.config.occlusionMaxMissedMs : this.config.maxMissedMs)) {
+			const coastMs = timestamp - track.lastSeen;
+			const limitMs = occluded ? this.config.occlusionMaxMissedMs : this.config.maxMissedMs;
+			const heldTooLong = track.lowScoreHeld && timestamp - track.confidentSeenAt > this.config.lowScoreContinuationMaxMs;
+			if (heldTooLong) this.lowScoreStats.sustainCapDrops++;
+			if (coastMs > limitMs || heldTooLong) {
 				track.lost = true;
 				track.lostAt = timestamp;
 				track.resurrectable = true;
+				track.lowScoreHeld = false;
 				this.lostTracks.push(track);
 			} else surviving.push(track);
 		}
@@ -48329,15 +48509,17 @@ var SortTracker = class SortTracker {
 			let bestScore = -1;
 			let bestGate = "iou";
 			let bestPeers = 0;
+			let bestVetoLifted = false;
 			let refused;
 			let refusedGate = "iou";
 			let refusedScore = -1;
 			for (const lost of this.lostTracks) {
 				if (!lost.resurrectable) continue;
 				if (timestamp - lost.lostAt > this.config.resurrectionWindowMs) continue;
-				const gate = this.looseMatch(lost, det, timestamp, false);
+				const gate = this.looseMatch(lost, det, timestamp, "resurrection");
 				if (gate === null) continue;
-				if (gate === "centroid" && this.isPlausibleBirth(det, frameArea)) continue;
+				const vetoLifted = gate === "centroid" && this.isPlausibleBirth(det, frameArea);
+				if (vetoLifted && !(this.config.resurrectionTimeScaled && this.isSoleSubjectResurrection(lost, det, detections, surviving, lowScore))) continue;
 				const score = iou$2(lost.bbox, det.bbox);
 				const peers = this.sameClassPeerCount(lost, surviving);
 				if (this.config.resurrectionCrowdGuard && peers > 0 && score < this.config.resurrectionCrowdedIouThreshold) {
@@ -48353,13 +48535,14 @@ var SortTracker = class SortTracker {
 					bestScore = score;
 					bestGate = gate;
 					bestPeers = peers;
+					bestVetoLifted = vetoLifted;
 				}
 			}
 			if (!best) {
 				if (refused !== void 0) this.reportBind("resurrection-refused", refusedGate, refused, det, timestamp);
 				continue;
 			}
-			resurrectedScene.set(best, bestPeers > 0 ? "multi-subject" : "sole-subject");
+			resurrectedScene.set(best, bestPeers > 0 ? "multi-subject" : bestVetoLifted ? "sole-subject-veto-lifted" : "sole-subject");
 			this.reportBind("resurrection", bestGate, best, det, timestamp);
 			this.lostTracks = this.lostTracks.filter((t) => t !== best);
 			best.bbox = det.bbox;
@@ -48373,6 +48556,7 @@ var SortTracker = class SortTracker {
 			best.lost = false;
 			best.lastSeen = timestamp;
 			best.lastSeenFrameSeq = this.frameSeq;
+			this.markConfident(best, det.bbox, timestamp);
 			best.velocity = {
 				dx: 0,
 				dy: 0
@@ -48449,7 +48633,10 @@ var SortTracker = class SortTracker {
 				classVotes: new Map([[det.class, det.score > 0 ? det.score : Number.EPSILON]]),
 				emitted: false,
 				lossReported: false,
-				lastNativeRecovery: det.nativeRecovery
+				lastNativeRecovery: det.nativeRecovery,
+				confidentBbox: det.bbox,
+				confidentSeenAt: timestamp,
+				lowScoreHeld: false
 			});
 		}
 		this.tracks = surviving;
@@ -48457,11 +48644,12 @@ var SortTracker = class SortTracker {
 		return this.tracks.filter((t) => this.isConfirmedForEmit(t)).map((t) => {
 			t.emitted = true;
 			const scene = resurrectedScene.get(t);
+			const held = t.lowScoreHeld;
 			return {
 				class: this.resolveReportedClass(t),
 				originalClass: t.originalClass,
 				score: t.score,
-				bbox: t.bbox,
+				bbox: held ? t.confidentBbox : t.bbox,
 				trackId: t.id,
 				trackAge: t.hits,
 				velocity: {
@@ -48469,8 +48657,9 @@ var SortTracker = class SortTracker {
 					dy: t.velocity.dy * t.emitIntervalMs
 				},
 				path: [...t.path],
-				matchedThisFrame: t.lastSeen === timestamp,
-				...scene !== void 0 ? { resurrectionScene: scene } : {}
+				matchedThisFrame: t.lastSeen === timestamp && !held,
+				...scene !== void 0 ? { resurrectionScene: scene } : {},
+				...held ? { heldByLowScore: true } : {}
 			};
 		});
 	}
@@ -48484,6 +48673,16 @@ var SortTracker = class SortTracker {
 		this.tracks = this.tracks.filter((t) => t.id !== trackId);
 		this.lostTracks = this.lostTracks.filter((t) => t.id !== trackId);
 	}
+	/**
+	* What the low-score continuation stage did since the last call, and reset
+	* (D665). The tracker has no `deviceId` and no logger; its owner reads this
+	* on its own cadence and logs it per camera.
+	*/
+	drainLowScoreStats() {
+		const out = this.lowScoreStats;
+		this.lowScoreStats = emptyLowScoreStats();
+		return out;
+	}
 	getActiveTracks() {
 		return this.tracks;
 	}
@@ -48858,6 +49057,8 @@ var FrameProcessor = class {
 	detectionRules;
 	/** See {@link setZoneMembershipMinOverlap}. 0 = any positive overlap. */
 	zoneMembershipMinOverlap;
+	/** See {@link setLowScoreContinuationFloor}. `null` = tier off. */
+	lowScoreFloor = LOW_SCORE_CONTINUATION_FLOOR_DEFAULT;
 	/** See {@link getLastZoneOverlaps}. */
 	lastZoneOverlaps;
 	/** See {@link getLastZoneRejections}. */
@@ -48970,6 +49171,18 @@ var FrameProcessor = class {
 	* failure mode this whole area keeps producing. {@link lastZoneOverlaps}
 	* exists so the distribution can be read before a number is picked.
 	*/
+	/**
+	* The score at or above which a box the operator's class floor dropped is
+	* handed to the tracker as low-score continuation evidence (D665); `null`
+	* turns the tier off for this camera. Pushed per frame, like the zones.
+	*/
+	setLowScoreContinuationFloor(floor) {
+		this.lowScoreFloor = floor !== null && Number.isFinite(floor) && floor >= 0 && floor <= 1 ? floor : null;
+	}
+	/** The tracker's low-score continuation counts since the last call (D665). */
+	drainLowScoreStats() {
+		return this.tracker.drainLowScoreStats();
+	}
 	setZoneMembershipMinOverlap(minOverlap) {
 		this.zoneMembershipMinOverlap = Number.isFinite(minOverlap) && minOverlap >= 0 && minOverlap <= 1 ? minOverlap : 0;
 	}
@@ -49362,10 +49575,16 @@ var FrameProcessor = class {
 			}
 			trackerInput.push(det);
 		}
+		const lowCandidates = selectLowScoreContinuations(frame.discarded, this.lowScoreFloor);
+		const lowScore = lowCandidates.length === 0 ? lowCandidates : this.zoneEngine.filterDetections(lowCandidates.map((d) => ({
+			...d.bbox,
+			detection: d
+		})), this.zones, this.detectionRules, frameWidth, frameHeight, (fd) => fd.detection.class).passed.map((fd) => fd.detection);
 		const trackedDetections = this.tracker.update(trackerInput, timestamp, {
 			frameWidth,
 			frameHeight,
-			continuationOnly
+			continuationOnly,
+			lowScore
 		});
 		const stationaryContinued = continuableBoxes.size === 0 ? 0 : trackedDetections.filter((t) => t.matchedThisFrame !== false && continuableBoxes.has(t.bbox)).length;
 		const riderFolds = foldByVehicleBbox.size === 0 ? EMPTY_RIDER_FOLDS : [...foldByVehicleBbox].map(([bbox, fold]) => {
@@ -49607,6 +49826,19 @@ var FrameProcessor = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/face-identity-retraction.ts
+/** The recognizer's step id — the attribution a face identity label carries. */
+var FACE_RECOGNIZER_STEP_ID = "face-recognizer";
+async function retractFaceIdentityLabel(stores, trackId) {
+	const meta = stores.trackStore.getActiveByTrack(trackId)?.subLabelMeta;
+	if (meta === void 0) return "no-label";
+	if (meta.stepId !== "face-recognizer") return "not-face-recognizer";
+	await stores.eventStore.clearLabelForTrack(trackId, 2);
+	await stores.trackStore.clearLabel(trackId, 2);
+	await stores.recomputeImportance?.(trackId);
+	return "retracted";
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/track-provenance.ts
 function trackProvenanceOf(frame) {
 	if (!(frame.width > 0 && frame.height > 0)) return void 0;
@@ -53746,11 +53978,10 @@ var EventStore = class {
 		let entryId;
 		for (const row of rows) {
 			const bbox = row.data["bbox"];
-			if (bbox !== null && typeof bbox === "object") {
-				const bw = "w" in bbox && typeof bbox.w === "number" ? bbox.w : 0;
-				const bh = "h" in bbox && typeof bbox.h === "number" ? bbox.h : 0;
-				if (bw <= 0 || bh <= 0) continue;
-			}
+			if (bbox === null || typeof bbox !== "object") continue;
+			const bw = "w" in bbox && typeof bbox.w === "number" ? bbox.w : 0;
+			const bh = "h" in bbox && typeof bbox.h === "number" ? bbox.h : 0;
+			if (bw <= 0 || bh <= 0) continue;
 			const conf = typeof row.data["confidence"] === "number" ? row.data["confidence"] : 0;
 			if (conf > bestConf) {
 				bestConf = conf;
@@ -62453,6 +62684,26 @@ var EmbeddingDispatcher = class {
 		return this.pendingCrops.size;
 	}
 };
+//#endregion
+//#region src/pipeline-analytics/embedding-rebuild.ts
+/**
+* Track sources a rebuild never lists (D664). An audio track and a synthetic
+* sensor track have no object event and no subject to embed — on the live hub
+* 6,726 + 180 of 42,254 tracks — and walking them only inflated the skip
+* counters an operator reads to judge media coverage.
+*/
+var REBUILD_EXCLUDED_SOURCES = ["audio", "sensor"];
+/**
+* One page of the rebuild listing as a `queryRecentIds` query. Pure, so the
+* exclusion is assertable: dropping it would look identical in every result
+* except the skip counters.
+*/
+function rebuildTrackPageQuery(window) {
+	return {
+		...window,
+		excludeSources: REBUILD_EXCLUDED_SOURCES
+	};
+}
 /**
 * Re-embed every listed track from its key frame.
 *
@@ -62468,6 +62719,14 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 	let recoveredKeyFrame = 0;
 	let missingEvent = 0;
 	let missingBbox = 0;
+	let boxSubject = 0;
+	let boxPositions = 0;
+	let boxEvent = 0;
+	let boxRefused = 0;
+	let forcedInSpace = 0;
+	let skippedOutOfSpace = 0;
+	const refusalsByDevice = /* @__PURE__ */ new Map();
+	const force = options.force === true;
 	let alreadyInSpace = 0;
 	let notRunnable = 0;
 	let noCapableNode = 0;
@@ -62478,6 +62737,12 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 	let budgetExhausted = false;
 	/** Set when the cluster ran out of nodes — the pass stops, `complete` is false. */
 	let abandoned = null;
+	const boxSourceCounts = () => ({
+		subjectBox: boxSubject,
+		positions: boxPositions,
+		event: boxEvent,
+		refused: boxRefused
+	});
 	while (scanned < maxTracks && abandoned === null) {
 		const page = await deps.listTrackIdPage(cursor);
 		if (page.trackIds.length === 0) {
@@ -62485,9 +62750,14 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 			break;
 		}
 		let pageIds = page.trackIds;
+		let forcedPage = false;
 		if (deps.filterOutOfSpace) {
 			const split = await deps.filterOutOfSpace(page.trackIds);
-			if (split !== null) {
+			if (split !== null && force) {
+				skippedOutOfSpace += split.outOfSpace.length;
+				pageIds = split.inSpace;
+				forcedPage = true;
+			} else if (split !== null) {
 				alreadyInSpace += split.alreadyInSpace;
 				pageIds = split.outOfSpace;
 			}
@@ -62503,6 +62773,7 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 		const room = maxTracks - scanned;
 		const batch = pageIds.slice(0, Number.isFinite(room) ? room : void 0);
 		if (batch.length < pageIds.length) budgetExhausted = true;
+		if (forcedPage) forcedInSpace += batch.length;
 		for (const trackId of batch) {
 			if (!deps.canDispatch()) {
 				abandoned = "no node left in the rotation can serve the pinned model — stopped before loading any further media";
@@ -62521,6 +62792,25 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 						missingEvent += 1;
 						return;
 					}
+					if (source.bbox === null || source.bbox.w <= 0 || source.bbox.h <= 0) {
+						missingBbox += 1;
+						boxRefused += 1;
+						const reason = source.boxSource.kind === "refused" ? source.boxSource.reason : "degenerate-box";
+						const n = (refusalsByDevice.get(source.deviceId) ?? 0) + 1;
+						refusalsByDevice.set(source.deviceId, n);
+						if (n === 1 || n % 100 === 0) deps.logger.warn("embedding rebuild: no box measured on the key frame — track refused (D303)", {
+							tags: { deviceId: source.deviceId },
+							meta: {
+								trackId,
+								reason,
+								refusedOnThisCamera: n
+							}
+						});
+						return;
+					}
+					if (source.boxSource.kind === "subjectBox") boxSubject += 1;
+					else if (source.boxSource.kind === "positions") boxPositions += 1;
+					else boxEvent += 1;
 					let keyFrame = source.keyFrame;
 					let recovered = false;
 					if (keyFrame === null && deps.recoverKeyFrame) {
@@ -62532,10 +62822,6 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 						return;
 					}
 					if (recovered) recoveredKeyFrame += 1;
-					if (source.bbox === null || source.bbox.w <= 0 || source.bbox.h <= 0) {
-						missingBbox += 1;
-						return;
-					}
 					const outcome = await deps.embed(recovered ? {
 						...source,
 						keyFrame
@@ -62603,6 +62889,9 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 				recoveredKeyFrame,
 				missingEvent,
 				missingBbox,
+				boxSource: boxSourceCounts(),
+				forcedInSpace,
+				skippedOutOfSpace,
 				alreadyInSpace,
 				notRunnable,
 				noCapableNode,
@@ -62626,6 +62915,10 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 		recoveredKeyFrame,
 		missingEvent,
 		missingBbox,
+		boxSource: boxSourceCounts(),
+		force,
+		forcedInSpace,
+		skippedOutOfSpace,
 		alreadyInSpace,
 		notRunnable,
 		noCapableNode,
@@ -62640,6 +62933,9 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 		recoveredKeyFrame,
 		missingEvent,
 		missingBbox,
+		boxSource: boxSourceCounts(),
+		forcedInSpace,
+		skippedOutOfSpace,
 		alreadyInSpace,
 		notRunnable,
 		noCapableNode,
@@ -63198,8 +63494,6 @@ function faceSizeScore(detectionFrameShortSidePx) {
 }
 //#endregion
 //#region src/pipeline-analytics/face-recognizer.ts
-/** Attribution of an identity resolved by the in-process ArcFace matcher. */
-var FACE_RECOGNIZER_STEP_ID = "face-recognizer";
 /** At most one "dropping imageless track" log per this interval, per recognizer. */
 var FACE_IMAGELESS_LOG_THROTTLE_MS = 6e4;
 /** At most one 'embedding magnitude' sample line per device per this interval. */
@@ -63225,6 +63519,9 @@ var FaceRecognizer = class {
 	gallery = [];
 	names = /* @__PURE__ */ new Map();
 	aggregates = /* @__PURE__ */ new Map();
+	/** The aggregate a veto-lifted quarantine set aside, restored if the first
+	*  face proves the same person (D665). */
+	stashedIdentity = /* @__PURE__ */ new Map();
 	bestFace = /* @__PURE__ */ new Map();
 	/** Frame instant of each live track's last source park (D644). */
 	lastSourceParkAt = /* @__PURE__ */ new Map();
@@ -63416,9 +63713,35 @@ var FaceRecognizer = class {
 	* • the face becomes non-promotable: {@link onTrackEnd} will not write it to
 	*   the gallery while the flag stands.
 	*
-	* The aggregate is deliberately left alone — see the note in `onTrackEnd`.
-	*/
-	quarantineHeldFace(deviceId, trackId) {
+	* The identity AGGREGATE depends on the scene (D665):
+	*
+	* • `multi-subject` — a bind that needed real overlap (IoU ≥ 0.3) with the
+	*   corpse's last box. The aggregate is LEFT ALONE: the next face either
+	*   confirms (same person, name intact at no cost — the common case, a
+	*   seated person occluded for a few seconds) or is rejected by cosine, and
+	*   a rejection is a PROVEN subject change: the aggregate is deleted and the
+	*   written identity label retracted then.
+	* • `sole-subject-veto-lifted` — a bind on proximity alone. The aggregate is
+	*   STASHED and reset, and the written identity label retracted at once:
+	*   `updateTrackAggregate` keeps an assignment through every unmatched frame,
+	*   so without the reset a stranger who never matched anybody would carry
+	*   the name. The first face-bearing frame decides — `confirmed` restores the
+	*   stash and rewrites the label (the same person, back immediately);
+	*   `rejected`, or no face before the track ends, discards it.
+	*/
+	async quarantineHeldFace(deviceId, trackId, scene) {
+		if (scene === "sole-subject-veto-lifted") {
+			const aggregate = this.aggregates.get(trackId);
+			if (aggregate?.assignedIdentityId != null) {
+				const peak = this.bestMatchScore.get(trackId);
+				this.stashedIdentity.set(trackId, {
+					aggregate,
+					...peak !== void 0 ? { bestMatchScore: peak } : {}
+				});
+				this.aggregates.delete(trackId);
+				await this.retractIdentity(deviceId, trackId, scene, aggregate.assignedIdentityId);
+			} else this.aggregates.delete(trackId);
+		}
 		const held = this.bestFace.get(trackId);
 		if (held === void 0 || held.unverified === true) return;
 		const quarantined = {
@@ -63441,6 +63764,7 @@ var FaceRecognizer = class {
 				trackId
 			},
 			meta: {
+				scene,
 				heldScore: held.score,
 				heldAt: held.timestamp,
 				strippedIdentityId: held.recognizedIdentityId ?? null,
@@ -63449,6 +63773,40 @@ var FaceRecognizer = class {
 		});
 	}
 	/**
+	* Take the identity label back from the track and its events — only when the
+	* face recognizer wrote it (`retractFaceIdentityLabel`). Stated either way.
+	*/
+	async retractIdentity(deviceId, trackId, reason, identityId) {
+		const retract = this.deps.retractIdentityLabel;
+		if (retract === void 0) return;
+		try {
+			const outcome = await retract(trackId);
+			this.deps.logger.info("face: identity label retracted after an unverified re-attach", {
+				tags: {
+					deviceId,
+					trackId
+				},
+				meta: {
+					reason,
+					identityId,
+					outcome
+				}
+			});
+		} catch (err) {
+			this.deps.logger.warn("face: identity label retraction failed", {
+				tags: {
+					deviceId,
+					trackId
+				},
+				meta: {
+					reason,
+					identityId,
+					error: String(err)
+				}
+			});
+		}
+	}
+	/**
 	* Ask a FRESH face whether the quarantined held face is still about the same
 	* person, at the same bar the gallery uses to say two vectors are one person
 	* (`similarityThreshold` — one knob over one band, D222).
@@ -63470,7 +63828,7 @@ var FaceRecognizer = class {
 	}
 	async processFrame(input) {
 		const { settings } = input;
-		for (const t of input.tracked) if (t.resurrectionScene === "multi-subject") this.quarantineHeldFace(input.deviceId, t.trackId);
+		for (const t of input.tracked) if (t.resurrectionScene !== void 0 && t.resurrectionScene !== "sole-subject") await this.quarantineHeldFace(input.deviceId, t.trackId, t.resurrectionScene);
 		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && (t.nativeFaceShortSidePx ?? (t.faceBbox ? Math.min(t.faceBbox.w, t.faceBbox.h) : void 0) ?? Number.POSITIVE_INFINITY) >= settings.minFacePx);
 		if (candidates.length === 0) return;
 		this.deps.logger.debug("face: frame candidates", {
@@ -63537,11 +63895,26 @@ var FaceRecognizer = class {
 					embedding: c.embedding,
 					embeddingModelId: c.embeddingModelId
 				}, settings.similarityThreshold);
-				if (verdict === "confirmed") this.bestFace.set(c.trackId, {
-					...quarantined,
-					unverified: false
-				});
-				else if (verdict === "rejected") {
+				const stashed = this.stashedIdentity.get(c.trackId);
+				this.stashedIdentity.delete(c.trackId);
+				if (verdict === "confirmed") {
+					this.bestFace.set(c.trackId, {
+						...quarantined,
+						unverified: false
+					});
+					const name = stashed?.aggregate.assignedIdentityId;
+					if (stashed !== void 0 && name != null) {
+						this.aggregates.set(c.trackId, stashed.aggregate);
+						if (stashed.bestMatchScore !== void 0) this.bestMatchScore.set(c.trackId, stashed.bestMatchScore);
+						labelWork.push({
+							trackId: c.trackId,
+							assignedIdentityId: name,
+							matchScore: stashed.bestMatchScore ?? null
+						});
+					}
+				} else if (verdict === "rejected") {
+					const named = this.aggregates.get(c.trackId)?.assignedIdentityId;
+					if (named != null) await this.retractIdentity(input.deviceId, c.trackId, "rejected", named);
 					this.bestFace.delete(c.trackId);
 					this.bestTracker.delete(c.trackId);
 					this.aggregates.delete(c.trackId);
@@ -63756,6 +64129,7 @@ var FaceRecognizer = class {
 		const bestMatchScore = this.bestMatchScore.get(trackId);
 		const bestSuggestion = this.bestSuggestion.get(trackId);
 		this.aggregates.delete(trackId);
+		this.stashedIdentity.delete(trackId);
 		this.bestFace.delete(trackId);
 		this.bestTracker.delete(trackId);
 		this.bestMatchScore.delete(trackId);
@@ -67917,6 +68291,19 @@ function shouldSkipDropoutFrame(activeTrackCount, detectionCount, consecutiveSki
 	if (activeTrackCount <= 0) return false;
 	return consecutiveSkips < cfg.maxSkipFrames;
 }
+/**
+* How much evidence a frame carries for the dropout decision: its detections,
+* plus the sub-floor boxes the tracker may continue a track on (D665).
+*
+* Until D665 the skip counted `frame.detections` only, so a frame whose sole
+* box was a person at 0.5 read as a detector glitch and never reached the
+* tracker — on camera 590 more than half the frames of a re-split gap were
+* dropout-skipped. A frame with a continuable box is not empty; `floor` is the
+* camera's low-score floor, `null` when the tier is off.
+*/
+function dropoutEvidenceCount(frame, floor) {
+	return frame.detections.length + selectLowScoreContinuations(frame.discarded, floor).length;
+}
 //#endregion
 //#region src/pipeline-analytics/pipeline/key-event-query.ts
 async function rankKeyEvents(candidates, options, peakLookup) {
@@ -73038,6 +73425,58 @@ function hasKeyFrame(source) {
 }
 //#endregion
 //#region src/pipeline-analytics/rebuild-source-loader.ts
+function refused(reason) {
+	return {
+		bbox: null,
+		boxSource: {
+			kind: "refused",
+			reason
+		}
+	};
+}
+function normaliseMeasured(box) {
+	if (box.frameWidth <= 0 || box.frameHeight <= 0 || box.w <= 0 || box.h <= 0) return null;
+	return {
+		x: box.x / box.frameWidth,
+		y: box.y / box.frameHeight,
+		w: box.w / box.frameWidth,
+		h: box.h / box.frameHeight
+	};
+}
+/**
+* The box measured on THIS key frame: its own `subjectBox`, else the track
+* position at exactly its instant, else a named refusal. Never another
+* frame's box (D303).
+*/
+async function keyFrameBox(deps, trackId, keyFrame) {
+	const own = (await deps.media.listSubjectBoxesByOwner("track", trackId)).find((row) => row.mediaId === keyFrame.mediaId);
+	if (own !== void 0) {
+		const bbox = normaliseMeasured(own.subjectBox);
+		if (bbox !== null) return {
+			bbox,
+			boxSource: { kind: "subjectBox" }
+		};
+	}
+	const track = await deps.tracks.getPersistedByTrackId(trackId);
+	if (track === null) return refused("track-row-missing");
+	const { frameWidth, frameHeight } = track;
+	if (frameWidth === void 0 || frameHeight === void 0) return refused("track-frame-size-unknown");
+	const at = track.positions.find((p) => p.timestamp === keyFrame.timestamp);
+	if (at === void 0) return refused("no-position-at-key-frame");
+	const bbox = normaliseMeasured({
+		...at.bbox,
+		frameWidth,
+		frameHeight
+	});
+	if (bbox === null) return refused("no-position-at-key-frame");
+	return {
+		bbox,
+		boxSource: { kind: "positions" }
+	};
+}
+function hasBox(event) {
+	return event.bbox !== void 0 && event.bbox.w > 0 && event.bbox.h > 0;
+}
 /**
 * Assemble one track's rebuild inputs, reading at most ONE blob.
 *
@@ -73045,7 +73484,8 @@ function hasKeyFrame(source) {
 * to describe, and the caller counts it. A track WITH an event but WITHOUT a
 * key frame still returns a source (with `keyFrame: null`) so the caller's
 * `missingKeyFrame` counter stays the one place that decision is made; no blob
-* is read in that case either.
+* is read in that case either. A key frame with no box measured on it returns
+* `bbox: null` and a named refusal, also without reading the blob.
 */
 async function loadRebuildSource(deps, trackId) {
 	const media = await deps.media.listInfoByOwner("track", trackId);
@@ -73053,26 +73493,44 @@ async function loadRebuildSource(deps, trackId) {
 	const cropInfo = media.find((m) => m.kind === "thumbnail");
 	const peak = await deps.events.peakForTrack(trackId);
 	const events = await deps.events.queryObjectByTrackIds([trackId]);
-	const best = events.find((e) => String(e.id) === peak.bestEventId) ?? events[0];
+	const best = events.find((e) => String(e.id) === peak.bestEventId) ?? events.find(hasBox) ?? events[0];
 	if (best === void 0) return null;
 	const common = {
 		trackId,
 		deviceId: best.deviceId,
-		timestamp: best.timestamp,
 		className: best.className,
 		confidence: best.confidence ?? 0,
-		bbox: normaliseEventBbox(best),
 		...cropInfo !== void 0 ? { mediaId: cropInfo.mediaId } : {}
 	};
-	if (keyFrameInfo === void 0) return {
+	if (keyFrameInfo === void 0) {
+		const bbox = normaliseEventBbox(best);
+		return {
+			...common,
+			timestamp: best.timestamp,
+			bbox,
+			boxSource: bbox !== null ? { kind: "event" } : {
+				kind: "refused",
+				reason: "event-without-box"
+			},
+			keyFrame: null
+		};
+	}
+	const box = await keyFrameBox(deps, trackId, keyFrameInfo);
+	const keyed = {
 		...common,
+		timestamp: keyFrameInfo.timestamp,
+		bbox: box.bbox,
+		boxSource: box.boxSource,
+		keyFrameMediaId: keyFrameInfo.mediaId
+	};
+	if (box.bbox === null) return {
+		...keyed,
 		keyFrame: null
 	};
 	const keyFrameFile = await deps.media.getById(keyFrameInfo.mediaId);
 	return {
-		...common,
-		keyFrame: keyFrameFile ? Buffer.from(keyFrameFile.base64, "base64") : null,
-		keyFrameMediaId: keyFrameInfo.mediaId
+		...keyed,
+		keyFrame: keyFrameFile ? Buffer.from(keyFrameFile.base64, "base64") : null
 	};
 }
 //#endregion
@@ -82799,7 +83257,21 @@ var TrackingSettingsSchema = require_clip_model_registry.object({
 	*  passes, only for a coarse box below `animalOverPersonMaxScore`, never on
 	*  the rescue / resurrection passes. Reported label stays via the class
 	*  vote. Off = exact per-frame class gating. */
-	classGroupAssoc: require_clip_model_registry.boolean().default(true)
+	classGroupAssoc: require_clip_model_registry.boolean().default(true),
+	/** Hand the boxes the per-class confidence floor dropped to the tracker as
+	*  CONTINUATION-ONLY evidence (D665): they may keep a confirmed track alive,
+	*  never open one, never produce media, events or notifications. */
+	lowScoreContinuationEnabled: require_clip_model_registry.boolean().default(true),
+	/** Score at/above which a floor-dropped box counts as continuation evidence
+	*  (D665 — justified in `low-score-continuation.ts`). */
+	lowScoreContinuationFloor: require_clip_model_registry.number().min(0).max(1).default(.35),
+	/** Longest a track may be held by floor-dropped boxes alone, from its last
+	*  confident box (ms). */
+	lowScoreContinuationMaxMs: require_clip_model_registry.number().min(0).default(8e3),
+	/** Graveyard reach scaled by the gap, and the plausible-birth veto lifted for
+	*  a sole subject (D665). Off = the flat pre-D665 resurrection gate — the
+	*  per-camera rollback that needs no redeploy. */
+	resurrectionTimeScaled: require_clip_model_registry.boolean().default(true)
 });
 var TRACKING_DEFAULTS = TrackingSettingsSchema.parse({});
 /**
@@ -82854,7 +83326,11 @@ function resolveTrackingSettings(raw) {
 		minSpawnAreaFracPerson: s.minSpawnAreaFracPerson.catch(TRACKING_DEFAULTS.minSpawnAreaFracPerson).parse(raw.minSpawnAreaFracPerson),
 		minSpawnAreaFracAnimal: s.minSpawnAreaFracAnimal.catch(TRACKING_DEFAULTS.minSpawnAreaFracAnimal).parse(raw.minSpawnAreaFracAnimal),
 		minSpawnAreaFracVehicle: s.minSpawnAreaFracVehicle.catch(TRACKING_DEFAULTS.minSpawnAreaFracVehicle).parse(raw.minSpawnAreaFracVehicle),
-		classGroupAssoc: s.classGroupAssoc.catch(TRACKING_DEFAULTS.classGroupAssoc).parse(raw.classGroupAssoc)
+		classGroupAssoc: s.classGroupAssoc.catch(TRACKING_DEFAULTS.classGroupAssoc).parse(raw.classGroupAssoc),
+		lowScoreContinuationEnabled: s.lowScoreContinuationEnabled.catch(TRACKING_DEFAULTS.lowScoreContinuationEnabled).parse(raw.lowScoreContinuationEnabled),
+		lowScoreContinuationFloor: s.lowScoreContinuationFloor.catch(TRACKING_DEFAULTS.lowScoreContinuationFloor).parse(raw.lowScoreContinuationFloor),
+		lowScoreContinuationMaxMs: s.lowScoreContinuationMaxMs.catch(TRACKING_DEFAULTS.lowScoreContinuationMaxMs).parse(raw.lowScoreContinuationMaxMs),
+		resurrectionTimeScaled: s.resurrectionTimeScaled.catch(TRACKING_DEFAULTS.resurrectionTimeScaled).parse(raw.resurrectionTimeScaled)
 	};
 }
 //#endregion
@@ -83284,6 +83760,40 @@ function buildDetectionSettingsSections() {
 					step: .05,
 					default: TRACKING_DEFAULTS.byteTrackLowIouThreshold
 				},
+				{
+					type: "boolean",
+					key: "lowScoreContinuationEnabled",
+					label: "Keep tracks through low-confidence frames",
+					description: "Boxes below the class confidence floor may keep an EXISTING track alive while the detector is unsure, so a person read at 0.5 for a few seconds keeps one id instead of splitting. They never start a track and never produce events, notifications or snapshots.",
+					default: TRACKING_DEFAULTS.lowScoreContinuationEnabled
+				},
+				{
+					type: "number",
+					key: "lowScoreContinuationFloor",
+					label: "Low-confidence continuation floor",
+					description: "Score at or above which a box the class floor dropped still counts as evidence that a tracked subject is there. Only used with the option above.",
+					min: 0,
+					max: 1,
+					step: .05,
+					default: TRACKING_DEFAULTS.lowScoreContinuationFloor
+				},
+				{
+					type: "number",
+					key: "lowScoreContinuationMaxMs",
+					label: "Low-confidence hold limit (ms)",
+					description: "Longest a track may be kept alive by low-confidence boxes alone, counted from its last confident box.",
+					min: 0,
+					max: 3e4,
+					step: 500,
+					default: TRACKING_DEFAULTS.lowScoreContinuationMaxMs
+				},
+				{
+					type: "boolean",
+					key: "resurrectionTimeScaled",
+					label: "Wider re-attach after a long gap",
+					description: "Let a track that was lost for a few seconds be re-attached to a subject that reappears further away, the longer the gap (up to two box diagonals) — only when nobody else of that class is in view. A recognised face is re-checked after such a re-attach. Off = the fixed short re-attach distance.",
+					default: TRACKING_DEFAULTS.resurrectionTimeScaled
+				},
 				{
 					type: "boolean",
 					key: "minSpawnAreaEnabled",
@@ -83621,7 +84131,7 @@ function buildGlobalSettingsSchema(cap) {
 					addonId: "pipeline-analytics",
 					action: "embedding.rebuildStatus",
 					buttonLabel: "Check progress",
-					successMessage: "{modelId} → {index}: indexed {indexed} · scanned {scanned} · rebuilt {rebuilt} · no key frame {missingKeyFrame} · not runnable {notRunnable} · failed {failed}"
+					successMessage: "{modelId} → {index}: indexed {indexed} · scanned {scanned} · rebuilt {rebuilt} · no key frame {missingKeyFrame} · no box {missingBbox} · no event {missingEvent} · not runnable {notRunnable} · failed {failed}"
 				},
 				{
 					type: "addon-action-button",
@@ -87784,6 +88294,8 @@ function decodeEmbeddingBase64(base64) {
 var PHANTOM_CELL_PX = 32;
 /** How long a cell remembers its closes. */
 var PHANTOM_CELL_WINDOW_MS = 360 * 6e4;
+/** Cadence of the per-camera low-score continuation line (D665). */
+var LOW_SCORE_REPORT_INTERVAL_MS = 6e4;
 var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_model_registry.BaseAddon {
 	/** Recent SHORT+MOTIONLESS track closes per `<device>:<class>:<cell>` —
 	*  see {@link noteShortMotionlessTrack}. Measurement only; each entry is
@@ -88451,6 +88963,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	packageBackground = null;
 	/** Consecutive detector-dropout frames skipped per (deviceId, source) key. */
 	dropoutSkipsByKey = /* @__PURE__ */ new Map();
+	/** Last time each processor's low-score continuation counts were logged (D665). */
+	lowScoreReportAtByKey = /* @__PURE__ */ new Map();
 	/** The per-track close-path orchestrator (S2, refactor spec 2026-07-22):
 	*  owns the single-flight sweep latch + the FULL per-track close sequence
 	*  (zero-media policy, lastFrame promotion, recognizer ends with the
@@ -90009,6 +90523,14 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			mediaStore: stores.mediaStore,
 			trackStore: stores.trackStore,
 			eventStore: stores.eventStore,
+			retractIdentityLabel: (trackId) => retractFaceIdentityLabel({
+				trackStore: stores.trackStore,
+				eventStore: stores.eventStore,
+				recomputeImportance: (id) => recomputeTrackImportance({
+					trackStore: stores.trackStore,
+					eventStore: stores.eventStore
+				}, id)
+			}, trackId),
 			captureCrop: (frameHandle, bbox, frameWidth, frameHeight, padding, ownerId, deviceId) => this.captureScheduler.request({
 				deviceId,
 				trackId: ownerId,
@@ -91963,6 +92485,31 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	* tracking/zone/event state never crosses between sources. Emits the
 	* SAME canonical events, distinguished only by `source`.
 	*/
+	/**
+	* One line per camera per minute with what the low-score continuation tier
+	* did (D665): boxes offered, tracks continued, holds that ended in a
+	* confident box again (`resumed` — an id the tier kept), holds cut at the
+	* cap. Never one line per box. Silent while nothing was offered.
+	*/
+	reportLowScoreContinuation(deviceId, key, processor) {
+		const now = Date.now();
+		const last = this.lowScoreReportAtByKey.get(key);
+		if (last === void 0) {
+			this.lowScoreReportAtByKey.set(key, now);
+			return;
+		}
+		if (now - last < LOW_SCORE_REPORT_INTERVAL_MS) return;
+		this.lowScoreReportAtByKey.set(key, now);
+		const stats = processor.drainLowScoreStats();
+		if (stats.offered === 0 && stats.sustainCapDrops === 0) return;
+		this.ctx.logger.info("tracker: low-score continuation", {
+			tags: { deviceId },
+			meta: {
+				...stats,
+				windowMs: now - last
+			}
+		});
+	}
 	async processFrame(deviceId, frame, source, rawFrameHandle, detailSteps, occasion = "session") {
 		if (this.shuttingDown) return;
 		if (!await this.bindingCache.isActive(deviceId)) {
@@ -91987,7 +92534,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		const trk = await this.resolveDeviceTrackingSettings(deviceId);
 		const activeCount = this.lastActiveTrackIds.get(key)?.size ?? 0;
 		const skips = this.dropoutSkipsByKey.get(key) ?? 0;
-		if (shouldSkipDropoutFrame(activeCount, frame.detections.length, skips, {
+		const lowScoreFloor = trk.lowScoreContinuationEnabled ? trk.lowScoreContinuationFloor : null;
+		if (shouldSkipDropoutFrame(activeCount, dropoutEvidenceCount(frame, lowScoreFloor), skips, {
 			enabled: trk.dropoutSkipEnabled,
 			maxSkipFrames: trk.dropoutMaxSkipFrames
 		})) {
@@ -92015,6 +92563,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		processor.setZones(liveZones);
 		processor.setDetectionRules(liveRules);
 		processor.setZoneMembershipMinOverlap(trk.zoneMembershipMinOverlap);
+		processor.setLowScoreContinuationFloor(lowScoreFloor);
 		const injection = injectSecondarySubjects(frame, this.secondarySubjects.take(key, Date.now()));
 		for (const id of injection.covered) this.secondarySubjects.drop(key, id);
 		const trackerFrame = injection.frame;
@@ -92030,6 +92579,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			timestamp: frame.timestamp,
 			frame: trackerFrame
 		});
+		this.reportLowScoreContinuation(deviceId, key, processor);
 		for (const r of processor.getLastLabelWriteRefusals()) {
 			const message = r.reason.kind === "macro-class" ? "label tier collapse refused" : "label write refused";
 			this.ctx.logger.info(message, {
@@ -95717,7 +96267,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					animal: trk.minSpawnAreaFracAnimal,
 					vehicle: trk.minSpawnAreaFracVehicle
 				},
-				classGroupAssoc: trk.classGroupAssoc
+				classGroupAssoc: trk.classGroupAssoc,
+				lowScoreContinuationEnabled: trk.lowScoreContinuationEnabled,
+				lowScoreContinuationMaxMs: trk.lowScoreContinuationMaxMs,
+				resurrectionTimeScaled: trk.resurrectionTimeScaled
 			}, {
 				stationaryThresholdSec,
 				...stillSpeedFracPerSec !== void 0 ? { stillSpeedFracPerSec } : {}
@@ -97208,6 +97761,15 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				refusal: "stores-unavailable"
 			};
 		}
+		const force = input.force === true;
+		if (force && input.maxTracks === void 0) {
+			this.ctx.logger.warn("rebuildObjectEmbeddings: refusing a force pass with no maxTracks", { meta: { refusal: "force-requires-max-tracks" } });
+			return {
+				started: false,
+				alreadyRunning: false,
+				refusal: "force-requires-max-tracks"
+			};
+		}
 		const confirmation = await this.getClusterPinConfirmer(api, "clip-rebuild").confirm();
 		if (confirmation.kind === "refused") {
 			this.ctx.logger.warn("rebuildObjectEmbeddings: the cluster CLIP model is not confirmed — refusing to start a pass that cannot pin one", { meta: { refusal: confirmation.reason } });
@@ -97251,16 +97813,17 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			logger: this.ctx.logger
 		}));
 		const deps = {
-			listTrackIdPage: async (cursor) => trackStore.queryRecentIds({
+			listTrackIdPage: async (cursor) => trackStore.queryRecentIds(rebuildTrackPageQuery({
 				deviceIds,
 				...input.since !== void 0 ? { since: input.since } : {},
 				...input.until !== void 0 ? { until: input.until } : {},
 				...cursor !== null ? { cursor } : {},
 				limit: REBUILD_PAGE_SIZE
-			}),
+			})),
 			loadSource: (trackId) => loadRebuildSource({
 				media: mediaStore,
-				events: eventStore
+				events: eventStore,
+				tracks: trackStore
 			}, trackId),
 			recoverKeyFrame: async (source) => {
 				const recovered = await recordedStills.recover(source.deviceId, source.timestamp, RECOVERED_KEY_FRAME_MAX_WIDTH);
@@ -97286,7 +97849,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				if (split === null) return null;
 				return {
 					outOfSpace: split.outOfSpaceIds,
-					alreadyInSpace: split.inSpace
+					alreadyInSpace: split.inSpace,
+					inSpace: split.inSpaceIds
 				};
 			},
 			logger: {
@@ -97298,6 +97862,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			running: true,
 			modelId,
 			index,
+			force,
 			startedAtMs: Date.now(),
 			progress: {
 				scanned: 0,
@@ -97306,6 +97871,14 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				recoveredKeyFrame: 0,
 				missingEvent: 0,
 				missingBbox: 0,
+				boxSource: {
+					subjectBox: 0,
+					positions: 0,
+					event: 0,
+					refused: 0
+				},
+				forcedInSpace: 0,
+				skippedOutOfSpace: 0,
 				alreadyInSpace: 0,
 				notRunnable: 0,
 				noCapableNode: 0,
@@ -97313,6 +97886,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			}
 		};
 		rebuildObjectEmbeddings(deps, {
+			force,
 			...input.maxTracks !== void 0 ? { maxTracks: input.maxTracks } : {},
 			...input.pacingMs !== void 0 ? { pacingMs: input.pacingMs } : {},
 			onProgress: (progress) => {
@@ -97324,6 +97898,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				running: false,
 				modelId,
 				index,
+				force,
 				startedAtMs: this.rebuildState.startedAtMs ?? Date.now(),
 				finishedAtMs: Date.now(),
 				progress: outcome,
@@ -97339,6 +97914,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				running: false,
 				modelId,
 				index,
+				force,
 				startedAtMs: this.rebuildState.startedAtMs ?? Date.now(),
 				finishedAtMs: Date.now(),
 				error: String(err)
@@ -97353,7 +97929,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			modelId,
 			index,
 			deviceId: input.deviceId ?? "all",
-			maxTracks: input.maxTracks ?? "unbounded"
+			maxTracks: input.maxTracks ?? "unbounded",
+			force
 		} });
 		return {
 			started: true,
@@ -98355,8 +98932,18 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			running: state.running,
 			scanned: p?.scanned ?? 0,
 			rebuilt: p?.rebuilt ?? 0,
-			missingKeyFrame: (p?.missingKeyFrame ?? 0) + (p?.missingEvent ?? 0),
+			missingKeyFrame: p?.missingKeyFrame ?? 0,
+			missingEvent: p?.missingEvent ?? 0,
 			missingBbox: p?.missingBbox ?? 0,
+			boxSource: p?.boxSource ?? {
+				subjectBox: 0,
+				positions: 0,
+				event: 0,
+				refused: 0
+			},
+			alreadyInSpace: p?.alreadyInSpace ?? 0,
+			force: state.force ?? null,
+			forcedInSpace: p?.forcedInSpace ?? 0,
 			notRunnable: p?.notRunnable ?? 0,
 			noCapableNode: p?.noCapableNode ?? 0,
 			failed: p?.failed ?? 0,