@camstack/addon-post-analysis 1.2.286 → 1.2.288

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-CY0FGcpQ.js");
+const require_clip_model_registry = require("../clip-model-registry-eFgKIlKE.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -88,7 +88,7 @@ function motionEpisodeDurationMs(state) {
 }
 //#endregion
 //#region src/pipeline-analytics/motion-episode-tracker.ts
-function keyOf$1(deviceId, source) {
+function keyOf$2(deviceId, source) {
 	return `${deviceId}:${source}`;
 }
 var MotionEpisodeTracker = class {
@@ -104,7 +104,7 @@ var MotionEpisodeTracker = class {
 	* {@link MotionEpisodeInsertInput}.
 	*/
 	async observe(deviceId, source, detected, timestamp, regionData) {
-		const key = keyOf$1(deviceId, source);
+		const key = keyOf$2(deviceId, source);
 		const prior = this.signals.get(key);
 		const decision = decideMotionSignal(prior, detected, timestamp);
 		switch (decision.kind) {
@@ -235,6 +235,34 @@ var MotionEpisodeTracker = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/audio-classify-outcome.ts
+/**
+* The Notification Center's audio sample for one analyzer frame: its level,
+* the labels that clear the SAME per-device floor the router uses (so a rule
+* and the event log never disagree about what was heard), and whether the
+* model ran at all.
+*/
+function ncAudioSampleFromFrame(frame, timestampMs, floor) {
+	const dbfs = frame.level?.dbfs;
+	return {
+		timestampMs,
+		...dbfs !== void 0 ? { dbfs } : {},
+		labels: (frame.detections ?? []).filter((d) => d.score >= floor.classificationMinScore).map((d) => d.macroClass).filter((macroClass) => floor.audioAllowedClasses.length === 0 || floor.audioAllowedClasses.includes(macroClass)),
+		...frame.classifyOutcome !== void 0 ? { classifyOutcome: frame.classifyOutcome } : {}
+	};
+}
+/** The level-path audio row for one frame — the one row kind with no label to explain it. */
+function levelAudioEventDraft(deviceId, timestamp, frame) {
+	return {
+		deviceId,
+		timestamp,
+		kind: "audio",
+		rms: frame.level?.rms ?? 0,
+		dbfs: frame.level?.dbfs ?? 0,
+		...frame.classifyOutcome !== void 0 ? { classifyOutcome: frame.classifyOutcome } : {}
+	};
+}
+//#endregion
 //#region src/notification-center/alarm/alarm-mode-coverage.ts
 /**
 * Whether the panel just BECAME armed, in the sense a person means.
@@ -12780,14 +12808,14 @@ var NcPruneRecordSchema = require_clip_model_registry.object({
 });
 /** Rules × deleted subjects — small; a generous ceiling. */
 var LOAD_LIMIT$4 = 1e4;
-function keyOf(row) {
+function keyOf$1(row) {
 	return `${row.kind}:${row.ruleId}:${row.field}:${row.subject}`;
 }
 var NC_DEVICE_PRUNES_SPEC = {
 	collection: NC_DEVICE_PRUNES_COLLECTION,
 	columns: [...NC_DEVICE_PRUNES_COLUMNS],
 	writeMode: "write-through",
-	keyOf,
+	keyOf: keyOf$1,
 	toValue: (row) => ({
 		ruleId: row.ruleId,
 		at: row.at,
@@ -12827,7 +12855,7 @@ var NcPruneLedger = class {
 	* {@link isLoaded} as it was — see the module docblock.
 	*/
 	async load() {
-		const heldBefore = new Set(this.ledger.snapshot().map(keyOf));
+		const heldBefore = new Set(this.ledger.snapshot().map(keyOf$1));
 		const startedAt = this.writes;
 		const writtenSince = (key) => (this.writtenAt.get(key) ?? 0) > startedAt;
 		try {
@@ -12838,7 +12866,7 @@ var NcPruneLedger = class {
 			const next = /* @__PURE__ */ new Map();
 			for (const record of records) {
 				const row = NC_DEVICE_PRUNES_SPEC.fromRecord(record.id, record.data);
-				if (row !== null) next.set(keyOf(row), row);
+				if (row !== null) next.set(keyOf$1(row), row);
 			}
 			for (const key of heldBefore) if (!next.has(key) && !writtenSince(key)) this.ledger.evict(key);
 			for (const [key, row] of next) if (!writtenSince(key)) this.ledger.stage(row);
@@ -12868,7 +12896,7 @@ var NcPruneLedger = class {
 	*/
 	async record(notes, source, at) {
 		for (const note of notes) {
-			const held = this.ledger.get(keyOf(note));
+			const held = this.ledger.get(keyOf$1(note));
 			if (held !== void 0 && KEPT_OUTCOMES.has(held.outcome) && !KEPT_OUTCOMES.has(note.outcome)) continue;
 			const row = NcPruneRecordSchema.parse({
 				...note,
@@ -12876,7 +12904,7 @@ var NcPruneLedger = class {
 				source
 			});
 			this.writes += 1;
-			this.writtenAt.set(keyOf(row), this.writes);
+			this.writtenAt.set(keyOf$1(row), this.writes);
 			await this.ledger.put(row);
 		}
 	}
@@ -39708,6 +39736,87 @@ var ReembedFacesInputSchema = require_clip_model_registry.object({
 	/** Run every embed on ONE named node instead of rotating the fleet. Data, not a pin. */
 	executeOnNodeId: require_clip_model_registry.string().optional()
 });
+/**
+* D658: re-embed each sample's stored template with ONE pinned model and
+* compare with the stored vector — does the stamp say what produced it?
+* Read-only: it reports and writes nothing.
+*/
+var AuditFaceEmbeddingsInputSchema = require_clip_model_registry.object({
+	/** The stamp to verify. Omit for `auraface-r100` (the D651 default). */
+	modelId: require_clip_model_registry.string().min(1).optional(),
+	/** Only this identity's samples. */
+	identityId: require_clip_model_registry.string().min(1).optional(),
+	/** Stop after this many measured samples. */
+	maxSamples: require_clip_model_registry.number().int().positive().optional(),
+	/** Run every embed on ONE named node instead of rotating the fleet. Data, not a pin. */
+	executeOnNodeId: require_clip_model_registry.string().optional()
+});
+var AuditFaceEmbeddingsResultSchema = require_clip_model_registry.object({
+	auditedModelId: require_clip_model_registry.string(),
+	total: require_clip_model_registry.number(),
+	ok: require_clip_model_registry.number(),
+	mismatch: require_clip_model_registry.number(),
+	inconclusive: require_clip_model_registry.number(),
+	unmeasurable: require_clip_model_registry.number(),
+	complete: require_clip_model_registry.boolean(),
+	okMinCosine: require_clip_model_registry.number(),
+	mismatchMaxCosine: require_clip_model_registry.number(),
+	rows: require_clip_model_registry.array(require_clip_model_registry.object({
+		sampleId: require_clip_model_registry.string(),
+		identityId: require_clip_model_registry.string(),
+		identityName: require_clip_model_registry.string(),
+		stampedModelId: require_clip_model_registry.string(),
+		verdict: require_clip_model_registry._enum([
+			"ok",
+			"mismatch",
+			"inconclusive",
+			"unmeasurable"
+		]),
+		cosine: require_clip_model_registry.number().optional(),
+		reason: require_clip_model_registry._enum([
+			"stamped-other-model",
+			"no-pixels",
+			"no-stored-vector",
+			"embed-failed",
+			"no-capable-node",
+			"dimension-differs"
+		]).optional(),
+		detail: require_clip_model_registry.string().optional()
+	}))
+});
+/**
+* D658: re-embed EXACTLY these samples with ONE pinned model, replacing their
+* vectors even when already stamped with it — the repair for what
+* `faceGallery.auditEmbeddings` accuses. See `face-sample-reembed.ts`.
+*/
+var ReembedSamplesInputSchema = require_clip_model_registry.object({
+	sampleIds: require_clip_model_registry.array(require_clip_model_registry.string().min(1)).min(1).max(200),
+	modelId: require_clip_model_registry.string().min(1),
+	/** Run every embed on ONE named node instead of rotating the fleet. Data, not a pin. */
+	executeOnNodeId: require_clip_model_registry.string().optional()
+});
+var ReembedSamplesResultSchema = require_clip_model_registry.object({
+	pinnedModelId: require_clip_model_registry.string(),
+	requested: require_clip_model_registry.number(),
+	reembedded: require_clip_model_registry.number(),
+	failed: require_clip_model_registry.number(),
+	rows: require_clip_model_registry.array(require_clip_model_registry.object({
+		sampleId: require_clip_model_registry.string(),
+		outcome: require_clip_model_registry._enum([
+			"reembedded",
+			"not-found",
+			"duplicate",
+			"no-pixels",
+			"embed-failed",
+			"no-capable-node",
+			"no-model-stamp",
+			"not-landed"
+		]),
+		previousModelId: require_clip_model_registry.string().optional(),
+		modelId: require_clip_model_registry.string().optional(),
+		detail: require_clip_model_registry.string().optional()
+	}))
+});
 /** Mirrors `FaceReembedResult` (`face-reembed-pass.ts`) minus the sample-id set. */
 var ReembedFacesResultSchema = require_clip_model_registry.object({
 	targetModelId: require_clip_model_registry.string(),
@@ -39959,11 +40068,256 @@ var embeddingActions = require_clip_model_registry.defineCustomActions({
 	"embedding.faceAlignmentStatus": require_clip_model_registry.customAction(NoInputSchema$1, FaceAlignmentStatusSchema),
 	"embedding.backfillPhotoSources": require_clip_model_registry.customAction(BackfillPhotoSourcesInputSchema, BackfillPhotoSourcesResultSchema, { auth: "admin" }),
 	"faceGallery.sourceFrameStats": require_clip_model_registry.customAction(NoInputSchema$1, SourceFrameStatsSchema),
+	"faceGallery.reembedSamples": require_clip_model_registry.customAction(ReembedSamplesInputSchema, ReembedSamplesResultSchema, {
+		kind: "mutation",
+		auth: "admin"
+	}),
+	"faceGallery.auditEmbeddings": require_clip_model_registry.customAction(AuditFaceEmbeddingsInputSchema, AuditFaceEmbeddingsResultSchema, { auth: "admin" }),
 	"faceGallery.resetToCore": require_clip_model_registry.customAction(ResetToCoreInputSchema, ResetToCoreResultSchema, {
 		kind: "mutation",
 		auth: "admin"
 	})
 });
+async function reembedOne(deps, sample, pinned) {
+	const base = {
+		sampleId: sample.sampleId,
+		previousModelId: sample.modelId
+	};
+	const crop = await deps.loadAlignedCrop(sample);
+	if (crop === null) return {
+		...base,
+		outcome: "no-pixels"
+	};
+	const outcome = await deps.embed(sample, crop);
+	if (outcome.kind === "failed") return {
+		...base,
+		outcome: "embed-failed",
+		detail: outcome.reason
+	};
+	if (outcome.kind === "no-capable-node") return {
+		...base,
+		outcome: "no-capable-node",
+		detail: outcome.reason
+	};
+	if (outcome.modelId === void 0 || outcome.modelId === "") return {
+		...base,
+		outcome: "no-model-stamp",
+		detail: "the embed answered no model id"
+	};
+	if (outcome.modelId !== pinned) return {
+		...base,
+		outcome: "embed-failed",
+		detail: `ran "${outcome.modelId}" for a call pinned to "${pinned}"`
+	};
+	const write = await deps.store(sample, outcome.embedding, outcome.modelId, outcome.dim);
+	if (!write.landed) return {
+		...base,
+		outcome: "not-landed",
+		detail: write.reason ?? "the write did not land"
+	};
+	return {
+		...base,
+		outcome: "reembedded",
+		modelId: outcome.modelId
+	};
+}
+async function reembedFaceSamples(deps, options) {
+	const pinned = options.modelId;
+	const byId = new Map((await deps.listSamples()).map((s) => [s.sampleId, s]));
+	const pacingMs = options.pacingMs ?? 25;
+	const seen = /* @__PURE__ */ new Set();
+	const rows = [];
+	let noNode = null;
+	deps.logger.info("face sample re-embed starting", { meta: {
+		pinnedModelId: pinned,
+		requested: options.sampleIds.length
+	} });
+	for (const sampleId of options.sampleIds) {
+		if (seen.has(sampleId)) {
+			rows.push({
+				sampleId,
+				outcome: "duplicate"
+			});
+			continue;
+		}
+		seen.add(sampleId);
+		const sample = byId.get(sampleId);
+		if (sample === void 0) {
+			rows.push({
+				sampleId,
+				outcome: "not-found"
+			});
+			continue;
+		}
+		if (noNode !== null) {
+			rows.push({
+				sampleId,
+				previousModelId: sample.modelId,
+				outcome: "no-capable-node",
+				detail: noNode
+			});
+			continue;
+		}
+		const row = await reembedOne(deps, sample, pinned);
+		if (row.outcome === "no-capable-node") noNode = row.detail ?? "no capable node";
+		if (row.outcome !== "reembedded") deps.logger.warn("face sample re-embed: sample NOT re-embedded", { meta: {
+			sampleId,
+			outcome: row.outcome,
+			detail: row.detail ?? null,
+			pinnedModelId: pinned
+		} });
+		rows.push(row);
+		await deps.pause(pacingMs);
+	}
+	const reembedded = rows.filter((r) => r.outcome === "reembedded").length;
+	deps.logger.info("face sample re-embed finished", { meta: {
+		pinnedModelId: pinned,
+		requested: options.sampleIds.length,
+		reembedded,
+		failed: rows.length - reembedded
+	} });
+	return {
+		pinnedModelId: pinned,
+		requested: options.sampleIds.length,
+		reembedded,
+		failed: rows.length - reembedded,
+		rows
+	};
+}
+//#endregion
+//#region src/pipeline-analytics/face-embedding-audit.ts
+/** At or above: the stored vector is this model's. */
+var AUDIT_OK_MIN_COSINE = .98;
+/** Below: the stored vector is NOT this model's. Between the two: inconclusive. */
+var AUDIT_MISMATCH_MAX_COSINE = .9;
+/** Cosine of two vectors of equal length; `null` when either has no length. */
+function cosine(a, b) {
+	let dot = 0;
+	let na = 0;
+	let nb = 0;
+	for (let i = 0; i < a.length; i++) {
+		const x = a[i] ?? 0;
+		const y = b[i] ?? 0;
+		dot += x * y;
+		na += x * x;
+		nb += y * y;
+	}
+	if (na === 0 || nb === 0) return null;
+	return dot / Math.sqrt(na * nb);
+}
+/** The verdict a measured cosine earns. Pure. */
+function verdictOf(c) {
+	if (c >= .98) return "ok";
+	if (c < .9) return "mismatch";
+	return "inconclusive";
+}
+function rowBase(s) {
+	return {
+		sampleId: s.sampleId,
+		identityId: s.identityId,
+		identityName: s.identityName,
+		stampedModelId: s.modelId
+	};
+}
+async function measure$2(deps, sample, stored) {
+	const base = rowBase(sample);
+	if (stored === void 0) return {
+		...base,
+		verdict: "unmeasurable",
+		reason: "no-stored-vector"
+	};
+	const crop = await deps.loadAlignedCrop(sample);
+	if (crop === null) return {
+		...base,
+		verdict: "unmeasurable",
+		reason: "no-pixels"
+	};
+	const outcome = await deps.embed(sample, crop);
+	if (outcome.kind === "failed") return {
+		...base,
+		verdict: "unmeasurable",
+		reason: "embed-failed",
+		detail: outcome.reason
+	};
+	if (outcome.kind === "no-capable-node") return {
+		...base,
+		verdict: "unmeasurable",
+		reason: "no-capable-node",
+		detail: outcome.reason
+	};
+	if (outcome.embedding.length !== stored.length) return {
+		...base,
+		verdict: "unmeasurable",
+		reason: "dimension-differs",
+		detail: `stored ${stored.length}-d, re-embedded ${outcome.embedding.length}-d`
+	};
+	const c = cosine(outcome.embedding, stored);
+	if (c === null) return {
+		...base,
+		verdict: "unmeasurable",
+		reason: "no-stored-vector",
+		detail: "zero vector"
+	};
+	return {
+		...base,
+		verdict: verdictOf(c),
+		cosine: Math.round(c * 1e4) / 1e4
+	};
+}
+/**
+* Audit every sample stamped with `auditedModelId`. Read-only; bounded by
+* `maxSamples`; a pass-terminal `no-capable-node` stops measuring and reports
+* the rest as unmeasurable rather than asking again per sample.
+*/
+async function auditFaceEmbeddings(deps, options) {
+	const all = await deps.listSamples();
+	const samples = options.identityId === void 0 ? all : all.filter((s) => s.identityId === options.identityId);
+	const inSpace = samples.filter((s) => s.modelId === options.auditedModelId);
+	const stored = await deps.loadStoredVectors(inSpace.map((s) => s.sampleId));
+	const budget = options.maxSamples ?? Number.POSITIVE_INFINITY;
+	const rows = [];
+	let measured = 0;
+	let complete = true;
+	let noNode = null;
+	for (const sample of samples) {
+		if (sample.modelId !== options.auditedModelId) {
+			rows.push({
+				...rowBase(sample),
+				verdict: "unmeasurable",
+				reason: "stamped-other-model"
+			});
+			continue;
+		}
+		if (measured >= budget) {
+			complete = false;
+			continue;
+		}
+		if (noNode !== null) {
+			rows.push({
+				...rowBase(sample),
+				verdict: "unmeasurable",
+				reason: "no-capable-node",
+				detail: noNode
+			});
+			continue;
+		}
+		const row = await measure$2(deps, sample, stored.get(sample.sampleId));
+		if (row.reason === "no-capable-node") noNode = row.detail ?? "no capable node";
+		if (row.cosine !== void 0) measured += 1;
+		rows.push(row);
+	}
+	const count = (v) => rows.filter((r) => r.verdict === v).length;
+	return {
+		auditedModelId: options.auditedModelId,
+		total: samples.length,
+		ok: count("ok"),
+		mismatch: count("mismatch"),
+		inconclusive: count("inconclusive"),
+		unmeasurable: count("unmeasurable"),
+		complete,
+		rows
+	};
+}
 //#endregion
 //#region src/pipeline-analytics/face-alignment-version.ts
 /**
@@ -66007,7 +66361,8 @@ var FaceReembedEmbedder = class {
 			return {
 				kind: "embedded",
 				embedding: vector,
-				dim: vector.length
+				dim: vector.length,
+				modelId: result.modelId
 			};
 		}
 	}
@@ -84298,6 +84653,79 @@ async function resolveSubjectShot(ports, trackId, deviceId, aroundMs) {
 		frameHeight: dims.h
 	};
 }
+var MESSAGES = {
+	"dimension-mismatch": "object embeddings refused — their length is not their model's dimension",
+	"no-clip-metadata": "object embeddings refused — the model has no CLIP metadata",
+	"no-model-id": "object embeddings refused — the result names no model"
+};
+function keyOf(r) {
+	return `${String(r.deviceId)}|${r.modelId ?? ""}|${r.reason}`;
+}
+var EmbeddingRefusalReport = class {
+	logger;
+	intervalMs;
+	now;
+	keys = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.logger = options.logger;
+		this.intervalMs = options.intervalMs ?? 3e5;
+		this.now = options.now ?? (() => Date.now());
+	}
+	/** Count one refusal; write a line if this key is new or its interval passed. */
+	note(refusal) {
+		const key = keyOf(refusal);
+		const at = this.now();
+		const held = this.keys.get(key);
+		const pending = (held?.pending ?? 0) + 1;
+		if (held === void 0 || at - held.lastLineAtMs >= this.intervalMs) {
+			this.write(refusal, pending, held === void 0 ? "first" : "interval");
+			this.keys = new Map(this.keys).set(key, {
+				last: refusal,
+				pending: 0,
+				lastLineAtMs: at
+			});
+			return;
+		}
+		this.keys = new Map(this.keys).set(key, {
+			...held,
+			last: refusal,
+			pending
+		});
+	}
+	/** Report every key whose interval passed with refusals still pending. */
+	sweep() {
+		const at = this.now();
+		for (const [key, held] of this.keys) {
+			if (held.pending === 0 || at - held.lastLineAtMs < this.intervalMs) continue;
+			this.write(held.last, held.pending, "interval");
+			this.keys = new Map(this.keys).set(key, {
+				...held,
+				pending: 0,
+				lastLineAtMs: at
+			});
+		}
+	}
+	/** Report every pending count now, whatever its interval (shutdown). */
+	flush() {
+		for (const held of this.keys.values()) if (held.pending > 0) this.write(held.last, held.pending, "flush");
+		this.keys = /* @__PURE__ */ new Map();
+	}
+	write(r, refused, closing) {
+		this.logger.warn(MESSAGES[r.reason], {
+			tags: { deviceId: r.deviceId },
+			meta: {
+				reason: r.reason,
+				modelId: r.modelId,
+				refused,
+				windowMs: this.intervalMs,
+				closing,
+				lastTrackId: r.trackId,
+				...r.dim !== void 0 ? { dim: r.dim } : {},
+				...r.expected !== void 0 ? { expected: r.expected } : {}
+			}
+		});
+	}
+};
 //#endregion
 //#region src/pipeline-analytics/store/object-embedding-store.ts
 /**
@@ -84360,10 +84788,33 @@ var ObjectEmbeddingStore = class {
 	clipModels;
 	/** index → the dim this process declared it at. Per index, per process. */
 	declaredDims = /* @__PURE__ */ new Map();
+	/**
+	* Refused writes, COUNTED per (camera, model, reason). A refusal is systemic
+	* — a runner stamping the wrong model refuses every vector it sends — so a
+	* per-track WARN was a flood that hid the one fact that mattered (D658).
+	*/
+	refusals;
 	constructor(deps) {
 		this.vectorStore = deps.vectorStore;
 		this.logger = deps.logger;
 		this.clipModels = deps.clipModels;
+		this.refusals = new EmbeddingRefusalReport({
+			logger: deps.logger,
+			...deps.refusalReportIntervalMs !== void 0 ? { intervalMs: deps.refusalReportIntervalMs } : {},
+			...deps.now !== void 0 ? { now: deps.now } : {}
+		});
+	}
+	/**
+	* Count a write refused BEFORE it reached this store — a detail whose result
+	* named no model (D658). Same report, same rate limit, as the refusals the
+	* store makes itself.
+	*/
+	noteRefused(refusal) {
+		this.refusals.note(refusal);
+	}
+	/** Report every refusal count still pending (shutdown). */
+	flushRefusals() {
+		this.refusals.flush();
 	}
 	/** Every index a delete, scan or wipe must reach. */
 	indexes() {
@@ -84461,19 +84912,28 @@ var ObjectEmbeddingStore = class {
 	* and dropped", because a counter that cannot reads as verification.
 	*/
 	async upsertIfBetter(input) {
+		this.refusals.sweep();
 		const vector = resolveVectorPayload(input);
 		if (vector === null) return "failed";
-		const space = this.spaceOrWarn(input.modelId, "upsert", input.deviceId);
-		if (space === null) return "failed";
+		const space = this.clipModels.spaceFor(input.modelId);
+		if (space === null) {
+			this.refusals.note({
+				deviceId: input.deviceId,
+				modelId: input.modelId,
+				reason: "no-clip-metadata",
+				trackId: input.trackId,
+				dim: vector.dim
+			});
+			return "failed";
+		}
 		if (vector.dim !== space.dim) {
-			this.logger.warn("object embedding refused — its length is not its model's dimension", {
-				tags: { deviceId: input.deviceId },
-				meta: {
-					trackId: input.trackId,
-					modelId: input.modelId,
-					dim: vector.dim,
-					expected: space.dim
-				}
+			this.refusals.note({
+				deviceId: input.deviceId,
+				modelId: input.modelId,
+				reason: "dimension-mismatch",
+				trackId: input.trackId,
+				dim: vector.dim,
+				expected: space.dim
 			});
 			return "failed";
 		}
@@ -84947,6 +85407,30 @@ function rowFromMetadata(id, metadata) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/clip-detail-route.ts
+async function routeClipDetailToStore(store, input) {
+	const modelId = input.embeddingModelId;
+	if (modelId === void 0 || modelId === "") {
+		store.noteRefused({
+			deviceId: input.deviceId,
+			modelId: null,
+			reason: "no-model-id",
+			trackId: input.trackId
+		});
+		return "failed";
+	}
+	return store.upsertIfBetter({
+		trackId: input.trackId,
+		deviceId: input.deviceId,
+		timestamp: input.timestamp,
+		className: input.className,
+		embeddingBase64: input.embeddingBase64,
+		modelId,
+		confidence: input.score,
+		...input.keyFrameMediaId !== void 0 ? { keyFrameMediaId: input.keyFrameMediaId } : {}
+	});
+}
+//#endregion
 //#region src/pipeline-analytics/clip-space-plan.ts
 /**
 * Which CLIP feature space a search reads and a rebuild fills — decided in one
@@ -87158,9 +87642,6 @@ var KEYFRAME_CROP_MIN_SUBJECT_IOU = .5;
 *  covers a healthy trail many times over; past it the honest answer is "no
 *  evidence" and the temporal bound takes over. */
 var KEYFRAME_CROP_MAX_SAMPLE_GAP_MS = 1e3;
-/** How long the active CLIP model id (from the embedding-encoder) is cached
-*  before re-reading. */
-var CLIP_MODEL_ID_CACHE_TTL_MS = 6e4;
 var SETTINGS_CACHE_TTL_MS = 5e3;
 /** TTL for the per-node confirmation-gate detector-step cache (the node's
 *  default object-detector step rarely changes). */
@@ -87451,10 +87932,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	overlayState = new OverlayDetailStateStore();
 	/** Throttle state for the "overlay synthesis failed" warn, one per device. */
 	overlaySynthesisWarnAt = /* @__PURE__ */ new Map();
-	/** Active CLIP image-embedding model id (== the text encoder's), TTL-cached.
-	*  Stamped on object-embedding rows from the detail plane so semantic search's
-	*  same-model gate keeps matching. */
-	clipModelIdCache = null;
 	/** Frame-based event/track media (crop + boxed full-frame) from the
 	*  detection-pipeline DECODED frame — the ONLY image source (never the
 	*  snapshot cap). Null when shm frame access is unavailable. */
@@ -91330,6 +91807,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		await Promise.all([this.drainSensorHandlers(), this.motionEpisodes?.closeAll("addon-shutdown")]);
 		await this.embeddingDispatcher?.stop();
 		this.embeddingDispatcher = null;
+		this.objectEmbeddingStore?.flushRefusals();
 		await this.notificationCenter?.stop();
 		this.notificationCenter = null;
 		for (const id of this.proxies.keys()) this.releaseProxy(id);
@@ -93012,31 +93490,19 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 	}
 	/** CLIP object-embedding detail → the object-embedding store (semantic
-	*  search). Stamps the active encoder's model id so the same-model search
-	*  gate keeps matching. */
+	*  search), under the model the RUNNER stamped — never a guess (D658). */
 	async routeClipDetail(deviceId, trackId, detail, timestamp) {
 		const store = this.objectEmbeddingStore;
 		if (!store || detail.embedding === void 0) return;
-		const modelId = detail.embeddingModelId ?? await this.resolveClipModelId();
-		if (modelId === null) {
-			this.ctx.logger.debug("clip detail dropped — no active embedding model id", {
-				tags: { deviceId },
-				meta: {
-					trackId,
-					stepId: detail.stepId
-				}
-			});
-			return;
-		}
 		const keyFrameMediaId = this.residents.keyFrameMediaId(trackId);
-		await store.upsertIfBetter({
-			trackId,
+		await routeClipDetailToStore(store, {
 			deviceId,
+			trackId,
 			timestamp,
 			className: detail.className,
-			embedding: decodeEmbeddingBase64(detail.embedding),
-			modelId,
-			confidence: detail.score,
+			score: detail.score,
+			embeddingBase64: detail.embedding,
+			embeddingModelId: detail.embeddingModelId,
 			...keyFrameMediaId !== void 0 ? { keyFrameMediaId } : {}
 		});
 	}
@@ -93065,23 +93531,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			...identityId !== void 0 ? { identityId } : {}
 		});
 	}
-	/** Active CLIP image-embedding model id (== the text encoder's), TTL-cached.
-	*  Returns null when the embedding-encoder cap is unavailable. */
-	async resolveClipModelId() {
-		const now = Date.now();
-		if (this.clipModelIdCache && now < this.clipModelIdCache.expiresAt) return this.clipModelIdCache.value;
-		let value = null;
-		try {
-			value = (await this.ctx.api.embeddingEncoder.getInfo.query())?.modelId ?? null;
-		} catch (err) {
-			this.ctx.logger.debug("resolveClipModelId: getInfo failed", { meta: { error: require_clip_model_registry.errMsg(err) } });
-		}
-		this.clipModelIdCache = {
-			value,
-			expiresAt: now + CLIP_MODEL_ID_CACHE_TTL_MS
-		};
-		return value;
-	}
 	/**
 	* §5 — decide which active tracks need periodic media THIS frame. Pure over
 	* TrackStore.lastSnapshotAt + the per-track best-confidence map:
@@ -93977,6 +94426,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			kind: "audio",
 			rms: input.rms,
 			dbfs: input.dbfs,
+			classifyOutcome: { state: "classified" },
 			classification: {
 				className: input.className,
 				...input.originalClass !== void 0 ? { originalClass: input.originalClass } : {},
@@ -94124,11 +94574,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 				score: topClassification.score
 			} : {}
 		}, this.audioMarkerConfig(settings));
-		this.notificationCenter?.observeAudio(deviceId, {
-			timestampMs: timestamp,
-			...level?.dbfs !== void 0 ? { dbfs: level.dbfs } : {},
-			labels: (frame.detections ?? []).filter((d) => d.score >= settings.classificationMinScore).map((d) => d.macroClass).filter((macroClass) => settings.audioAllowedClasses.length === 0 || settings.audioAllowedClasses.includes(macroClass))
-		});
+		this.notificationCenter?.observeAudio(deviceId, ncAudioSampleFromFrame(frame, timestamp, settings));
 		const route = classifyAudioFrame(topClassification ? {
 			className: topClassification.macroClass,
 			score: topClassification.score
@@ -94203,13 +94649,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 		this.levelStateByDevice.set(deviceId, res.nextState);
 		if (!res.emit) return;
-		const draft = {
-			deviceId,
-			timestamp,
-			kind: "audio",
-			rms: level?.rms ?? 0,
-			dbfs: level?.dbfs ?? 0
-		};
+		const draft = levelAudioEventDraft(deviceId, timestamp, frame);
 		this.lastAudioInsertByDevice.set(deviceId, {
 			className: void 0,
 			atMs: timestamp
@@ -97007,6 +97447,126 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		}
 	}
 	/**
+	* D658: re-embed EXACTLY the named samples with ONE pinned model, forced
+	* (`face-sample-reembed.ts`) — the repair for what the audit accuses. Shares
+	* the gallery-job exclusion with the re-embed pass, the photo pass and the
+	* reset, and reloads the matcher's gallery when anything landed.
+	*/
+	async reembedFaceGallerySamples(input) {
+		const api = this.ctx.api;
+		if (!api) throw new Error("faceGallery.reembedSamples: the addon API is not available");
+		const identityStore = this.identityStore;
+		if (!identityStore) throw new Error("faceGallery.reembedSamples: the identity store is not ready");
+		const mediaStore = this.mediaStore;
+		if (!mediaStore) throw new Error("faceGallery.reembedSamples: the media store is not ready");
+		if (this.faceReembedRunning) throw new Error("faceGallery.reembedSamples: a face re-embed pass is already running");
+		if (this.faceAlignmentJobs?.isPhotoPassRunning === true) throw new Error("faceGallery.reembedSamples: a photo re-enrol pass is running (D643)");
+		if (this.faceAlignmentJobs?.isResetRunning === true) throw new Error("faceGallery.reembedSamples: a face gallery reset is running (D644)");
+		this.faceReembedRunning = true;
+		try {
+			const embedder = new FaceReembedEmbedder({
+				runStatelessStep: (nodeId, stepInput) => this.runRebuildStepOn(nodeId, stepInput),
+				logger: { warn: (m, e) => this.ctx.logger.warn(m, e) }
+			}, await this.resolveRebuildNodes(api, input.executeOnNodeId), input.modelId);
+			const result = await reembedFaceSamples({
+				listSamples: () => identityStore.listSamplesForReembed(),
+				loadAlignedCrop: async (sample) => {
+					if (sample.mediaId === void 0) return null;
+					try {
+						const file = await mediaStore.getById(sample.mediaId);
+						return file === null ? null : Buffer.from(file.base64, "base64");
+					} catch (err) {
+						this.ctx.logger.warn("face sample re-embed: aligned crop read threw", { meta: {
+							sampleId: sample.sampleId,
+							error: String(err)
+						} });
+						return null;
+					}
+				},
+				embed: (sample, crop) => embedder.embed(sample, crop),
+				store: (sample, embedding, modelId, dim) => identityStore.restampSample({
+					sampleId: sample.sampleId,
+					identityId: sample.identityId,
+					embedding,
+					modelId,
+					dim
+				}),
+				pause: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+				logger: {
+					info: (m, e) => this.ctx.logger.info(m, e),
+					warn: (m, e) => this.ctx.logger.warn(m, e)
+				}
+			}, {
+				sampleIds: input.sampleIds,
+				modelId: input.modelId
+			});
+			if (result.reembedded > 0) await this.faceRecognizer?.refreshGallery();
+			return {
+				...result,
+				rows: [...result.rows]
+			};
+		} finally {
+			this.faceReembedRunning = false;
+		}
+	}
+	/**
+	* D658: re-embed each sample's stored template with ONE pinned model and
+	* compare with its stored vector (`face-embedding-audit.ts`). READ-ONLY —
+	* nothing is restamped, re-embedded or removed. The pass pins the model the
+	* caller names (default `auraface-r100`), not the cluster row: the question
+	* is whether a STAMP is true, whatever the cluster runs today.
+	*/
+	async auditFaceGalleryEmbeddings(input) {
+		const api = this.ctx.api;
+		if (!api) throw new Error("faceGallery.auditEmbeddings: the addon API is not available");
+		const identityStore = this.identityStore;
+		if (!identityStore) throw new Error("faceGallery.auditEmbeddings: the identity store is not ready");
+		const mediaStore = this.mediaStore;
+		if (!mediaStore) throw new Error("faceGallery.auditEmbeddings: the media store is not ready");
+		const auditedModelId = input.modelId ?? "auraface-r100";
+		const embedder = new FaceReembedEmbedder({
+			runStatelessStep: (nodeId, stepInput) => this.runRebuildStepOn(nodeId, stepInput),
+			logger: { warn: (m, e) => this.ctx.logger.warn(m, e) }
+		}, await this.resolveRebuildNodes(api, input.executeOnNodeId), auditedModelId);
+		const report = await auditFaceEmbeddings({
+			listSamples: () => identityStore.listSamplesForReembed(),
+			loadStoredVectors: (ids) => identityStore.loadSampleVectors(ids),
+			loadAlignedCrop: async (sample) => {
+				if (sample.mediaId === void 0) return null;
+				try {
+					const file = await mediaStore.getById(sample.mediaId);
+					return file === null ? null : Buffer.from(file.base64, "base64");
+				} catch (err) {
+					this.ctx.logger.warn("face embedding audit: aligned crop read threw", { meta: {
+						sampleId: sample.sampleId,
+						error: String(err)
+					} });
+					return null;
+				}
+			},
+			embed: (sample, crop) => embedder.embed(sample, crop)
+		}, {
+			auditedModelId,
+			...input.identityId !== void 0 ? { identityId: input.identityId } : {},
+			...input.maxSamples !== void 0 ? { maxSamples: input.maxSamples } : {}
+		});
+		this.ctx.logger.info("face embedding audit finished", { meta: {
+			auditedModelId,
+			total: report.total,
+			ok: report.ok,
+			mismatch: report.mismatch,
+			inconclusive: report.inconclusive,
+			unmeasurable: report.unmeasurable,
+			complete: report.complete
+		} });
+		return {
+			...report,
+			okMinCosine: AUDIT_OK_MIN_COSINE,
+			mismatchMaxCosine: AUDIT_MISMATCH_MAX_COSINE,
+			rows: [...report.rows]
+		};
+	}
+	/**
 	* The server-side half of "change the model from any UI and the gallery
 	* follows": if a sample sits outside the cluster space and a pass could
 	* still bring it in, start one. Runs on a timer; converges and goes quiet.
@@ -97529,6 +98089,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					samples: [...result.samples]
 				};
 			},
+			"faceGallery.reembedSamples": async (input) => this.reembedFaceGallerySamples(input),
+			"faceGallery.auditEmbeddings": async (input) => this.auditFaceGalleryEmbeddings(input),
 			"faceGallery.sourceFrameStats": async () => ({ devices: this.faceSourceStats.snapshot().map((d) => ({
 				...d,
 				dropped: { ...d.dropped }