@gotcos/glasses-server 6.94.2 → 6.94.4

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-trainer.ts

@@ -13,6 +13,7 @@ import {
   rawCosineSimilarity, saveProfileStore, rebuildAllProfiles, clearSpeakerEmbeddings,
 } from './speaker-embeddings.js'
 import { COS_SCRIPTS_DIR } from './python-bridge.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 const CACHE_DIR = '/tmp/cos-speaker-training'
 const PROGRESS_PATH = resolve(CACHE_DIR, 'training-progress.json')
@@ -520,7 +521,7 @@ export async function getTrainingStatus(): Promise<TrainingStatus> {
   }
 
   for (const name of enrolledNames) {
-    if (!speakers.some(s => s.name === name)) {
+    if (!speakers.some(s => sameSpeakerName(s.name, name))) {
       speakers.push({ name, segments: 0, meetings: 0, enrolled: true })
     }
   }

package/server/lib/voice-directory.ts

@@ -26,6 +26,7 @@ import {
 } from './meeting-speaker-review.js'
 import { getOwnerSpeakerLabel } from './profile.js'
 import { readVoiceProfiles, type VoiceProfile } from './speaker-embeddings.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 const MONTH = /^\d{4}-(0[1-9]|1[0-2])$/
 const SIDECAR = /\.g2-chunks\.json$/
@@ -363,7 +364,7 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
       .slice(0, MAX_APPEARANCES_PER_VOICE)
     return {
       name: profile.name,
-      isOwner: profile.name === owner,
+      isOwner: sameSpeakerName(profile.name, owner),
       embeddings: profile.embeddings.length,
       sources: sourceCounts(profile),
       sourcesAligned: (profile.sources?.length ?? 0) === profile.embeddings.length,

package/server/lib/voice-profile-store.ts

@@ -16,6 +16,7 @@ import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:f
 import { basename, dirname, join, resolve } from 'node:path'
 import { durableAtomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
 import { EVICTION_ORDER, isMacAssign, macAssignCapFor, provenanceTier } from './embedding-eviction.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 export interface VoiceProfile {
   name: string
@@ -512,6 +513,11 @@ export interface MergeOutcome {
  * removable later, and overwriting it to record a bookkeeping event would trade
  * a useful fact for a useless one.
  */
+/** The profile stored under `name`: the exact spelling first, else the one that is the same name in NFC. */
+export function findStoredProfile(store: ProfileStore, name: string): VoiceProfile | undefined {
+  return store.profiles.find(p => p.name === name) ?? store.profiles.find(p => sameSpeakerName(p.name, name))
+}
+
 export function mergeProfilesInStore(
   store: ProfileStore,
   into: string,
@@ -519,7 +525,7 @@ export function mergeProfilesInStore(
   options: { cap?: number } = {},
 ): MergeOutcome {
   const cap = options.cap ?? 40
-  const target = store.profiles.find(p => p.name === into)
+  const target = findStoredProfile(store, into)
   const outcome: MergeOutcome = {
     similarity: {},
     samplesBefore: target?.embeddings.length ?? 0,
@@ -537,18 +543,23 @@ export function mergeProfilesInStore(
   const sources = [...(target.sources ?? [])]
   while (sources.length < embeddings.length) sources.push(UNKNOWN_SOURCE)
 
+  // Sources are the stored profiles themselves, never the spelling asked for: a name stored decomposed and its composed twin are two
+  // profiles (the twin is merged into the one that was asked for), and the target is never its own source.
+  const absorbed = new Set<VoiceProfile>()
   for (const name of from) {
-    if (name === into) continue
-    const source = store.profiles.find(p => p.name === name)
-    if (!source) { outcome.missing.push(name); continue }
-    outcome.similarity[name] = profileSimilarity(target, source)
-    const sourceSources = [...(source.sources ?? [])]
-    while (sourceSources.length < source.embeddings.length) sourceSources.push(UNKNOWN_SOURCE)
-    for (let i = 0; i < source.embeddings.length; i++) {
-      embeddings.push(source.embeddings[i])
-      sources.push(sourceSources[i] ?? UNKNOWN_SOURCE)
+    const found = store.profiles.filter(p => p !== target && !absorbed.has(p) && sameSpeakerName(p.name, name))
+    if (found.length === 0) { if (!store.profiles.some(p => sameSpeakerName(p.name, name) && p !== target)) outcome.missing.push(name); continue }
+    for (const source of found) {
+      outcome.similarity[name] = profileSimilarity(target, source)
+      const sourceSources = [...(source.sources ?? [])]
+      while (sourceSources.length < source.embeddings.length) sourceSources.push(UNKNOWN_SOURCE)
+      for (let i = 0; i < source.embeddings.length; i++) {
+        embeddings.push(source.embeddings[i])
+        sources.push(sourceSources[i] ?? UNKNOWN_SOURCE)
+      }
+      outcome.mergedFrom.push(source.name)
+      absorbed.add(source)
     }
-    outcome.mergedFrom.push(name)
   }
 
   if (outcome.mergedFrom.length === 0) return outcome
@@ -569,8 +580,7 @@ export function mergeProfilesInStore(
   target.sources = keep.map(i => sources[i])
   outcome.samplesAfter = target.embeddings.length
 
-  const removed = new Set(outcome.mergedFrom)
-  store.profiles = store.profiles.filter(p => !removed.has(p.name))
+  store.profiles = store.profiles.filter(p => !absorbed.has(p))
   return outcome
 }
 
@@ -583,7 +593,7 @@ export function deleteProfileFromStore(
   let removedProfiles = 0
   let removedEmbeddings = 0
   store.profiles = store.profiles.filter(profile => {
-    if (profile.name !== name) return true
+    if (!sameSpeakerName(profile.name, name)) return true
     removedProfiles++
     removedEmbeddings += profile.embeddings.length
     return false

package/server/routes/decision-provider.ts

@@ -3,6 +3,7 @@ import { Router } from 'express'
 import { JEV_MODEL, resolveJevKey } from '../lib/jev.js'
 import { resolveSubqKey, subqKeyStatus } from '../lib/subq-key.js'
 import { SUBQ_MODEL } from '../lib/decision-provider.js'
+import { sessionFindAvailable } from '../lib/session-find.js'
 import { decisionSettingsView, DecisionSettingsError, patchDecisionSettings, readDecisionSettings, writeDecisionSettings, type DecisionProvider, type DecisionSettings } from '../lib/decision-settings.js'
 export interface DecisionProviderRouteDeps {
   read: () => DecisionSettings
@@ -15,7 +16,9 @@ export function createDecisionProviderRouter(overrides: Partial<DecisionProvider
   const deps: DecisionProviderRouteDeps = { read: readDecisionSettings, write: writeDecisionSettings, configured: () => ({ jev: !!resolveJevKey(), subq: !!resolveSubqKey() }), env: process.env, keyStatus: () => { const jev = resolveJevKey(); return { jev: { configured:!!jev, source:jev?.source ?? 'none' }, subq:subqKeyStatus() } }, ...overrides }
   const router = Router()
   const view = (settings: DecisionSettings) => ({ ...decisionSettingsView(settings, deps.configured(), deps.env), models: { jev: JEV_MODEL, subq: SUBQ_MODEL }, keyStatus: deps.keyStatus(),
-    capabilities: { choices: ['jev','subq'], workflows: ['session','completion','search'], hotReload: true, fallback: false, subqImages: true, subqKeySource: 'config-or-env' } })
+    capabilities: { choices: ['jev','subq'], workflows: ['session','completion','search'], hotReload: true, fallback: false, subqImages: true, subqKeySource: 'config-or-env',
+    // Present only while POST /api/agent-sessions/find can answer. Absent means no meaning search here, and Control does not ask (never keyed on version).
+    ...(sessionFindAvailable(deps.env) ? { sessionFind: true } : {}) } })
   router.use('/decision-provider', (_req,res,next) => { res.set('Cache-Control','private, no-store'); next() })
   router.get('/decision-provider', (_req,res) => {
     try { res.json(view(deps.read())) } catch { res.status(503).json({ error: { code: 'decision_settings_unavailable', message: 'Decision provider settings could not be read.' } }) }

package/server/routes/jev.ts

@@ -14,6 +14,7 @@ import { CompletionChecker, readRepliesSince } from '../lib/work-completion.js'
 import { isSafeSessionId, type AgentProvider } from '../lib/agent-session-store.js'
 import { listBoard } from '../lib/task-store.js'
 import { sharedWorkSearchJevClient } from '../lib/work-search.js'
+import { sharedSessionFindJevClient } from '../lib/session-find.js'
 import { isSafeDomainName } from '../lib/domains.js'
 
 /** What the route reads from a meeting review (6.57.1): the server's own record, never client text. */
@@ -34,6 +35,8 @@ export interface JevRouteDependencies {
   replies: (provider: AgentProvider, sessionId: string, afterMs: number | null) => Promise<string | null>
   /** 6.65.0: Work search keeps its own client and breaker; a newly saved key clears that breaker too. */
   searchJev: Pick<JevClient, 'resetForNewKey'>
+  /** Session find (Control 0.5.363) keeps its own client and breaker too. */
+  findJev: Pick<JevClient, 'resetForNewKey'>
 }
 
 /** Work identity first: it survives a rename, while a new card's id could equal an old identity's text hash. */
@@ -45,7 +48,7 @@ export function createJevRouter(overrides: Partial<JevRouteDependencies> = {}):
   const jev = overrides.jev ?? sharedJevClient()
   const deps: JevRouteDependencies = { jev, recommender: new SessionRecommender(createDecisionClient('session', jev)), list: listBoard, validate: validateJevKey, save: saveJevKey,
     completion: new CompletionChecker(createDecisionClient('completion', jev)), replies: (provider, sessionId, afterMs) => readRepliesSince(provider, sessionId, afterMs),
-    searchJev: sharedWorkSearchJevClient(), ...overrides }
+    searchJev: sharedWorkSearchJevClient(), findJev: sharedSessionFindJevClient(), ...overrides }
   const router = Router()
   router.use(['/jev-key', '/work-board/session-recommendation', '/work-board/completion-check'], (_req, res, next) => { res.set('Cache-Control', 'private, no-store'); next() })
 
@@ -67,6 +70,7 @@ export function createJevRouter(overrides: Partial<JevRouteDependencies> = {}):
     }
     deps.jev.resetForNewKey()
     deps.searchJev.resetForNewKey()
+    deps.findJev.resetForNewKey()
     return res.json({ ok: true, ...deps.jev.status() })
   })
 

package/server/routes/meeting.ts

@@ -3,6 +3,7 @@ import { readMacSpeakerMachineEvidence } from '../lib/mac-speaker-machine-eviden
 import { dataPath } from '../lib/data-dir.js'
 import { PHONE_CAPTURE_ID, PHONE_SOURCE_TYPE, assertPhoneProvenance, readPhoneRecording, requirePhoneRecording, closePhoneRecording } from '../lib/phone-recording.js'
 import { MAC_CAPTURE_ID, readMacRecording, requireMacRecording, macChunkReceipt, closeMacRecording } from '../lib/mac-recording.js'
+import { bodyName, sameRecordId, sameSpeakerName } from '../lib/speaker-name-nfc.js'
 import { readSpeakerPolicy, writeSpeakerPolicy, isSpeakerMode } from '../lib/meeting-speaker-policy.js'
 // POST /api/meeting/save — finalize an existing transcribe-stream session into
 // the standalone public meeting store. The live transcript and chunk metadata
@@ -261,7 +262,7 @@ function markdownUnreadableReason(operations: { mergedScribeConflict?: string[]
 }
 
 function requestedRecordMatches(requested: unknown, expected: string): boolean {
-  return requested == null || requested === '' || requested === expected
+  return requested == null || requested === '' || sameRecordId(requested, expected)
 }
 
 interface MeetingSessionSource {
@@ -1967,7 +1968,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       res.status(400).json({ error: 'Invalid sessionId', reason: 'invalid_session_id' })
       return
     }
-    const speaker = typeof req.body?.speaker === 'string' ? req.body.speaker.trim() : ''
+    const speaker = bodyName(req.body?.speaker).trim()
     if (!speaker) {
       res.status(400).json({ error: 'speaker is required', reason: 'invalid_label' })
       return
@@ -2000,7 +2001,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     }
 
     // Only rows that ACTUALLY landed, and only those that named this speaker.
-    const rows = appliedCorrections(sessionId).filter(r => r.to === speaker && r.chunks.length > 0)
+    const rows = appliedCorrections(sessionId).filter(r => sameSpeakerName(r.to, speaker) && r.chunks.length > 0)
     if (rows.length === 0) {
       res.status(404).json({ error: `No applied correction named "${speaker}" in this meeting`, reason: 'no_correction' })
       return
@@ -2047,8 +2048,8 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       return
     }
 
-    const from = typeof req.body?.from === 'string' ? req.body.from : ''
-    const to = typeof req.body?.to === 'string' ? req.body.to : ''
+    const from = bodyName(req.body?.from)
+    const to = bodyName(req.body?.to)
     const chunks = Array.isArray(req.body?.chunks)
       ? (req.body.chunks as unknown[]).filter((n): n is number => Number.isInteger(n) && (n as number) >= 0)
       : []
@@ -2401,7 +2402,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       res.status(evidenceRefusal.status).json(evidenceRefusal.body)
       return
     }
-    const label = typeof req.body?.label === 'string' ? req.body.label : ''
+    const label = bodyName(req.body?.label)
     const bad = invalidLabelReason(label)
     if (bad) {
       res.status(400).json({ error: `label: ${bad}`, reason: 'invalid_label' })
@@ -2449,7 +2450,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       const doc = JSON.parse(readFileSync(sidecarPath, 'utf-8')) as Record<string, unknown>
       const rows = Array.isArray(doc.chunks) ? doc.chunks : []
       carried = rows.filter(r => r && typeof r === 'object'
-        && (r as Record<string, unknown>).speaker === label).length
+        && sameSpeakerName((r as Record<string, unknown>).speaker, label)).length
     } catch {
       res.status(500).json({ error: 'Could not read the chunk sidecar', reason: 'sidecar_unreadable' })
       return
@@ -2492,7 +2493,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       res.status(evidenceRefusal.status).json(evidenceRefusal.body)
       return
     }
-    const from = typeof req.body?.from === 'string' ? req.body.from : ''
+    const from = bodyName(req.body?.from)
     const bad = invalidLabelReason(from)
     if (bad) {
       res.status(400).json({ error: `from: ${bad}`, reason: 'invalid_label' })
@@ -2568,7 +2569,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       if (Array.isArray(parsed.chunks)) {
         for (const c of parsed.chunks) {
           const sp = (c as { speaker?: unknown } | null)?.speaker
-          if (typeof sp === 'string' && !existingSpeakers.includes(sp)) existingSpeakers.push(sp)
+          if (typeof sp === 'string' && !existingSpeakers.some(x => sameSpeakerName(x, sp))) existingSpeakers.push(sp)
         }
       }
     } catch { /* the relabel below reports a corrupt sidecar */ }
@@ -2581,7 +2582,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
 
     // What this would remove from the profile, and what it CANNOT reach.
     // readVoiceProfiles returns a ProfileStore, not an array.
-    const profile = readVoiceProfiles().profiles.find(p => p.name === from)
+    const profile = readVoiceProfiles().profiles.find(p => sameSpeakerName(p.name, from))
     const profileSources: Array<string | undefined> = profile
       ? Array.from({ length: profile.embeddings.length }, (_, i) => profile.sources?.[i])
       : []

package/server/routes/session-find.ts

@@ -0,0 +1,73 @@
+/**
+ * POST /api/agent-sessions/find (Control 0.5.363): which of this Mac's agent sessions the person means, by meaning.
+ * Auth comes from the parent /api mount. See lib/session-find.ts for what leaves the Mac, the cost controls and the gates.
+ *
+ * Body `{ query, consentedProvider, stage }`, exactly those keys. `query` is a string; the words are redacted and cut at 200
+ * code points before use. `consentedProvider` is `"jev"`, `"subq"` or `null`: the provider the person agreed to send to.
+ * `stage` is `"first"` (the newest 254 sessions) or `"full"` (the next 254 too, unless the first already settles it).
+ *
+ * A search that cannot run answers HTTP 200 with `available: false`, a `reason` and a `message`, so Control keeps its word
+ * search and says one line about why. A malformed body is 400. A walk that fails (the session store, the keyed-sessions file) is
+ * also a 200 with `reason: failed`, so Control keeps its word search. 503 `session_find_unavailable` is left for an unexpected
+ * error outside the finder's own handling: try later.
+ * An older server answers 404, which Control reads as "no meaning search here".
+ *
+ * A closed connection stops the walk and any stage that has not started. A model request already sent is not aborted (it is
+ * billed either way). The query and the sessions never reach a log line.
+ */
+import { Router, type Response } from 'express'
+import { isAbortError } from '../lib/session-find-collect.js'
+import { SESSION_FIND_LIMITS, SessionFinder, unavailableAnswer, type SessionFindAnswer } from '../lib/session-find.js'
+
+export interface SessionFindRouteDependencies {
+  finder: Pick<SessionFinder, 'find'>
+  now: () => number
+}
+
+const BODY_KEYS = new Set(['query', 'consentedProvider', 'stage'])
+/** One log line per degrade reason per 10 minutes: Control falls back quietly, so the server says why. Fixed words only, never the query or a session. */
+export const SESSION_FIND_LOG_EVERY_MS = 10 * 60_000
+
+export function createSessionFindRouter(overrides: Partial<SessionFindRouteDependencies> = {}): Router {
+  let finder: Pick<SessionFinder, 'find'> | null = overrides.finder ?? null
+  const now = overrides.now ?? Date.now
+  const lastLogged = new Map<string, number>()
+  const logDegrade = (reason: string) => {
+    const at = now()
+    const last = lastLogged.get(reason)
+    if (last !== undefined && at - last < SESSION_FIND_LOG_EVERY_MS) return
+    lastLogged.set(reason, at)
+    console.warn(`[session-find] unavailable: ${reason}`)
+  }
+  const router = Router()
+  router.use('/agent-sessions/find', (_req, res, next) => { res.set('Cache-Control', 'private, no-store'); next() })
+
+  router.post('/agent-sessions/find', async (req, res: Response) => {
+    const body = req.body
+    const bad = () => res.status(400).json({ error: { code: 'invalid_find_request',
+      message: 'Send a query, the provider you consented to (jev, subq or null) and a stage of first or full.' } })
+    if (!body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).some(key => !BODY_KEYS.has(key))) return bad()
+    if (typeof body.query !== 'string' || body.query.length > SESSION_FIND_LIMITS.queryRawMax) return bad()
+    if (body.consentedProvider !== null && body.consentedProvider !== undefined && body.consentedProvider !== 'jev' && body.consentedProvider !== 'subq') return bad()
+    if (body.stage !== 'first' && body.stage !== 'full') return bad()
+
+    const controller = new AbortController()
+    // `close` also fires when a response has finished normally; only a connection that closed before the answer counts.
+    res.on('close', () => { if (!res.writableEnded) controller.abort() })
+    let answer: SessionFindAnswer
+    try {
+      finder ??= new SessionFinder()
+      answer = await finder.find({ query: body.query, consentedProvider: body.consentedProvider ?? null, stage: body.stage }, controller.signal)
+    } catch (error) {
+      if (isAbortError(error) || controller.signal.aborted) return
+      console.error('[session-find] search failed')
+      return res.status(503).json({ error: { code: 'session_find_unavailable', message: 'Meaning search could not read your sessions. Try again shortly.' } })
+    }
+    if (controller.signal.aborted) return
+    if (!answer.available && answer.reason) logDegrade(answer.reason)
+    return res.json(answer)
+  })
+  return router
+}
+
+export { unavailableAnswer }