@camstack/addon-post-analysis 1.2.101 → 1.2.103

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BQsMSX2A.js");
+const require_dist = require("../dist-BwxXdV9d.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -8302,6 +8302,10 @@ var en_default = {
 		"one": "plate",
 		"other": "plates"
 	},
+	"class.audio": {
+		"one": "sound",
+		"other": "sounds"
+	},
 	"class.other": "{{name}}",
 	"group.others.person": {
 		"one": "{{count}} other person",
@@ -8359,8 +8363,11 @@ var en_default = {
 		"one": "{{count}} addon update available",
 		"other": "{{count}} addon updates available"
 	},
+	"system.addon-update-available.title.onNode": {
+		"one": "{{count}} addon update available on {{nodeId}}",
+		"other": "{{count}} addon updates available on {{nodeId}}"
+	},
 	"system.addon-update-available.body": "{{list}}",
-	"system.addon-update-available.body.onNode": "{{packageName}} {{latestVersion}} is available (current {{currentVersion}}) on node {{nodeId}}",
 	"system.server-update-available.title": {
 		"one": "Server update available on {{count}} node",
 		"other": "Server update available on {{count}} nodes"
@@ -8375,6 +8382,7 @@ var en_default = {
 	"system.addon-updated.body": "{{list}}",
 	"system.server-updated.title": "Server updated",
 	"system.server-updated.body": "{{packageName}} on {{nodeId}} is now {{toVersion}} (was {{fromVersion}})",
+	"system.server-updated.body.toOnly": "{{packageName}} on {{nodeId}} is now {{toVersion}}",
 	"system.server-updated.body.plain": "{{packageName}} on {{nodeId}} was updated",
 	"system.export-completed.title": "Export ready",
 	"system.export-completed.body": "The footage export is ready",
@@ -8516,6 +8524,10 @@ var it_default = {
 		"one": "targa",
 		"other": "targhe"
 	},
+	"class.audio": {
+		"one": "suono",
+		"other": "suoni"
+	},
 	"class.other": "{{name}}",
 	"group.others.person": {
 		"one": "{{count}} altra persona",
@@ -8573,8 +8585,11 @@ var it_default = {
 		"one": "{{count}} aggiornamento addon disponibile",
 		"other": "{{count}} aggiornamenti addon disponibili"
 	},
+	"system.addon-update-available.title.onNode": {
+		"one": "{{count}} aggiornamento addon disponibile su {{nodeId}}",
+		"other": "{{count}} aggiornamenti addon disponibili su {{nodeId}}"
+	},
 	"system.addon-update-available.body": "{{list}}",
-	"system.addon-update-available.body.onNode": "{{packageName}} {{latestVersion}} è disponibile (attuale {{currentVersion}}) sul nodo {{nodeId}}",
 	"system.server-update-available.title": {
 		"one": "Aggiornamento server disponibile su {{count}} nodo",
 		"other": "Aggiornamento server disponibile su {{count}} nodi"
@@ -8589,6 +8604,7 @@ var it_default = {
 	"system.addon-updated.body": "{{list}}",
 	"system.server-updated.title": "Server aggiornato",
 	"system.server-updated.body": "{{packageName}} sul nodo {{nodeId}} è ora {{toVersion}} (era {{fromVersion}})",
+	"system.server-updated.body.toOnly": "{{packageName}} sul nodo {{nodeId}} è ora {{toVersion}}",
 	"system.server-updated.body.plain": "{{packageName}} sul nodo {{nodeId}} è stato aggiornato",
 	"system.export-completed.title": "Export pronto",
 	"system.export-completed.body": "L'export del filmato è pronto",
@@ -10411,15 +10427,15 @@ function incomingFromUpdateAvailable(facts, data) {
 	const nodeIds = unique(packages.map((pkg) => pkg.nodeId).filter((id) => id !== void 0));
 	const packageNames = unique(packages.map((pkg) => pkg.packageName));
 	const signature = packages.map((pkg) => `${pkg.nodeId ?? ""}:${pkg.packageName}@${pkg.latestVersion}`).toSorted().join(",");
-	const list = packages.map(formatAvailableLine).join("\n");
-	const nodes = nodeIds.join(", ");
 	const head = packages[0];
 	const oneNode = nodeIds.length === 1 ? nodeIds[0] : void 0;
+	const list = packages.map((pkg) => formatAvailableLine(pkg, oneNode !== void 0)).join("\n");
+	const nodes = nodeIds.join(", ");
 	return systemSubject({
 		facts,
 		kind,
 		subject: addon ? `packages:addon:${signature}` : `packages:server:${signature}`,
-		titleKey: `system.${kind}.title`,
+		titleKey: addon && oneNode !== void 0 ? `system.${kind}.title.onNode` : `system.${kind}.title`,
 		bodyKey: !addon && oneNode !== void 0 ? `system.${kind}.body.onNode` : !addon && nodeIds.length > 1 ? `system.${kind}.body.onNodes` : `system.${kind}.body`,
 		textParams: {
 			list,
@@ -10478,12 +10494,12 @@ function incomingFromAddonUpdates(facts, updates) {
 function incomingFromServerUpdated(facts, data) {
 	const kind = stringField(data, "kind");
 	const requestedBy = stringField(data, "requestedBy");
-	if (!(kind === "framework-update" || kind === "framework-bulk-update" || requestedBy !== void 0 && requestedBy.startsWith("server-update:"))) return null;
 	const packageName = stringField(data, "packageName") ?? "@camstack/server";
 	const fromVersion = stringField(data, "fromVersion");
 	const toVersion = stringField(data, "toVersion") ?? versionFromRequestedBy(requestedBy);
+	if (!(kind === "framework-update" || kind === "framework-bulk-update" || requestedBy !== void 0 && requestedBy.startsWith("server-update:") && toVersion !== void 0)) return null;
 	const nodeId = stringField(data, "nodeId") ?? "hub";
-	const bodyKey = fromVersion !== void 0 && toVersion !== void 0 ? "system.server-updated.body" : "system.server-updated.body.plain";
+	const bodyKey = toVersion === void 0 ? "system.server-updated.body.plain" : fromVersion === void 0 ? "system.server-updated.body.toOnly" : "system.server-updated.body";
 	return systemSubject({
 		facts,
 		kind: "server-updated",
@@ -10564,9 +10580,15 @@ function updatePackages(data) {
 		...nodeId !== void 0 ? { nodeId } : {}
 	}];
 }
-function formatAvailableLine(pkg) {
-	const line = `${pkg.packageName} ${pkg.latestVersion} (current ${pkg.currentVersion})`;
-	return pkg.nodeId !== void 0 ? `${line} on ${pkg.nodeId}` : line;
+/**
+* One line of an availability list — the SAME shape the completed-update list
+* uses (`incomingFromAddonUpdates`), and deliberately word-free: the list is a
+* frozen param, so any English in it ("current") is delivered verbatim to an
+* Italian household. An arrow is not a language.
+*/
+function formatAvailableLine(pkg, nodeNamedInTitle) {
+	const line = `${pkg.packageName} ${pkg.currentVersion} → ${pkg.latestVersion}`;
+	return pkg.nodeId !== void 0 && !nodeNamedInTitle ? `${line} (${pkg.nodeId})` : line;
 }
 function versionFromRequestedBy(requestedBy) {
 	if (requestedBy === void 0) return void 0;
@@ -25184,7 +25206,16 @@ function clamp01$1(x) {
 	if (x > 1) return 1;
 	return x;
 }
-/** Rank a class name into [0,1] by how event-worthy it is. Case-insensitive. */
+/**
+* Rank a class name into [0,1] by how event-worthy it is. Case-insensitive.
+*
+* `audio` falls through to {@link CLASS_RANK_DEFAULT} on purpose — a sound is
+* not a subject in frame. Before D189 an audio episode carried the HEARD class
+* here, so `dog`/`cat`/`animal` landed in {@link ANIMAL_CLASSES} and a bark
+* ranked as if an animal had walked past, while `speech` (500 of the 576 audio
+* rows measured live) already ranked default. That boost was an accident of the
+* class collision, not a decision. Pinned by `key-event-scoring.spec.ts`.
+*/
 function classRank(className) {
 	const c = className.toLowerCase();
 	if (PERSON_CLASSES.has(c)) return 1;
@@ -28811,19 +28842,29 @@ var BEST_FRAME_POLICY = {
 	sizeAware: true
 };
 /**
-* Best FACE (face-recognizer hold buffer) — confidence-only, no hysteresis, no
-* rate limit. WHY: the face path must keep the TRUE highest-confidence face —
-* accepting a new best only swaps an already-decoded crop buffer in memory
-* (cheap; no capture is triggered), and a track may live well under the
-* best-frame rate-limit window, so a gap/hysteresis would silently discard the
-* real peak for nothing. This was the face path's de-facto behavior all along
-* (it constructed the tracker with defaults); S9 declares it.
+* Best FACE (face-recognizer hold buffer) — SIZE-AWARE, no hysteresis, no rate
+* limit.
+*
+* No hysteresis / no gap, unchanged: accepting a new best only swaps an
+* already-decoded crop buffer in memory (cheap; no capture is triggered), and a
+* track may live well under the best-frame rate-limit window, so a gap would
+* silently discard the real peak for nothing.
+*
+* `sizeAware` since 2026-08-19. It used to be confidence-ONLY, and that was the
+* wrong ranking: SCRFD saturates its confidence on surveillance footage, so a
+* 12 px face and a 40 px face both answer ~0.9 and the track simply kept
+* whichever arrived first. The size that matters is the face's DETECTION-FRAME
+* short side, because that bounds the landmark precision the alignment warp
+* consumes — `face-size-score.ts` carries the measurement that set the
+* reference. Because `minGapMs` is 0 here, enabling this does NOT switch on the
+* decisive-improvement rate-limit bypass (there is no rate limit to bypass); it
+* only adds the size factor to the ranking.
 */
 var BEST_FACE_POLICY = {
 	hysteresis: 0,
 	minGapMs: 0,
 	edgeAware: false,
-	sizeAware: false
+	sizeAware: true
 };
 /**
 * Best OBJECT (CLIP) embedding + its tight crop — confidence-only in-memory
@@ -32248,7 +32289,11 @@ var AudioDetectionSettingsSchema = require_dist.object({
 	*  thresholds, is what bounds the worst case — a mis-tuned threshold can
 	*  only ever cost the operator this many markers a day. */
 	audioMarkerMaxPerDay: require_dist.number().int().positive().default(12),
-	/** Materialize one event + one synthetic track per classified episode. */
+	/** Materialize one event + one synthetic track per classified episode.
+	*  OFF switches off the GROUPING only — classified audio still persists an
+	*  event (class change, then one per 5 s heartbeat) and still reaches the
+	*  Notification Center; it just opens no synthetic track. A knob that names
+	*  the grouping must never silence the path (D62). */
 	audioEpisodeEnabled: require_dist.boolean().default(true),
 	/** Class must be heard continuously this long before the episode opens. */
 	audioEpisodeOpenHoldSec: require_dist.number().nonnegative().default(1.5),
@@ -34468,11 +34513,44 @@ async function resolveDefaultEventMedia(deps) {
 	return pickTrackFallbackMedia(await deps.listTrackMedia(trackId)) ?? null;
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/embedding-magnitude-gate.ts
+/**
+* `null` = accept. A verdict = refuse, carrying both numbers so the caller can
+* name them in a log.
+*
+* Accepts unconditionally when the bound is 0 (disabled) or when the magnitude
+* is absent / non-finite — an older runner that does not report it must keep
+* working exactly as before, never be silently gated to nothing. Pure.
+*/
+function embeddingMagnitudeVerdict(magnitude, bound) {
+	if (!(bound > 0)) return null;
+	if (magnitude === void 0 || !Number.isFinite(magnitude)) return null;
+	if (magnitude <= bound) return null;
+	return {
+		magnitude,
+		bound
+	};
+}
+/**
+* Map a detection-frame face short side to the 0..1 `sizeScore` the
+* {@link ./best-detection-tracker.BestDetectionTracker} multiplies into its
+* effective score. Linear up to {@link FACE_SIZE_SCORE_REFERENCE_PX}, saturated
+* above it, 0 for a missing/degenerate measurement (so an unmeasurable face can
+* never outrank a measured one). Pure.
+*/
+function faceSizeScore(detectionFrameShortSidePx) {
+	if (!Number.isFinite(detectionFrameShortSidePx) || detectionFrameShortSidePx <= 0) return 0;
+	if (detectionFrameShortSidePx >= 32) return 1;
+	return detectionFrameShortSidePx / 32;
+}
+//#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. */
+var FACE_MAGNITUDE_LOG_THROTTLE_MS = 6e4;
 /**
 * arcface model id stamped on a detail-plane face candidate when the gallery is
 * empty (collect-only). The detail-subtree result carries no `embeddingModelId`
@@ -34487,6 +34565,8 @@ var FaceRecognizer = class {
 	names = /* @__PURE__ */ new Map();
 	aggregates = /* @__PURE__ */ new Map();
 	bestFace = /* @__PURE__ */ new Map();
+	/** Per-device throttle clock for the magnitude sample line. */
+	lastMagnitudeLogAt = /* @__PURE__ */ new Map();
 	/**
 	* Peak identity-MATCH cosine per track for the currently-assigned identity
 	* (NOT the detection confidence held in {@link bestFace}). Reset on an
@@ -34536,6 +34616,21 @@ var FaceRecognizer = class {
 	* input source moves from the per-frame plane to this per-track call.
 	*/
 	async ingestFaceDetail(input) {
+		const verdict = embeddingMagnitudeVerdict(input.embeddingMagnitude, input.settings.maxEmbeddingMagnitude);
+		if (verdict !== null) {
+			this.deps.logger.info("face: dropping detail — raw embedding magnitude over bound", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					trackId: input.trackId,
+					magnitude: Number(verdict.magnitude.toFixed(3)),
+					bound: verdict.bound,
+					score: input.score,
+					...input.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: input.nativeFaceShortSidePx } : {}
+				}
+			});
+			return;
+		}
+		this.logEmbeddingMagnitude(input);
 		const modelId = this.gallery[0]?.modelId ?? FALLBACK_FACE_MODEL_ID;
 		const candidate = {
 			trackId: input.trackId,
@@ -34562,6 +34657,30 @@ var FaceRecognizer = class {
 			...input.frameHandle !== void 0 ? { frameHandle: input.frameHandle } : {}
 		});
 	}
+	/**
+	* At most one magnitude line per device per
+	* {@link FACE_MAGNITUDE_LOG_THROTTLE_MS}. This is the ONLY way the operator
+	* can see where this cluster's usable and degenerate face populations sit, so
+	* it must exist before `maxEmbeddingMagnitude` can honestly be turned on.
+	*/
+	logEmbeddingMagnitude(input) {
+		const magnitude = input.embeddingMagnitude;
+		if (magnitude === void 0 || !Number.isFinite(magnitude)) return;
+		const now = Date.now();
+		if (now - (this.lastMagnitudeLogAt.get(input.deviceId) ?? 0) < FACE_MAGNITUDE_LOG_THROTTLE_MS) return;
+		this.lastMagnitudeLogAt.set(input.deviceId, now);
+		this.deps.logger.info("face: embedding magnitude", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				trackId: input.trackId,
+				magnitude: Number(magnitude.toFixed(3)),
+				bound: input.settings.maxEmbeddingMagnitude,
+				score: input.score,
+				detectionFrameShortSidePx: input.faceBbox !== void 0 ? Math.round(Math.min(input.faceBbox.w, input.faceBbox.h)) : 0,
+				...input.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: Math.round(input.nativeFaceShortSidePx) } : {}
+			}
+		});
+	}
 	async processFrame(input) {
 		const { settings } = input;
 		const candidates = input.tracked.filter((t) => Array.isArray(t.embedding) && t.embedding.length > 0 && typeof t.embeddingModelId === "string" && t.confidence >= settings.minFaceConfidence && (t.nativeFaceShortSidePx ?? (t.faceBbox ? Math.min(t.faceBbox.w, t.faceBbox.h) : void 0) ?? Number.POSITIVE_INFINITY) >= settings.minFacePx);
@@ -34623,7 +34742,8 @@ var FaceRecognizer = class {
 			}
 			const recognizedIdentityId = state.assignedIdentityId ?? void 0;
 			const held = this.bestFace.get(c.trackId);
-			const isNewBest = this.bestTracker.observe(c.trackId, c.confidence, input.timestamp);
+			const detectionFrameShortSidePx = c.faceBbox !== void 0 ? Math.min(c.faceBbox.w, c.faceBbox.h) : 0;
+			const isNewBest = this.bestTracker.observe(c.trackId, c.confidence, input.timestamp, void 0, void 0, void 0, faceSizeScore(detectionFrameShortSidePx));
 			const needsCrop = held !== void 0 && held.crop === void 0;
 			if (isNewBest || needsCrop) {
 				const cropBbox = c.faceBbox ?? c.bbox;
@@ -34883,14 +35003,38 @@ var FaceSettingsSchema = require_dist.object({
 	* stripped from the per-device schema).
 	*/
 	enabled: require_dist.boolean().default(true),
-	/** Cosine similarity (on L2-normalized arcface vectors) required to match.
-	*  Raised 0.55→0.62 (2026-07-23 face-quality batch): 0.55 was implausibly
-	*  loose against thin/low-quality galleries and produced ~25-40% visually
-	*  wrong auto-assignments in the 12h audit. */
-	similarityThreshold: require_dist.number().min(0).max(1).default(.62),
-	/** Reject ambiguous matches: require best − secondBest ≥ margin. Raised
-	*  0.10→0.15 (2026-07-23 face-quality batch) to widen the confusion gap. */
-	margin: require_dist.number().min(0).max(1).default(.15),
+	/**
+	* Cosine similarity (on L2-normalized arcface vectors) required to match.
+	*
+	* History: 0.55→0.62 on 2026-07-23, then back to 0.55 on 2026-08-18 once the
+	* dead `assignUniquePerFrame` margin and the poisoned gallery were fixed —
+	* with both repaired, genuine probes scored median 0.38 / p90 0.51, so 0.62
+	* left almost nothing recognisable. That retune lived only as a RUNTIME
+	* override until 2026-08-19; it is the schema default now, because a default
+	* nobody runs is a decision nobody made.
+	*
+	* ⚠ NOT the end state. 0.55 is the least-bad value for the CURRENT crop
+	* quality, where most of what reaches ArcFace is not a correctly aligned
+	* face (measured 2026-08-19 over 60 live crops pulled from the hub: 20%
+	* aligned, 18% marginal, 62% misaligned or containing no detectable face).
+	* On correctly aligned crops the SAME models separate at a far lower
+	* operating point — 300 LFW pairs gave genuine median 0.605 / impostor p90
+	* 0.175, best accuracy 98.3% at threshold 0.28.
+	*
+	* Recalibration plan, in this order:
+	*   1. land the landmark-precision gate (the alignment fix),
+	*   2. re-enrol the gallery from crops produced AFTER it,
+	*   3. re-measure genuine/impostor over a week of post-fix traffic,
+	*   4. expect to lower this toward ~0.30, and `margin` with it.
+	* Lowering it BEFORE step 1 would be actively harmful: a misaligned crop
+	* scores ~0.9 against everything, so the degenerate population sits ABOVE
+	* any threshold you could pick — the knob cannot reach it.
+	*/
+	similarityThreshold: require_dist.number().min(0).max(1).default(.55),
+	/** Reject ambiguous matches: require best − secondBest ≥ margin. 0.10→0.15
+	*  (2026-07-23), then →0.12 (2026-08-18) alongside the threshold retune —
+	*  same story and the same recalibration plan as {@link similarityThreshold}. */
+	margin: require_dist.number().min(0).max(1).default(.12),
 	/** Minimum face-detection confidence for a face to be considered. */
 	minFaceConfidence: require_dist.number().min(0).max(1).default(.5),
 	/**
@@ -34934,6 +35078,33 @@ var FaceSettingsSchema = require_dist.object({
 	*  1 (0 confirmations would assign on a single noisy frame — nonsensical;
 	*  such a value falls back to the default). */
 	confirmFrames: require_dist.number().int().min(1).default(3),
+	/**
+	* Upper bound on the RAW ArcFace feature magnitude a face may have and still
+	* be embedded into the buffer / matched / enrolled. `0` (the default) DISABLES
+	* the gate.
+	*
+	* This exists because a degenerate crop does not score LOW, it scores HIGH:
+	* measured on this cluster 2026-08-18/19, 28.8% of all pairs of DIFFERENT
+	* faces exceeded cosine 0.90 and the worst 40% of the face population had
+	* collapsed onto effectively one vector (mean pairwise cosine 0.976). No
+	* similarity threshold can reach that — it sits above every threshold — so the
+	* only defence is to refuse the embedding before it is stored or compared.
+	*
+	* Direction: for this model the DEGENERATE crops carry the LARGER norm (the
+	* inverse of the MagFace convention), hence a maximum. Over 140 LFW faces
+	* through this exact model and preprocessing, usable crops sat at ≈4.4 (p95
+	* 5.25) regardless of size, grey level or blur, while information-free crops
+	* jumped to 10–16; a bound of 6.0 kept 97.6% of usable crops and rejected
+	* 93.2% of degenerate ones.
+	*
+	* Default 0 ON PURPOSE. Those numbers are LFW's, not this cluster's, and the
+	* magnitude has never been observable here — `result-assembler` discarded it
+	* one line after computing it. The field and its logging ship first; set a
+	* real bound once a week of live `face: embedding magnitude` lines says where
+	* this cluster's populations actually sit. Enabling a gate against a number
+	* nobody has measured in production is how recognition silently stops.
+	*/
+	maxEmbeddingMagnitude: require_dist.number().min(0).default(0),
 	/** Max buffered faces kept per device. */
 	bufferMaxPerDevice: require_dist.number().int().min(0).default(50)
 });
@@ -34952,6 +35123,7 @@ function resolveFaceSettings(raw) {
 		recognitionMinFacePx: pick("recognitionMinFacePx"),
 		suggestionMinCosine: pick("suggestionMinCosine"),
 		minIdentitySamples: pick("minIdentitySamples"),
+		maxEmbeddingMagnitude: pick("maxEmbeddingMagnitude"),
 		confirmFrames: pick("confirmFrames"),
 		bufferMaxPerDevice: pick("bufferMaxPerDevice")
 	};
@@ -39423,6 +39595,147 @@ async function applyTrackFlags(deps, input) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/pipeline/plate-vote.ts
+/**
+* Per-character VOTE over a track's plate reads.
+*
+* A track produces up to `plate-ocr`'s `cadence.maxPerTrack` reads of the SAME
+* physical plate, from different frames. The recognizer used to keep the single
+* read with the highest OCR score (`holdBest`, argmax) — and OCR score does not
+* correlate with correctness. In the 2026-08 audit the top-scoring read of a
+* track was routinely the wrong one while two lower-scoring reads agreed on the
+* right glyph: score ranks how confident the recognizer was about the pixels it
+* saw, not how much of the plate those pixels were.
+*
+* So the reads vote. Each read is normalized (upper, alnum only), aligned to a
+* reference read, and contributes its OCR score to whichever glyph it saw at
+* each reference position; the winner per position is the output. Two reads
+* that agree beat one confident read that disagrees, which is the whole point.
+*
+* ALIGNMENT — reads differ in length (4–9 glyphs live: a dropped leading
+* district letter, a hallucinated trailing glyph). A positional vote on raw
+* indices would let one missing character shift every later column and destroy
+* the agreement it was supposed to measure. Each read is therefore aligned to
+* the reference by Levenshtein traceback: a match or substitution votes at the
+* reference position it aligned to, an insertion votes nowhere, and a deletion
+* simply abstains at that position.
+*
+* REFERENCE — the length carrying the most SCORE MASS wins (a hallucinated
+* 9-glyph read does not get to set the output length just by being longest);
+* ties inside that length go to the highest-scoring read. With ≤5 reads this is
+* the honest cheap heuristic: there is no third source of truth to consult.
+*/
+/**
+* Align `candidate` to `reference` by Levenshtein traceback. Returns one entry
+* per REFERENCE position: the candidate glyph that aligned there, or `null`
+* when the candidate had nothing at that position (a deletion). Candidate
+* insertions are dropped — they have no reference column to vote in.
+*/
+function alignToReference(reference, candidate) {
+	const n = reference.length;
+	const m = candidate.length;
+	const dist = [];
+	for (let i = 0; i <= n; i++) {
+		const row = new Array(m + 1).fill(0);
+		row[0] = i;
+		dist.push(row);
+	}
+	const first = dist[0];
+	if (first === void 0) return [];
+	for (let j = 0; j <= m; j++) first[j] = j;
+	for (let i = 1; i <= n; i++) {
+		const prev = dist[i - 1];
+		const cur = dist[i];
+		if (prev === void 0 || cur === void 0) continue;
+		for (let j = 1; j <= m; j++) {
+			const cost = reference[i - 1] === candidate[j - 1] ? 0 : 1;
+			cur[j] = Math.min((prev[j] ?? 0) + 1, (cur[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost);
+		}
+	}
+	const aligned = new Array(n).fill(null);
+	let i = n;
+	let j = m;
+	while (i > 0 && j > 0) {
+		const cur = dist[i];
+		const prev = dist[i - 1];
+		if (cur === void 0 || prev === void 0) break;
+		const cost = reference[i - 1] === candidate[j - 1] ? 0 : 1;
+		if (cur[j] === (prev[j - 1] ?? 0) + cost) {
+			aligned[i - 1] = candidate[j - 1] ?? null;
+			i--;
+			j--;
+		} else if (cur[j] === (prev[j] ?? 0) + 1) i--;
+		else j--;
+	}
+	return aligned;
+}
+/** The read whose LENGTH carries the most score mass; ties → highest score. */
+function pickReference(reads) {
+	const massByLength = /* @__PURE__ */ new Map();
+	for (const r of reads) massByLength.set(r.text.length, (massByLength.get(r.text.length) ?? 0) + r.score);
+	let bestLength = 0;
+	let bestMass = -1;
+	for (const [length, mass] of massByLength) if (mass > bestMass || mass === bestMass && length < bestLength) {
+		bestMass = mass;
+		bestLength = length;
+	}
+	let reference = "";
+	let referenceScore = -1;
+	for (const r of reads) if (r.text.length === bestLength && r.score > referenceScore) {
+		referenceScore = r.score;
+		reference = r.text;
+	}
+	return reference;
+}
+/**
+* Confidence-weighted per-character vote over a track's plate reads. Returns
+* the normalized winning text (`''` when there is nothing to vote on).
+*/
+function votePlateText(reads) {
+	const normalized = [];
+	for (const r of reads) {
+		const text = normalizePlate(r.text);
+		if (text.length > 0) normalized.push({
+			text,
+			score: r.score
+		});
+	}
+	if (normalized.length === 0) return "";
+	const only = normalized[0];
+	if (normalized.length === 1 && only !== void 0) return only.text;
+	const reference = pickReference(normalized);
+	if (reference.length === 0) return "";
+	const columns = [];
+	for (let i = 0; i < reference.length; i++) columns.push(/* @__PURE__ */ new Map());
+	for (const r of normalized) {
+		const aligned = r.text === reference ? [...r.text] : alignToReference(reference, r.text);
+		for (let i = 0; i < reference.length; i++) {
+			const glyph = aligned[i];
+			if (glyph === null || glyph === void 0) continue;
+			const column = columns[i];
+			if (column === void 0) continue;
+			column.set(glyph, (column.get(glyph) ?? 0) + r.score);
+		}
+	}
+	let out = "";
+	for (let i = 0; i < reference.length; i++) {
+		const column = columns[i];
+		const referenceGlyph = reference[i] ?? "";
+		if (column === void 0 || column.size === 0) {
+			out += referenceGlyph;
+			continue;
+		}
+		let bestGlyph = referenceGlyph;
+		let bestMass = column.get(referenceGlyph) ?? -1;
+		for (const [glyph, mass] of column) if (mass > bestMass) {
+			bestMass = mass;
+			bestGlyph = glyph;
+		}
+		out += bestGlyph;
+	}
+	return out;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/plate-matcher.ts
 /**
 * plate-matcher — name a plate read against the vehicle gallery by text vicinity.
@@ -39471,11 +39784,11 @@ function matchPlateText(probe, gallery, opts) {
 //#endregion
 //#region src/pipeline-analytics/plate-recognizer.ts
 /**
-* PlateRecognizer — buffers the best license-plate OCR read per vehicle track
-* for the plate gallery. Unlike faces there is NO gallery matching: the OCR text
-* IS the label and already rides on the event via the detection pipeline. This
-* only collects per-track reads (+ a tight plate crop) so the gallery can group,
-* review and search them. Mirrors FaceRecognizer's hold→onTrackEnd lifecycle.
+* PlateRecognizer — collects EVERY license-plate OCR read a vehicle track
+* produces and stores their per-character VOTE (`plate-vote.ts`) at close, plus
+* the max-score read's crop for the gallery tile. Unlike faces there is NO
+* gallery matching: the OCR text IS the label and already rides on the event via
+* the detection pipeline. Mirrors FaceRecognizer's hold→onTrackEnd lifecycle.
 */
 var PlateRecognizer = class {
 	deps;
@@ -39538,7 +39851,7 @@ var PlateRecognizer = class {
 		const minConfidence = input.minConfidence ?? 0;
 		const candidates = input.tracked.filter((t) => typeof t.plateText === "string" && t.plateText.length > 0 && typeof t.plateScore === "number" && t.plateScore >= minConfidence && t.plateBbox !== void 0);
 		if (candidates.length === 0) return;
-		for (const c of candidates) await this.holdBest({
+		for (const c of candidates) await this.observeRead({
 			deviceId: input.deviceId,
 			trackId: c.trackId,
 			text: c.plateText,
@@ -39561,15 +39874,50 @@ var PlateRecognizer = class {
 	* gallery stays empty (0 plateCrop) — the observed live gap.
 	*/
 	async observePlateRead(input) {
-		if (!isPlausiblePlateRead(input.text, input.score)) return;
-		if (input.score < (input.minConfidence ?? 0)) return;
-		await this.holdBest(input);
+		const minConfidence = input.minConfidence ?? 0;
+		const reason = !isPlausiblePlateRead(input.text, input.score) ? "implausible" : input.score < minConfidence ? "below-min-confidence" : null;
+		if (reason !== null) {
+			this.deps.logger.info("plate: read discarded", {
+				tags: {
+					deviceId: input.deviceId,
+					trackId: input.trackId
+				},
+				meta: {
+					text: input.text,
+					score: input.score,
+					minConfidence,
+					reason
+				}
+			});
+			return;
+		}
+		await this.observeRead(input);
 	}
-	/** Hold the highest-scoring plate read per track, capturing a tight crop the
-	*  first time a new best is seen (shared by the per-frame + detail-plane paths). */
-	async holdBest(input) {
+	/**
+	* Record one plate read for a track (shared by the per-frame + detail-plane
+	* paths).
+	*
+	* EVERY read is kept for the close-time vote — a track's reads disagree, and
+	* the disagreement is the signal. The crop + geometry still track the
+	* MAX-SCORE read: the vote decides the text, but the picture the operator
+	* reviews should be the sharpest frame the track produced.
+	*
+	* The read list is capped at {@link MAX_VOTING_READS} in ARRIVAL order, not
+	* by score: evicting the lowest-scoring read would re-introduce the very
+	* ranking this vote exists to stop trusting.
+	*/
+	async observeRead(input) {
 		const held = this.bestPlate.get(input.trackId);
-		if (held !== void 0 && input.score <= held.score) return;
+		const vote = {
+			text: input.text,
+			score: input.score
+		};
+		if (held !== void 0 && input.score <= held.score) {
+			if (held.reads.length < 5) held.reads.push(vote);
+			return;
+		}
+		const reads = held?.reads ?? [];
+		if (reads.length < 5) reads.push(vote);
 		let crop;
 		if (input.frameHandle !== void 0) try {
 			crop = await this.deps.captureCrop(input.frameHandle, input.bbox, input.frameWidth, input.frameHeight, input.cropPadding, input.trackId, input.deviceId) ?? void 0;
@@ -39585,6 +39933,7 @@ var PlateRecognizer = class {
 		this.bestPlate.set(input.trackId, {
 			text: input.text,
 			score: input.score,
+			reads,
 			bbox: input.bbox,
 			timestamp: input.timestamp,
 			frameWidth: input.frameWidth,
@@ -39661,14 +40010,16 @@ var PlateRecognizer = class {
 				}
 			});
 		}
-		const match = this.matchVehicle(held.text, held.score);
+		const voted = votePlateText(held.reads);
+		const text = voted.length > 0 && isPlausiblePlateRead(voted, held.score) ? voted : normalizePlate(held.text);
+		const match = this.matchVehicle(text, held.score);
 		try {
 			await this.deps.plateStore.insert({
 				id: plateId,
 				deviceId,
 				trackId,
 				timestamp: held.timestamp,
-				text: normalizePlate(held.text),
+				text,
 				score: held.score,
 				...mediaKey !== void 0 ? { mediaKey } : {},
 				corrected: false,
@@ -39689,7 +40040,10 @@ var PlateRecognizer = class {
 				},
 				meta: {
 					plateId,
-					text: normalizePlate(held.text),
+					text,
+					bestRead: normalizePlate(held.text),
+					reads: held.reads.map((r) => `${normalizePlate(r.text)}@${r.score.toFixed(2)}`),
+					votedFromReads: held.reads.length,
 					score: held.score,
 					hasCrop: mediaKey !== void 0,
 					recognizedVehicleId: match?.vehicleId ?? null
@@ -40207,6 +40561,24 @@ function buildRecordedStillPorts(input) {
 var MIGRATION_MARKER_COLLECTION = "pipeline-analytics:migrations";
 var MIGRATION_MARKER_KEY = "label-tier-4g";
 /**
+* The owner declares its marker collection — like every other store in this
+* addon. KV shape (a single `data` column: `get`/`set` route the value as a
+* JSON blob; the engine adds the implicit `id` primary key). This declaration
+* never existed, so the engine refused every marker write, the catch below
+* warned, and every boot re-scanned the full analytics store — ~36k rows per
+* boot from the day the migration shipped.
+*/
+async function declareMigrationMarkers(store) {
+	await store.declareCollection.mutate({
+		collection: MIGRATION_MARKER_COLLECTION,
+		columns: [{
+			name: "data",
+			type: "TEXT",
+			notNull: true
+		}]
+	});
+}
+/**
 * The decision for ONE row, exposed so the rule is testable without a store.
 *
 * `null` = leave the row alone.
@@ -43387,6 +43759,47 @@ function canRollbackSnapshot(mark, currentLastSnapshotAt) {
 	return mark.priorRollbacks < 3;
 }
 //#endregion
+//#region src/pipeline-analytics/store/audio-track-class.ts
+/** The taxonomy macro every audio-sourced track carries as its class. */
+var AUDIO_TRACK_CLASS = "audio";
+/**
+* True when this row predates the contract: audio-sourced, but carrying a
+* naked audio macro as its class.
+*
+* Deliberately NOT "className is in AUDIO_MACRO_LABELS" — an id added to the
+* vocabulary after a row was written would then read as modern forever. The
+* question is the simple one: is this an audio row that does not say `audio`?
+*/
+function isLegacyAudioTrackClass(track) {
+	return track.source === "audio" && track.className !== "audio";
+}
+/**
+* Bring a hydrated row up to the contract. Returns the SAME reference when
+* there is nothing to do, so the hot path (every non-audio track, and every
+* audio track written after this shipped) allocates nothing.
+*
+* The naked class is preserved as an `audioLabels` entry when — and only when
+* — the row carries none. On the 576 legacy rows measured on the live hub that
+* branch is unreachable (all of them have labels); it exists so the rewrite
+* can never be the step that DESTROYS the only copy of what was heard.
+*/
+function normalizeAudioTrackClass(track) {
+	if (!isLegacyAudioTrackClass(track)) return track;
+	const heard = {
+		label: track.className,
+		peakScore: 0,
+		count: 1,
+		firstAt: track.firstSeen,
+		lastAt: track.lastSeen
+	};
+	const audioLabels = track.audioLabels !== void 0 && track.audioLabels.length > 0 ? track.audioLabels : [heard];
+	return {
+		...track,
+		className: AUDIO_TRACK_CLASS,
+		audioLabels
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/store/recent-cursor.ts
 function encodeRecentCursor(cursor) {
 	return Buffer.from(JSON.stringify({
@@ -45034,7 +45447,7 @@ var TrackStore = class {
 			maxX: envMaxX,
 			maxY: envMaxY
 		} : null;
-		return {
+		return normalizeAudioTrackClass({
 			trackId: id,
 			deviceId: Number(data["deviceId"]),
 			className: String(data["className"]),
@@ -45065,7 +45478,7 @@ var TrackStore = class {
 			...closedReason !== void 0 ? { closedReason } : {},
 			observations,
 			...envelope !== null ? { envelope } : {}
-		};
+		});
 	}
 };
 //#endregion
@@ -47398,7 +47811,7 @@ var AudioMarkerProjector = class {
 				cameraId: deviceId,
 				sourceDeviceId: deviceId,
 				source: "audio",
-				kind: "audio",
+				kind: AUDIO_TRACK_CLASS,
 				timestamp: timestampMs,
 				...audioLabels !== void 0 ? { audioLabels } : {}
 			});
@@ -48606,6 +49019,23 @@ async function projectSensorMarkers(deps, data, timestamp) {
 * {@link isSpatialTrack}.
 */
 var DEFAULT_DEBOUNCE_MS = 1e4;
+/**
+* What the debounce treats as "the same event happening again".
+*
+* `(camera, kind)` — plus, for an audio row, the class HEARD. Since D189 every
+* audio row carries `kind: 'audio'` and puts the class on `audioLabels`, so
+* keying on `kind` alone would collapse this to one bucket per camera. The
+* episode hysteresis cools down PER CLASS, so a bark three seconds after speech
+* is a legitimate second episode — and a per-camera bucket would drop it.
+*
+* Only the FIRST label is used: a materialize carries the one class the episode
+* opened on. Joining all of them would make `[speech]` and `[speech, dog]`
+* different buckets, which is the opposite of what a debounce is for.
+*/
+function debounceKey(input) {
+	const heard = input.audioLabels?.[0]?.label;
+	return heard === void 0 ? `${input.cameraId}:${input.kind}` : `${input.cameraId}:${input.kind}:${heard}`;
+}
 /** A hanging snapshot cap must not stall the sensor state-change path. */
 var DEFAULT_SNAPSHOT_TIMEOUT_MS = 1e4;
 /** Distinguishes a snapshot-cap timeout from a fetch failure for reporting. */
@@ -48648,7 +49078,7 @@ var SyntheticTrackMaterializer = class {
 	snapshotTimeoutMs;
 	makeId;
 	now;
-	/** Last snapshot time per `${cameraId}:${kind}`. */
+	/** Last snapshot time per {@link debounceKey}. */
 	lastAt = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.deps = deps;
@@ -48687,7 +49117,7 @@ var SyntheticTrackMaterializer = class {
 	* still lands a track (with no media) — it never blocks the durable record.
 	*/
 	async materialize(input) {
-		const key = `${input.cameraId}:${input.kind}`;
+		const key = debounceKey(input);
 		const last = this.lastAt.get(key);
 		if (last !== void 0 && this.now() - last < this.debounceMs) return null;
 		this.lastAt.set(key, this.now());
@@ -50042,7 +50472,7 @@ function buildGlobalSettingsSchema() {
 					type: "boolean",
 					key: "audioEpisodeEnabled",
 					label: "Create audio episodes",
-					description: "When off, classified audio still notifies from other paths but does not open a synthetic track or coalesce classification events.",
+					description: "Off switches off the GROUPING only: classified audio still persists an event and still notifies, but no timeline track is opened and a long sound is no longer collapsed into one episode (one event per class change, then one every 5 s while it lasts).",
 					default: AUDIO_DETECTION_DEFAULTS.audioEpisodeEnabled
 				},
 				{
@@ -50168,6 +50598,15 @@ function buildGlobalSettingsSchema() {
 					step: 1,
 					default: FACE_DEFAULTS.confirmFrames
 				},
+				{
+					type: "number",
+					key: "maxEmbeddingMagnitude",
+					label: "Max embedding magnitude (0 = off)",
+					description: "Refuse a face whose RAW ArcFace feature magnitude exceeds this, before it is buffered, matched or enrolled. A degenerate crop does not score LOW against the gallery — it scores HIGH against everything — so no similarity threshold can catch it; the raw magnitude can. On this model a usable face sits around 4.4 whatever its size, grey level or blur, while an information-free crop jumps to 10–16. Leave at 0 until the \"face: embedding magnitude\" log lines show where YOUR cameras sit; a bound guessed from someone else's data silently stops recognising everybody.",
+					min: 0,
+					step: .5,
+					default: FACE_DEFAULTS.maxEmbeddingMagnitude
+				},
 				{
 					type: "number",
 					key: "bufferMaxPerDevice",
@@ -50245,6 +50684,125 @@ function evaluatePeriodicSnapshot(input) {
 		movedFraction
 	};
 }
+/** Where the completion marker lives — the collection `runLabelTierMigration`
+*  already established for exactly this. */
+var AUDIO_CLASS_MIGRATION_MARKER_COLLECTION = "pipeline-analytics:migrations";
+var AUDIO_CLASS_MIGRATION_MARKER_KEY = "audio-track-class-d189";
+/**
+* The decision for ONE stored row, exposed so the rule is testable without a
+* store. `null` = leave the row alone.
+*
+* Reads the RAW row rather than a hydrated `Track` on purpose: this is the
+* column the pass rewrites, and hydrating through `rowToTrack` would apply the
+* read-side normalization and hide the very rows it is looking for.
+*/
+function decideAudioClassRowMigration(data) {
+	if (data["source"] !== "audio") return null;
+	const className = data["className"];
+	if (typeof className !== "string" || className.length === 0) return null;
+	if (className === "audio") return null;
+	const stored = data["audioLabels"];
+	if (Array.isArray(stored) && stored.length > 0) return { className: AUDIO_TRACK_CLASS };
+	const firstSeen = typeof data["firstSeen"] === "number" ? data["firstSeen"] : 0;
+	return {
+		className: AUDIO_TRACK_CLASS,
+		audioLabels: [{
+			label: className,
+			peakScore: 0,
+			count: 1,
+			firstAt: firstSeen,
+			lastAt: typeof data["lastSeen"] === "number" ? data["lastSeen"] : firstSeen
+		}]
+	};
+}
+/**
+* Run the pass over the tracks collection, once.
+*
+* The marker short-circuits a completed migration; it is written only when the
+* pass did NOT truncate, so an interrupted run resumes on the next boot instead
+* of declaring itself done.
+*/
+async function runAudioTrackClassMigration(deps, collection) {
+	try {
+		const marker = await deps.store.get.query({
+			collection: AUDIO_CLASS_MIGRATION_MARKER_COLLECTION,
+			key: AUDIO_CLASS_MIGRATION_MARKER_KEY
+		});
+		if (marker !== null && marker !== void 0) return null;
+	} catch {}
+	let scanned = 0;
+	let rewritten = 0;
+	let labelsRecovered = 0;
+	let skipped = 0;
+	let offset = 0;
+	let truncated = false;
+	for (;;) {
+		if (scanned >= 2e5) {
+			truncated = true;
+			break;
+		}
+		const rows = await deps.store.query.query({
+			collection,
+			filter: {
+				limit: 500,
+				offset
+			}
+		});
+		if (rows.length === 0) break;
+		for (const row of rows) {
+			scanned++;
+			const patch = decideAudioClassRowMigration(row.data);
+			if (patch === null) {
+				skipped++;
+				continue;
+			}
+			const deviceId = typeof row.data["deviceId"] === "number" ? row.data["deviceId"] : void 0;
+			try {
+				await deps.store.update.mutate({
+					collection,
+					id: row.id,
+					data: patch
+				});
+				rewritten++;
+				if (patch["audioLabels"] !== void 0) labelsRecovered++;
+			} catch (err) {
+				deps.logger.warn("audio track class migration row failed", {
+					...deviceId !== void 0 ? { tags: { deviceId } } : {},
+					meta: {
+						collection,
+						id: row.id,
+						error: err instanceof Error ? err.message : String(err)
+					}
+				});
+				skipped++;
+			}
+		}
+		if (rows.length < 500) break;
+		offset += rows.length;
+	}
+	if (!truncated) try {
+		await deps.store.set.mutate({
+			collection: AUDIO_CLASS_MIGRATION_MARKER_COLLECTION,
+			key: AUDIO_CLASS_MIGRATION_MARKER_KEY,
+			value: {
+				completedAt: deps.now(),
+				rewritten
+			}
+		});
+	} catch (err) {
+		deps.logger.warn("audio track class migration marker failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+	}
+	const stats = {
+		collection,
+		scanned,
+		rewritten,
+		labelsRecovered,
+		skipped,
+		truncated
+	};
+	deps.logger.info("audio track class migration", { meta: { ...stats } });
+	return stats;
+}
 //#endregion
 //#region src/pipeline-analytics/store/object-embedding-store.ts
 /**
@@ -51548,6 +52106,16 @@ var OVERLAY_SYNTHESIS_WARN_THROTTLE_MS = 6e4;
 var AUDIO_EPISODE_VISUAL_QUIET_MS = 2e3;
 /** Persist lastSeen on an open synthetic audio track at most this often. */
 var AUDIO_EPISODE_PERSIST_MS = 2e3;
+/**
+* Coalescing window for classified audio inserts when episodes are OFF.
+*
+* With `audioEpisodeEnabled: false` there is no hysteresis to collapse a sound
+* into one row, but the classifier still fires at ~30 Hz — so the pre-episode
+* rule applies again: while the SAME class persists, one row per heartbeat;
+* a class change inserts immediately. The knob turns off the grouping, never
+* the persistence (D62).
+*/
+var AUDIO_EVENT_HEARTBEAT_MS = 5e3;
 var MOTION_EVENT_HEARTBEAT_MS = 5e3;
 /**
 * Stored media kinds that carry NO drawn bounding box, in fallback preference
@@ -52653,7 +53221,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			AnalyticsLts.declare(api.settingsStore),
 			SceneStore.declare(api.settingsStore),
 			NotificationCenter.declare(api.settingsStore),
-			ViewerSettingsSnapshotStore.declare(api.settingsStore)
+			ViewerSettingsSnapshotStore.declare(api.settingsStore),
+			declareMigrationMarkers(api.settingsStore)
 		]);
 		this.viewerSettingsSnapshots = new ViewerSettingsSnapshotStore(api.settingsStore);
 		try {
@@ -52671,6 +53240,13 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		}, [TRACKS_COLLECTION, OBJECT_EVENTS_COLLECTION]).catch((err) => {
 			this.ctx.logger.warn("label tier migration failed — will retry next boot", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
+		runAudioTrackClassMigration({
+			store: api.settingsStore,
+			logger: this.ctx.logger,
+			now: () => Date.now()
+		}, TRACKS_COLLECTION).catch((err) => {
+			this.ctx.logger.warn("audio track class migration failed — will retry next boot", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		});
 	}
 	/** Event-media storage. By default it uses `ctx.kernel.storage`, rooted at
 	*  the node data dir (appData) → heavy thumbnail/track-frame churn hammers
@@ -55403,6 +55979,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			frameHeight: frame.frameHeight,
 			score: detail.score,
 			embedding: decodeEmbeddingBase64(detail.embedding),
+			...detail.embeddingMagnitude !== void 0 ? { embeddingMagnitude: detail.embeddingMagnitude } : {},
 			parentBbox: { ...frame.bbox },
 			...detail.bbox !== void 0 ? { faceBbox: { ...detail.bbox } } : {},
 			...detail.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: detail.nativeFaceShortSidePx } : {},
@@ -55870,7 +56447,18 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				return;
 		}
 	}
-	async openAudioEpisode(input, ref) {
+	/**
+	* The ONE writer for a classified audio observation: the durable row, the
+	* Notification Center hook fired in the same persist moment (D-2), the
+	* track-level `audioLabels` stamp, and the telemetry event.
+	*
+	* Shared by both routes on purpose. `audioEpisodeEnabled` selects WHEN this
+	* runs (once per episode, or once per heartbeat), never WHETHER — a knob
+	* that names the grouping must not be able to silence the classified path
+	* (D62). This body was inlined in `openAudioEpisode` and the knob-off camera
+	* therefore persisted nothing at all.
+	*/
+	async persistClassifiedAudio(input) {
 		const ev = {
 			id: (0, node_crypto.randomUUID)(),
 			deviceId: input.deviceId,
@@ -55879,18 +56467,18 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			rms: input.rms,
 			dbfs: input.dbfs,
 			classification: {
-				className: ref.className,
+				className: input.className,
 				...input.originalClass !== void 0 ? { originalClass: input.originalClass } : {},
 				score: input.score
 			}
 		};
 		this.lastAudioInsertByDevice.set(input.deviceId, {
-			className: ref.className,
+			className: input.className,
 			atMs: input.timestamp
 		});
 		await this.eventStore.insertAudio(ev);
 		this.notificationCenter?.onAudioEventPersisted(ev);
-		this.trackStore?.addAudioLabelEpisode(input.deviceId, ref.className, input.score, input.timestamp);
+		this.trackStore?.addAudioLabelEpisode(input.deviceId, input.className, input.score, input.timestamp);
 		this.ctx.eventBus.emit({
 			id: `pa-${ev.id}`,
 			timestamp: new Date(ev.timestamp),
@@ -55907,6 +56495,25 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				timestamp: ev.timestamp
 			}
 		});
+	}
+	/**
+	* Classified audio with episodes OFF: persist on class change or heartbeat,
+	* and open NO synthetic track. This is the whole of what the knob switches —
+	* the timeline track and the episode coalescing — and it is what the form
+	* promises.
+	*/
+	async persistClassifiedAudioUngrouped(input) {
+		const last = this.lastAudioInsertByDevice.get(input.deviceId);
+		const sameClass = last?.className === input.className;
+		const heartbeatDue = last === void 0 || input.timestamp - last.atMs >= AUDIO_EVENT_HEARTBEAT_MS;
+		if (sameClass && !heartbeatDue) return;
+		await this.persistClassifiedAudio(input);
+	}
+	async openAudioEpisode(input, ref) {
+		await this.persistClassifiedAudio({
+			...input,
+			className: ref.className
+		});
 		if (this.hasLiveVisualTrack(input.deviceId, input.timestamp)) return;
 		const materializer = this.syntheticTracks;
 		if (materializer === null) return;
@@ -55915,7 +56522,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				cameraId: input.deviceId,
 				sourceDeviceId: input.deviceId,
 				source: "audio",
-				kind: ref.className,
+				kind: AUDIO_TRACK_CLASS,
 				timestamp: input.timestamp,
 				audioLabels: [{
 					label: ref.className,
@@ -56018,19 +56625,26 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				});
 				return;
 			}
-			await this.driveAudioEpisode({
+			const classified = {
 				deviceId,
 				timestamp,
 				className: route.className,
 				score: topClassification.score,
-				originalClass: topClassification.debug?.originalClass,
+				...topClassification.debug?.originalClass !== void 0 ? { originalClass: topClassification.debug.originalClass } : {},
 				rms: level?.rms ?? 0,
-				dbfs: level?.dbfs ?? 0,
+				dbfs: level?.dbfs ?? 0
+			};
+			if (!settings.audioEpisodeEnabled) {
+				await this.persistClassifiedAudioUngrouped(classified);
+				return;
+			}
+			await this.driveAudioEpisode({
+				...classified,
 				knobs: this.audioEpisodeKnobs(settings)
 			});
 			return;
 		}
-		await this.driveAudioEpisode({
+		if (settings.audioEpisodeEnabled) await this.driveAudioEpisode({
 			deviceId,
 			timestamp,
 			className: null,