@gotcos/glasses-server 6.94.1 → 6.94.3

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

@@ -13,6 +13,7 @@
 import { lstat, readFile, readdir, realpath } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
 import { setImmediate as yieldToEventLoop } from 'node:timers/promises'
+import { readMacSpeakerMachineEvidence } from './mac-speaker-machine-evidence.js'
 import { dataPath } from './data-dir.js'
 import { confirmedLabels, confirmedChunks } from './meeting-corrections.js'
 import { resolveCosOperationsDir, resolveMeetingLibrary } from './cos-operations-meetings.js'
@@ -25,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$/
@@ -294,11 +296,14 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
         storedTitle,
       )
 
+      const machineEvidence = readMacSpeakerMachineEvidence(record)
       const review = reviewMeetingSpeakers(chunks as ReviewChunk[], {
         owner,
         phrasesPerVoice: 1,
         confirmed: confirmedLabels(sessionId),
-      confirmedChunks: confirmedChunks(sessionId),
+        confirmedChunks: confirmedChunks(sessionId),
+        machineQualifiedPositions: machineEvidence.positions,
+        machineEvidenceStatus: machineEvidence.status,
         durationMs: typeof record.durationMs === 'number' ? record.durationMs : undefined,
         batchSegments: Array.isArray(record.batchSegments)
           ? record.batchSegments as SpeakerWordSegment[]
@@ -359,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() })
   })