@camstack/addon-post-analysis 1.2.291 → 1.2.293

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-CTY5co6P.js");
+const require_clip_model_registry = require("../clip-model-registry-BAuTHS_s.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -47054,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.
@@ -47202,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
 /**
@@ -47350,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
@@ -47358,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();
@@ -47429,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,
@@ -47489,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;
@@ -47536,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";
@@ -47991,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);
 	}
 	/**
@@ -48068,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) {
@@ -48222,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;
@@ -48279,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,
@@ -48309,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,
@@ -48333,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);
 		}
@@ -48347,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) {
@@ -48371,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;
@@ -48391,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
@@ -48467,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;
@@ -48475,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: {
@@ -48487,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 } : {}
 			};
 		});
 	}
@@ -48502,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;
 	}
@@ -48876,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}. */
@@ -48988,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;
 	}
@@ -49380,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]) => {
@@ -49625,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;
@@ -63280,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. */
@@ -63307,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();
@@ -63498,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 = {
@@ -63523,6 +63764,7 @@ var FaceRecognizer = class {
 				trackId
 			},
 			meta: {
+				scene,
 				heldScore: held.score,
 				heldAt: held.timestamp,
 				strippedIdentityId: held.recognizedIdentityId ?? null,
@@ -63531,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).
@@ -63552,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", {
@@ -63619,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);
@@ -63838,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);
@@ -67999,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) {
@@ -82952,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({});
 /**
@@ -83007,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
@@ -83437,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",
@@ -87937,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
@@ -88604,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
@@ -90162,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,
@@ -92116,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)) {
@@ -92140,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
 		})) {
@@ -92168,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;
@@ -92183,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, {
@@ -95870,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 } : {}