@gotcos/glasses-server 6.95.0 → 6.98.1

package/server/lib/speaker-embeddings.ts

@@ -26,6 +26,7 @@ import {
   saveVoiceProfileStore,
   type ProfileStore,
   type VoiceProfile,
+  findStoredProfile,
 } from './voice-profile-store.js'
 import { homedir } from 'node:os'
 import { spawnSync } from 'node:child_process'
@@ -43,6 +44,7 @@ const __dirname = fileURLToPath(new URL('.', import.meta.url))
 
 import { DATA_DIR } from './data-dir.js'
 import { AUTO_ENROLL_THRESHOLD, OWNER_VERIFY_SIMILARITY } from './voiceprint-floor.js'
+import { nfc, sameSpeakerName } from './speaker-name-nfc.js'
 
 export const SPEAKER_MODEL_FILENAME = '3dspeaker_speech_eres2net_sv_en_voxceleb_16k.onnx'
 
@@ -263,10 +265,23 @@ export function initSpeakerEmbeddings(): boolean {
   }
 }
 
+/**
+ * The manager is keyed on the STORED profile name, which may be decomposed (written before names were NFC) or composed. Every lookup
+ * therefore tries both forms of the name asked for, and returns the key it is actually held under.
+ */
+function managerKey(name: string): string | null {
+  if (!manager) return null
+  for (const key of new Set([name, nfc(name), name.normalize('NFD')])) if (manager.contains(key)) return key
+  return null
+}
+function removeFromManager(name: string): void {
+  if (!manager) return
+  for (const key of new Set([name, nfc(name), name.normalize('NFD')])) if (manager.contains(key)) manager.remove(key)
+}
+
 /** Check if a speaker is enrolled */
 export function isEnrolled(name: string): boolean {
-  if (!manager) return false
-  return manager.contains(name)
+  return managerKey(name) !== null
 }
 
 /** Get all enrolled speaker names */
@@ -307,7 +322,7 @@ export function enrollEmbedding(name: string, embedding: Float32Array, source: s
 
   // Check diversity: skip if too similar to an existing embedding for this speaker
   const store = loadProfileStore()
-  const profile = store.profiles.find(p => p.name === name)
+  const profile = store.profiles.find(p => sameSpeakerName(p.name, name))
   if (profile) {
     // Dedup check: skip if too similar to existing (unless bypassed by trainer)
     if (!skipDedupCheck) {
@@ -338,7 +353,7 @@ export function enrollEmbedding(name: string, embedding: Float32Array, source: s
       return { success: false, dim: extractor.dim, error: `Profile store write failed: ${errMsg(err)}` }
     }
     const updatedStore = loadProfileStore()
-    const updatedProfile = updatedStore.profiles.find(p => p.name === name)
+    const updatedProfile = updatedStore.profiles.find(p => sameSpeakerName(p.name, name))
     if (updatedProfile) {
       rebuildSpeakerInManager(name, updatedProfile.embeddings)
       console.log(`[speaker] Force-enrolled "${name}" via rebuild (${updatedProfile.embeddings.length} total, source: ${source})`)
@@ -415,7 +430,7 @@ export interface BatchEnrollResult {
 export function enrollEmbeddingsBatch(name: string, items: BatchEnrollItem[]): BatchEnrollResult {
   if (!extractor || !manager) return { enrolled: 0, declined: items.length, persisted: false, error: 'Speaker embeddings not initialized' }
   const store = loadProfileStore()
-  const profile = store.profiles.find(p => p.name === name)
+  const profile = store.profiles.find(p => sameSpeakerName(p.name, name))
   if (!profile) return { enrolled: 0, declined: items.length, persisted: false, error: 'No such profile' }
   let added = 0
   let declined = 0
@@ -474,13 +489,14 @@ export function identifySpeaker(
     // Phase 4: scoped search — try expected attendees first
     if (expectedSpeakers && expectedSpeakers.length > 0) {
       for (const name of expectedSpeakers) {
-        if (name === owner) continue // wearer already checked
-        if (!manager.contains(name)) continue
-        const matches = manager.verify({ name, v: embedding, threshold: Math.max(SEARCH_THRESHOLD, minimum) })
+        if (sameSpeakerName(name, owner)) continue // wearer already checked
+        const held = managerKey(name)
+        if (!held) continue
+        const matches = manager.verify({ name: held, v: embedding, threshold: Math.max(SEARCH_THRESHOLD, minimum) })
         if (matches) {
-          const similarity = computeCosineSimilarity(embedding, name)
-          logCalibration(name, similarity, true, options.event)
-          return { speaker: name, similarity, embedding }
+          const similarity = computeCosineSimilarity(embedding, held)
+          logCalibration(held, similarity, true, options.event)
+          return { speaker: held, similarity, embedding }
         }
       }
     }
@@ -518,7 +534,7 @@ export function autoEnroll(
   sessionId: string,
 ): { enrolled: boolean; reason: string } {
   if (!extractor || !manager) return { enrolled: false, reason: 'not initialized' }
-  if (name === getOwnerSpeakerLabel() || name === 'Ext') return { enrolled: false, reason: 'skip owner/Ext' }
+  if (sameSpeakerName(name, getOwnerSpeakerLabel()) || name === 'Ext') return { enrolled: false, reason: 'skip owner/Ext' }
   if (similarity < AUTO_ENROLL_THRESHOLD) return { enrolled: false, reason: `similarity ${similarity.toFixed(3)} < ${AUTO_ENROLL_THRESHOLD}` }
 
   // Check if already auto-enrolled this session
@@ -565,7 +581,7 @@ export function clearAutoEnrollSession(sessionId: string): void {
 /** Clear all embeddings for a speaker (used by fresh training mode) */
 export function clearSpeakerEmbeddings(name: string): boolean {
   const store = loadProfileStore()
-  const profile = store.profiles.find(p => p.name === name)
+  const profile = store.profiles.find(p => sameSpeakerName(p.name, name))
   if (!profile || profile.embeddings.length === 0) return false
 
   console.log(`[speaker] Clearing ${profile.embeddings.length} embeddings for "${name}"`)
@@ -573,9 +589,7 @@ export function clearSpeakerEmbeddings(name: string): boolean {
   profile.sources = []
 
   // Remove from manager
-  if (manager && manager.contains(name)) {
-    try { manager.remove(name) } catch { /* ignore */ }
-  }
+  try { removeFromManager(name) } catch { /* ignore */ }
 
   // Persist. A "fresh training" clear legitimately empties one profile but must
   // never be able to empty the whole store, so allowEmpty stays off here.
@@ -621,7 +635,7 @@ export function mergeSpeakerProfiles(
   options: { force?: boolean; dryRun?: boolean } = {},
 ): MergeReport {
   const store = loadProfileStore()
-  const target = store.profiles.find(p => p.name === into)
+  const target = findStoredProfile(store, into)
   const report: MergeReport = {
     into,
     merged: [],
@@ -641,10 +655,11 @@ export function mergeSpeakerProfiles(
   const eligible: string[] = []
   const refused: { name: string; similarity: number; floor: number }[] = []
   for (const name of from) {
-    if (name === into) continue
-    const source = store.profiles.find(p => p.name === name)
-    if (!source) { report.missing.push(name); continue }
-    const similarity = profileSimilarity(target, source)
+    // The target is never its own source, but a twin stored under the same name in the other form is a different profile and merges.
+    const sources = store.profiles.filter(p => p !== target && sameSpeakerName(p.name, name))
+    if (sources.length === 0) { if (!sameSpeakerName(name, into)) report.missing.push(name); continue }
+    // Every stored copy of the name is merged, so every copy has to clear the floor; the lowest one is what is reported.
+    const similarity = Math.min(...sources.map(source => profileSimilarity(target, source)))
     report.similarity[name] = Math.round(similarity * 1000) / 1000
     if (similarity < MERGE_SIMILARITY_FLOOR && !options.force) {
       refused.push({ name, similarity: report.similarity[name], floor: MERGE_SIMILARITY_FLOOR })
@@ -696,7 +711,7 @@ export function mergeSpeakerProfiles(
   // tests (no 26 MB model), so this side effect has no test seam — the reason
   // it is expressed as a single reused call rather than bespoke logic.
   for (const name of outcome.mergedFrom) rebuildSpeakerInManager(name, [])
-  rebuildSpeakerInManager(into, target.embeddings)
+  rebuildSpeakerInManager(target.name, target.embeddings)
   writeProfileStore(store)
   console.log(
     `[speaker] Merged ${outcome.mergedFrom.join(', ')} into "${into}"`,
@@ -712,9 +727,7 @@ export function removeSpeakerProfile(name: string): { removedProfiles: number; r
   const result = deleteProfileFromStore(store, name)
   if (result.removedProfiles === 0) return result
 
-  if (manager && manager.contains(name)) {
-    try { manager.remove(name) } catch { /* the on-disk removal is the durable half */ }
-  }
+  try { removeFromManager(name) } catch { /* the on-disk removal is the durable half */ }
   // allowEmpty: deleting the only enrolled person is a legitimate reset, and the
   // caller has already confirmed it explicitly.
   writeProfileStore(store, { allowEmpty: true })
@@ -729,7 +742,7 @@ export function retractEmbeddingsBySource(
   matches: (source: string) => boolean,
 ): { removed: number; remaining: number } {
   const store = loadProfileStore()
-  const profile = store.profiles.find(p => p.name === name)
+  const profile = store.profiles.find(p => sameSpeakerName(p.name, name))
   if (!profile) return { removed: 0, remaining: 0 }
 
   const removed = removeEmbeddingsBySource(profile, matches)
@@ -743,7 +756,7 @@ export function retractEmbeddingsBySource(
 /** Get embedding count for a speaker */
 export function getEmbeddingCount(name: string): number {
   const store = loadProfileStore()
-  const profile = store.profiles.find(p => p.name === name)
+  const profile = store.profiles.find(p => sameSpeakerName(p.name, name))
   return profile?.embeddings.length ?? 0
 }
 
@@ -1060,9 +1073,9 @@ function invalidateProfileCache(): void {
 function restoreProfileFromDisk(name: string): void {
   invalidateProfileCache()
   try {
-    const fresh = loadProfileStore().profiles.find(p => p.name === name)
-    if (fresh && fresh.embeddings.length > 0) rebuildSpeakerInManager(name, fresh.embeddings)
-    else if (manager?.contains(name)) manager.remove(name)
+    const fresh = loadProfileStore().profiles.find(p => sameSpeakerName(p.name, name))
+    if (fresh && fresh.embeddings.length > 0) rebuildSpeakerInManager(fresh.name, fresh.embeddings)
+    else removeFromManager(name)
   } catch (err: unknown) {
     console.error(`[speaker] Could not restore "${name}" from disk after a failed write:`, errMsg(err))
   } finally {
@@ -1077,7 +1090,7 @@ function persistProfile(name: string, embedding: Float32Array, source: string =
   try {
     const store = loadProfileStore()
 
-    let profile = store.profiles.find(p => p.name === name)
+    let profile = store.profiles.find(p => sameSpeakerName(p.name, name))
     if (!profile) {
       profile = { name, embeddings: [], sources: [] }
       store.profiles.push(profile)
@@ -1131,10 +1144,8 @@ export function computeCentroid(embeddings: number[][]): Float32Array {
 function rebuildSpeakerInManager(name: string, embeddings: number[][]): void {
   if (!manager) return
   try {
-    // Remove existing entry
-    if (manager.contains(name)) {
-      manager.remove(name)
-    }
+    // Remove the existing entry, whichever form it is held under
+    removeFromManager(name)
     if (embeddings.length === 0) return
 
     // Register centroid of all embeddings

package/server/lib/speaker-name-nfc.ts

@@ -0,0 +1,37 @@
+/**
+ * Speaker names are compared and stored in NFC.
+ *
+ * Foundation's `Process` turns an argument into decomposed Unicode (NFD): COS Control's helper sent `Pólya` and the server
+ * received the bytes `50 6f cc 81 6c 79 61`, where NFC is `50 c3 b3 6c 79 61`. A sidecar written by the pipeline holds NFC, so a
+ * confirm of "Brigitta Pólya" answered 409 `No chunk in this meeting is labelled` while 11 chunks carried that name.
+ *
+ * Two rules, applied everywhere a name arrives in a request or is matched against stored data:
+ *   1. Normalize a name to NFC at the route boundary (`bodyName`, `nfc`), so nothing decomposed is ever WRITTEN to a sidecar, a
+ *      ledger or a voice profile.
+ *   2. Compare with NFC on both sides (`sameSpeakerName`), so a name already stored decomposed (written before this existed)
+ *      still matches its composed spelling. Stored data is not rewritten.
+ */
+export function nfc(name: string): string { return name.normalize('NFC') }
+
+export function sameSpeakerName(a: unknown, b: unknown): boolean {
+  return typeof a === 'string' && typeof b === 'string' && (a === b || nfc(a) === nfc(b))
+}
+
+/** A request value as a name: a string in NFC, or '' for anything else. */
+export function bodyName(value: unknown): string { return typeof value === 'string' ? nfc(value) : '' }
+
+/** A regular expression source that matches `name` in either form, for text that may hold either. */
+export function nameForms(name: string, escape: (s: string) => string): string {
+  const composed = nfc(name), decomposed = name.normalize('NFD')
+  return composed === decomposed ? escape(composed) : `(?:${escape(composed)}|${escape(decomposed)})`
+}
+
+/** A record id carries a filename, and Control's helper hands it over decomposed: equal when they are the same text in NFC. */
+export function sameRecordId(requested: unknown, expected: string): boolean {
+  return typeof requested === 'string' && (requested === expected || nfc(requested) === nfc(expected))
+}
+
+/** True when raw text holds `name` in either Unicode form (a file written before names were normalized may hold the decomposed one). */
+export function textHasName(raw: string, name: string): boolean {
+  return raw.includes(name) || raw.includes(nfc(name)) || raw.includes(name.normalize('NFD'))
+}

package/server/lib/speaker-rename-fanout.ts

@@ -6,6 +6,7 @@
 import { readFileSync, readdirSync, lstatSync, realpathSync } from 'node:fs'
 import { join } from 'node:path'
 import { renameMeetingSpeaker } from './held-naming-batches.js'
+import { nameForms, sameSpeakerName, textHasName } from './speaker-name-nfc.js'
 
 /** A month directory, and nothing that merely looks like one. */
 const CANONICAL_MONTH = /^\d{4}-\d{2}$/
@@ -153,7 +154,7 @@ export async function fanOutSpeakerRename(
     if (!path.endsWith(SIDECAR_SUFFIX)) continue
     const markdownPath = path.slice(0, -SIDECAR_SUFFIX.length) + '.md'
     coveredMarkdown.add(markdownPath)
-    if (!raw.includes(from)) continue
+    if (!textHasName(raw, from)) continue
     try {
       const doc = JSON.parse(raw)
       if (!doc || Array.isArray(doc) || typeof doc !== 'object') throw new Error('sidecar is not a JSON object')
@@ -190,7 +191,7 @@ export async function fanOutSpeakerRename(
   // Cloud-only and archived markdown has no raw G2 position authority. Keep it
   // visible in the report rather than rewriting an attendee or quoted name.
   for (const [path, raw] of entries) {
-    if (!path.endsWith('.md') || coveredMarkdown.has(path) || !raw.includes(from)) continue
+    if (!path.endsWith('.md') || coveredMarkdown.has(path) || !textHasName(raw, from)) continue
     if (hasNamedLabel(raw, from)) result.skipped.push({
       path, reason: 'no G2 session sidecar; transcript labels cannot be safely aligned',
     })
@@ -203,13 +204,13 @@ function errorText(error: unknown): string {
 }
 
 function carriesSpeaker(doc: Record<string, any>, name: string): boolean {
-  return (Array.isArray(doc.chunks) && doc.chunks.some((chunk: any) => chunk?.speaker === name))
-    || (Array.isArray(doc.chunkEntries) && doc.chunkEntries.some((entry: any) => entry?.chunk?.speaker === name))
+  return (Array.isArray(doc.chunks) && doc.chunks.some((chunk: any) => sameSpeakerName(chunk?.speaker, name)))
+    || (Array.isArray(doc.chunkEntries) && doc.chunkEntries.some((entry: any) => sameSpeakerName(entry?.chunk?.speaker, name)))
     || (Array.isArray(doc.batchSegments) && doc.batchSegments.some((segment: any) =>
-      Array.isArray(segment?.speakerWords) && segment.speakerWords.some((word: any) => word?.speaker === name)))
+      Array.isArray(segment?.speakerWords) && segment.speakerWords.some((word: any) => sameSpeakerName(word?.speaker, name))))
 }
 
-function escapedName(name: string): string { return name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') }
+function escapedName(name: string): string { return nameForms(name, n => n.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')) }
 function hasNamedLabel(markdown: string, name: string): boolean {
   const escaped = escapedName(name)
   return new RegExp(`^(?:\\[${escaped}\\]:|\\*\\*${escaped}(?::\\*\\*|\\*\\*)|[-*] ${escaped}$)`, 'm').test(markdown)

package/server/lib/speaker-shadow-decide.ts

@@ -1,4 +1,4 @@
-// Speaker merge shadow mode (6.95.0): the gates, ported EXACTLY from the research tool.
+// Speaker merge shadow mode: the research gates plus the Wave-1 anchor gate.
 //
 // SOURCE OF TRUTH. `community-1-fluidaudio-v1/scripts/hybrid.py` `decide()` (round 2) and
 // the report assembly in `round3/propose.py`, on CPython 3.15. Production `Voice N` labels
@@ -9,21 +9,31 @@
 //   (b) it has at least `floorSeconds` (15 s) of production speech;
 //   (c) its window-embedding centroid lies inside the target cluster's own spread,
 //       measured leave-fragment-out against the 95th percentile.
+//   (d) a nonanchor's centroid distance from the kept voice must be <=1.5 times
+//       that anchor's own p95 spread. Missing evidence fails closed. The anchor
+//       remains the longest voice passing (a)-(c); a rejected fragment never
+//       causes selection of another anchor.
 // Named labels, `Ext` and every non-Voice label are frozen: never merged into or out of.
-// The post-hoc anchor ratio is computed and REPORTED ONLY. It decides nothing.
 //
 // LOG ONLY. Nothing here writes, and nothing calls a writer: the output is a proposal record.
 //
 // Order and rounding are part of the contract: Python dicts iterate in insertion order,
-// max()/most_common(1) keep the FIRST maximum, sorted() is stable, gates compare ROUNDED
-// values and reason strings use Python %-formatting. Every one of those is kept below,
+// max()/most_common(1) keep the FIRST maximum, sorted() is stable, research gates compare
+// ROUNDED values and reason strings use Python %-formatting. Gate(d) uses the raw ratio.
+// The research numerics remain unchanged below,
 // with the Python-compatible numerics in speaker-shadow-numeric.ts.
 
 import { PY_VOICE_LABEL, codePointCompare, pyClock, pyFirstInt, pyFixed, pyRound, pyRoundInt, pySum } from './speaker-shadow-numeric.js'
 
 export const SHADOW_SAMPLE_RATE = 16_000
-/** The round-2 gates, fixed before scoring (RESULT-ROUND2.md). */
-export const SHADOW_GATES = Object.freeze({ majority: 0.8, minCoveredFraction: 0.5, floorSeconds: 15, anchorRatioPostHoc: 1.5 })
+/** Existing round-2 gates plus the separately enforced Wave-1 anchor ratio. */
+export const SHADOW_GATES = Object.freeze({ majority: 0.8, minCoveredFraction: 0.5, floorSeconds: 15, anchorRatioMax: 1.5,
+  /** Compatibility alias for older report consumers; this is now enforced. */
+  anchorRatioPostHoc: 1.5 })
+
+export function passesShadowAnchorRatio(ratio: number | null): boolean {
+  return ratio !== null && Number.isFinite(ratio) && ratio >= 0 && ratio <= SHADOW_GATES.anchorRatioMax
+}
 
 /** One production segment on the reconstructed timeline: [lo, hi) samples and its label. */
 export type ShadowSegment = readonly [lo: number, hi: number, label: string]
@@ -154,6 +164,10 @@ export interface ShadowVoiceRow {
   fragmentEmbeddings: number
   otherClusterMembers: number
   outlier: ShadowOutlier
+  /** Unrounded ratio used by gate (d); null for the anchor or missing evidence. */
+  anchorRatio: number | null
+  /** null means this voice is the anchor or is not in a proposed group. */
+  anchorRatioPass: boolean | null
   eligible: boolean
   reasons: string[]
 }
@@ -161,6 +175,20 @@ export interface ShadowVoiceRow {
 export interface ShadowItem { vec: number[]; exportCluster: string; outputCluster: string | null; voice: string | null }
 export interface ShadowGroup { cluster: string; voices: string[]; anchor: string | null; mergedIntoAnchor: string[] }
 
+/** The anchor spread is independent of the fragment; do not inflate it with
+ * candidate fragments, and do not accept a missing/zero spread as agreement. */
+function anchorRatio(fragment: readonly number[][], anchor: readonly number[][]): number | null {
+  if (fragment.length < 3 || anchor.length < 3 || [...fragment, ...anchor].some(v =>
+    v.length !== 256 || v.some(x => !Number.isFinite(x)) || !v.some(x => x !== 0))) return null
+  const centroid = meanDir(anchor)
+  const spread = p95(anchor.map(v => cosdist(v, centroid)))
+  const distance = cosdist(meanDir(fragment), centroid)
+  if (!Number.isFinite(spread) || !(spread > 0) || !Number.isFinite(distance) || distance < -1e-12) return null
+  // Unit-vector dot products can exceed one by a rounding ulp.
+  const ratio = Math.max(0, distance) / spread
+  return Number.isFinite(ratio) ? ratio : null
+}
+
 export interface ShadowDecision {
   voices: Map<string, Array<[number, number]>>
   rows: Map<string, ShadowVoiceRow>
@@ -233,7 +261,7 @@ export function decide(
       topCluster: top,
       majority: covered ? pyRound(topN / covered, 3) : 0,
       fragmentEmbeddings: 0, otherClusterMembers: 0,
-      outlier: { pass: false, reason: '' }, eligible: false, reasons: [],
+      outlier: { pass: false, reason: '' }, anchorRatio: null, anchorRatioPass: null, eligible: false, reasons: [],
     })
   }
 
@@ -278,13 +306,30 @@ export function decide(
   const remap = new Map<string, string>()
   const rejected: ShadowDecision['rejected'] = []
   const groups: ShadowGroup[] = []
+  const vecs = new Map<string, number[][]>()
+  for (const item of items) if (item.voice) {
+    const list = vecs.get(item.voice)
+    if (list) list.push(item.vec); else vecs.set(item.voice, [item.vec])
+  }
   let proposed = 0, accepted = 0
   for (const [k, vs] of [...byCluster].sort((x, y) => codePointCompare(x[0], y[0]))) {
     if (vs.length < 2) continue
     proposed += vs.length - 1
-    const ok = longestFirst(vs.filter(v => rows.get(v)!.eligible))
-    const anchor = ok[0] ?? null
-    const merged = ok.slice(1)
+    const baseEligible = longestFirst(vs.filter(v => rows.get(v)!.eligible))
+    const anchor = baseEligible[0] ?? null
+    if (anchor) for (const v of vs) {
+      if (v === anchor) continue
+      const row = rows.get(v)!
+      row.anchorRatio = anchorRatio(vecs.get(v) ?? [], vecs.get(anchor) ?? [])
+      row.anchorRatioPass = passesShadowAnchorRatio(row.anchorRatio)
+      if (row.eligible && !row.anchorRatioPass) {
+        row.eligible = false
+        row.reasons.push(row.anchorRatio === null ? '(d) anchor ratio evidence unavailable'
+          : `(d) anchor ratio ${pyFixed(row.anchorRatio, 4)} > ${pyFixed(SHADOW_GATES.anchorRatioMax, 2)}`)
+      }
+    }
+    const ok = baseEligible.filter(v => rows.get(v)!.eligible)
+    const merged = ok.filter(v => v !== anchor)
     accepted += merged.length
     for (const v of merged) remap.set(v, anchor!)
     for (const v of vs) {
@@ -315,7 +360,9 @@ export interface ShadowVoiceEntry {
   outlierDistance: number | null
   outlierP95: number | null
   outlierNote: string | null
-  /** UNVALIDATED post-hoc check, reported only (fragment centroid vs the kept voice's spread). */
+  /** Applied unrounded ratio. Optional only for older persisted proposal rows. */
+  anchorRatio?: number | null
+  /** Rounded compatibility field; gate (d) uses the row's UNROUNDED ratio. */
   anchorRatioPostHoc: number | null
   eligible: boolean
   reasons: string[]
@@ -368,16 +415,6 @@ export function buildShadowProposals(
   const byLabel = new Map<string, ShadowSegmentSource[]>()
   segs.forEach(([, , label], i) => { const list = byLabel.get(label); if (list) list.push(sources[i]); else byLabel.set(label, [sources[i]]) })
 
-  const vecs = new Map<string, number[][]>()
-  for (const it of D.items) if (it.voice) { const list = vecs.get(it.voice); if (list) list.push(it.vec); else vecs.set(it.voice, [it.vec]) }
-  const ratio = (v: string, anchor: string): number | null => {
-    const A = vecs.get(anchor) ?? [], B = vecs.get(v) ?? []
-    if (v === anchor || A.length < 3 || B.length < 3) return null
-    const ca = meanDir(A)
-    const thr = p95(A.map(x => cosdist(x, ca)))
-    return thr > 0 ? pyRound(cosdist(meanDir(B), ca) / thr, 2) : null
-  }
-
   // Named / non-Voice labels sharing each FluidAudio cluster (caution only; never merged).
   const named = new Map<string, Map<string, number>>()
   for (const [lo, hi, label] of segs) {
@@ -399,7 +436,7 @@ export function buildShadowProposals(
       outlierDistance: 'reason' in o ? null : o.fragmentCentroidDistance,
       outlierP95: 'reason' in o ? null : o.clusterP95Distance,
       outlierNote: 'reason' in o ? o.reason : null,
-      anchorRatioPostHoc: ratio(v, anchor), eligible: r.eligible, reasons: r.reasons,
+      anchorRatio: r.anchorRatio, anchorRatioPostHoc: r.anchorRatio === null ? null : pyRound(r.anchorRatio, 2), eligible: r.eligible, reasons: r.reasons,
       listen: listenPointers(v, byLabel),
     }
   }

package/server/lib/speaker-shadow-pair-source.ts

@@ -0,0 +1,91 @@
+// Bounded read-only clock diagnostics. File dates and timestamps are not alignment proof.
+import { open, readdir, lstat } from 'node:fs/promises'
+import { constants } from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import { createHash } from 'node:crypto'
+
+export interface ShadowPairSource {
+  status: 'time_only' | 'ambiguous' | 'unpaired'
+  reason: string
+  sessionId?: string
+  sourceSha256?: string
+  g2?: { startTime: number; chunks: Array<{ speaker: string; elapsed: number; audioDurationMs: number }> }
+}
+const finite = (n: unknown): n is number => typeof n === 'number' && Number.isFinite(n)
+function bounds(value: Record<string, unknown>, durationOverride?: number): [number, number] | null {
+  if (!finite(value.startTime) || !Array.isArray(value.chunks)) return null
+  const duration = durationOverride ?? value.durationMs
+  if (!finite(duration) || duration <= 0 || duration > 4 * 3600_000) return null
+  return [value.startTime, value.startTime + duration]
+}
+const day = (ms: number) => { const d = new Date(ms); return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}` }
+/** Only the current recording directory is searched; absent cross-month pairs remain unpaired. */
+export async function findShadowPairSource(sidecarPath: string, mac: Record<string, unknown>, durationMs?: number): Promise<ShadowPairSource> {
+  const target = bounds(mac, durationMs)
+  if (!target) return { status: 'unpaired', reason: 'invalid Mac clock or duration' }
+  const dir = dirname(sidecarPath)
+  // Official sidecars use this Mac's local calendar-day prefix. Include a four-hour
+  // lookback for a G2 capture that started before this Mac capture (maximum call length).
+  const days = new Set([day(target[0] - 4 * 3600_000), day(target[0]), day(target[1])])
+  const all = await readdir(dir)
+  const names = all.filter(n => n.endsWith('.g2-chunks.json') && n !== basename(sidecarPath))
+    .filter(n => { const prefix = n.match(/^(\d{4}-\d{2}-\d{2})_/); return !prefix || days.has(prefix[1]) }).sort()
+  if (names.length > 256) return { status: 'ambiguous', reason: 'day-window discovery file limit exceeded; no pair selected' }
+  let bytes = 0, estimated = false
+  const candidates: ShadowPairSource[] = []
+  for (const name of names) {
+    const path = join(dir, name)
+    let raw: string, value: Record<string, unknown>
+    try {
+      const stat = await lstat(path)
+      if (!stat.isFile() || stat.isSymbolicLink()) return { status: 'ambiguous', reason: 'unreadable day-window candidate; no pair selected' }
+      if (stat.size > 16 * 1024 * 1024 || bytes + stat.size > 128 * 1024 * 1024) return { status: 'ambiguous', reason: 'day-window discovery byte limit exceeded; no pair selected' }
+      const parts: Buffer[] = []
+      let size = 0
+      // A candidate can change between lstat and open. Never wait on a FIFO/device
+      // substituted in that interval; verify the actual descriptor before reading.
+      const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK)
+      try {
+        if (!(await handle.stat()).isFile()) throw new Error('candidate is no longer a regular file')
+        const buffer = Buffer.alloc(64 * 1024)
+        while (true) {
+          const { bytesRead } = await handle.read(buffer)
+          if (!bytesRead) break
+          size += bytesRead
+          if (size > 16 * 1024 * 1024 || bytes + size > 128 * 1024 * 1024) throw new Error('candidate grew beyond byte budget')
+          parts.push(Buffer.from(buffer.subarray(0, bytesRead)))
+        }
+      } finally { await handle.close() }
+      raw = Buffer.concat(parts).toString('utf8')
+      bytes += size
+      if (Buffer.byteLength(raw) > 16 * 1024 * 1024 || bytes > 128 * 1024 * 1024) return { status: 'ambiguous', reason: 'day-window discovery changed beyond byte limit; no pair selected' }
+      const parsed: unknown = JSON.parse(raw)
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('invalid sidecar')
+      value = parsed as Record<string, unknown>
+      if (typeof value.sessionId !== 'string') throw new Error('missing source identity')
+    } catch { return { status: 'ambiguous', reason: 'unreadable or malformed day-window candidate; no pair selected' } }
+    if (typeof value.sessionId !== 'string' || !value.sessionId.startsWith('meeting_') || value.finalizationState !== 'complete') continue
+    const span = bounds(value)
+    if (!span) return { status: 'ambiguous', reason: 'complete G2 candidate lacks valid clock/duration; no pair selected' }
+    const overlap = Math.max(0, Math.min(target[1], span[1]) - Math.max(target[0], span[0]))
+    const macDuration = target[1] - target[0], g2Duration = span[1] - span[0]
+    if (overlap / Math.max(macDuration, g2Duration) < .5 || Math.min(macDuration, g2Duration) / Math.max(macDuration, g2Duration) < .5) continue
+    const chunks: NonNullable<ShadowPairSource['g2']>['chunks'] = []
+    for (const item of value.chunks as unknown[]) {
+      if (!item || typeof item !== 'object') return { status: 'ambiguous', reason: 'invalid G2 chunk; no pair selected' }
+      const row = item as Record<string, unknown>
+      if (typeof row.speaker !== 'string' || !finite(row.elapsed) || row.elapsed < 0) return { status: 'ambiguous', reason: 'invalid G2 timing or label; no pair selected' }
+      const exactDuration = row.audioDurationMs ?? row.durationMs
+      if (exactDuration !== undefined && (!finite(exactDuration) || exactDuration <= 0 || (row.audioDurationMs !== undefined && row.durationMs !== undefined && row.audioDurationMs !== row.durationMs))) return { status: 'ambiguous', reason: 'invalid G2 duration; no pair selected' }
+      // Historical G2 sidecars lack chunk durations: disclose the fixed-window
+      // approximation. This function can NEVER qualify alignment or transfer a name.
+      const duration = exactDuration === undefined ? 6000 : exactDuration as number
+      estimated ||= exactDuration === undefined
+      chunks.push({ speaker: row.speaker, elapsed: row.elapsed, audioDurationMs: duration })
+    }
+    candidates.push({ status: 'time_only', reason: '', sessionId: value.sessionId, sourceSha256: createHash('sha256').update(raw).digest('hex'), g2: { startTime: span[0], chunks } })
+  }
+  const scope = `Day-window scan: ${names.length} files, ${bytes} bytes, current directory only.`
+  return candidates.length === 1 ? { ...candidates[0], reason: `Clock overlap only; text offset/drift alignment has not been qualified. G2 names are estimates.${estimated ? ' G2 chunk durations use an approximate 6-second window where absent.' : ''} ${scope}` }
+    : { status: candidates.length ? 'ambiguous' : 'unpaired', reason: `${candidates.length ? `${candidates.length} overlapping G2 candidates; no pair chosen` : 'no complete overlapping G2 capture'}. ${scope}` }
+}