@gotcos/glasses-server 6.45.5 → 6.46.0

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

@@ -1,57 +1,11 @@
-// Carry a speaker rename out to the meetings that already have the old name baked in.
-//
-// ---------------------------------------------------------------------------
-// WHY THIS EXISTS
-// ---------------------------------------------------------------------------
-// `merge-profiles` folds two voice profiles together and relabels the calibration log.
-// That is ALL it has ever touched -- verified in the handler, not assumed. Meetings keep
-// the speaker strings that were written at transcription time, and the review panel
-// re-reads those strings from disk on every request, so a merge is invisible to every
-// meeting that already exists.
-//
-// Measured on this machine when the Luke H / Luke Henry merge ran: the split had been
-// live since 2026-03-25, and every affected meeting would have rendered two Lukes
-// forever. The merge fixed identification going FORWARD and nothing behind it.
-//
-// ---------------------------------------------------------------------------
-// WHY IT DOES NOT REUSE THE PER-MEETING RELABEL ROUTE
-// ---------------------------------------------------------------------------
-// `POST /api/meeting/:id/relabel` also calls `enrolNamedVoice`, which folds that
-// meeting's audio into the target profile. That is correct when a human names a voice:
-// the embedding genuinely should learn it.
-//
-// It is WRONG for a merge fan-out, and not by a little. The merge has already absorbed
-// those embeddings; re-enrolling the same audio across every affected meeting would
-// double-count it and drag the centroid further. That matters here specifically because
-// the Luke merge already moved a neighbouring speaker's similarity from 0.818 to 0.842,
-// and 0.842 is close enough to the identification threshold to start producing wrong
-// attributions.
-//
-// So this is a PURE STRING REWRITE. Same two primitives the relabel route uses --
-// `relabelSidecarJson` and `relabelMeetingMarkdown` -- minus the enrolment.
-//
-// ---------------------------------------------------------------------------
-// SAFETY
-// ---------------------------------------------------------------------------
-// This rewrites production meeting records, so:
-//   - DRY RUN IS THE DEFAULT. Writing requires asking for it.
-//   - Atomic writes only, via the same helper the rest of the server uses.
-//   - iCloud conflict copies are skipped by construction. Desktop-and-Documents sync
-//     creates `2026-08 2/` and `meeting 2.md`; rewriting one of those would edit a file
-//     nothing reads while leaving the real one stale. Month directories must match
-//     `YYYY-MM` exactly.
-//   - Every skip is REPORTED rather than silently dropped, because a fan-out that
-//     quietly missed files is worse than one that refused.
+// Merge fan-out carries exact speaker names through the durable correction core.
+// Enrollment stays off: the profile merge already absorbed those voice samples.
+// Missing copies, unavailable raw maps and legacy markdown-only records are
+// explicit skips. A merge must never silently fall back to a chunks-only write.
 
-import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { readFileSync, readdirSync, lstatSync, realpathSync } from 'node:fs'
 import { join } from 'node:path'
-import { atomicWriteFileSync } from './atomic-fs.js'
-import {
-  relabelSidecarJson,
-  relabelMeetingMarkdown,
-  type SidecarRelabelResult,
-  type MarkdownRelabelResult,
-} from './meeting-relabel.js'
+import { renameMeetingSpeaker } from './held-naming-batches.js'
 
 /** A month directory, and nothing that merely looks like one. */
 const CANONICAL_MONTH = /^\d{4}-\d{2}$/
@@ -110,7 +64,7 @@ function safeReaddir(dir: string): string[] {
 
 function isDir(path: string): boolean {
   try {
-    return statSync(path).isDirectory()
+    return lstatSync(path).isDirectory() && !lstatSync(path).isSymbolicLink()
   } catch {
     return false
   }
@@ -156,156 +110,116 @@ function monthsIn(meetingsDir: string): string[] {
 }
 
 /**
- * Rewrite `from` to `to` across every meeting sidecar and transcript.
- *
- * Returns what changed, or what WOULD change when `apply` is not set. Never throws for
- * one bad file: an unreadable or unparsable record is reported as a skip and the sweep
- * continues, because stopping halfway would leave the library in a half-renamed state
- * that is worse than either end.
+ * Preserve the existing report/error shape while executing each session through
+ * the shared two-copy, ledgered correction core. Dry-run remains the default.
+ * Sequential awaits are intentional: all correction entrypoints share one lock.
  */
-export function fanOutSpeakerRename(
+export async function fanOutSpeakerRename(
   operationsDir: string,
   from: string,
   to: string,
   options: FanOutOptions = {},
-): SpeakerRenameFanOut {
+): Promise<SpeakerRenameFanOut> {
   const apply = options.apply === true
   const result: SpeakerRenameFanOut = {
     from, to, dryRun: !apply, sidecars: [], markdown: [], scanned: 0, skipped: [],
   }
   if (!from.trim() || !to.trim() || from === to) return result
-
+  const entries = new Map<string, string>()
+  const canonicalSources = new Map<string, string>()
   for (const monthDir of meetingMonthDirs(operationsDir, options.includeArchive === true)) {
-    for (const name of safeReaddir(monthDir)) {
-      // A conflict copy of a FILE, same reasoning as the month directory.
-      //
-      // The marker sits before the EXTENSION CHAIN, not just before the last dot.
-      // iCloud writes `sync.g2-chunks 2.json` for a sidecar and `sync 2.md` for a
-      // transcript, and a sidecar belonging to an already-conflicted meeting comes
-      // out as `sync 2.g2-chunks.json`. A first cut anchored the digit to the final
-      // extension and let that third form straight through -- it would have rewritten
-      // a duplicate nobody reads while the real file kept the old name.
+    for (const name of safeReaddir(monthDir).sort()) {
+      const path = join(monthDir, name)
       if (/ \d+(\.[A-Za-z0-9-]+)*\.(md|json)$/.test(name)) {
-        result.skipped.push({ path: join(monthDir, name), reason: 'icloud conflict copy' })
+        result.skipped.push({ path, reason: 'icloud conflict copy' })
         continue
       }
-      const isSidecar = name.endsWith(SIDECAR_SUFFIX)
-      const isMarkdown = name.endsWith('.md')
-      if (!isSidecar && !isMarkdown) continue
-
-      const path = join(monthDir, name)
-      result.scanned += 1
-      let raw: string
+      if (!name.endsWith(SIDECAR_SUFFIX) && !name.endsWith('.md')) continue
+      result.scanned++
       try {
-        raw = readFileSync(path, 'utf-8')
+        const stat = lstatSync(path)
+        if (!stat.isFile() || stat.isSymbolicLink()) throw new Error('not a canonical regular file')
+        const raw = readFileSync(path, 'utf8')
+        entries.set(path, raw)
+        canonicalSources.set(realpathSync(path), raw)
       } catch (error) {
-        result.skipped.push({ path, reason: `unreadable: ${(error as Error).message}` })
-        continue
+        result.skipped.push({ path, reason: `unreadable: ${errorText(error)}` })
       }
-      // Cheap pre-filter, and deliberately loose: `from` is a SUBSTRING of the name it
-      // is being merged into ("Luke H" inside "Luke Henry"), so a file holding only the
-      // new name still passes here. The primitives below are exact and reject it, which
-      // is why a plain no-match must not be reported as a skip -- see below.
-      if (!raw.includes(from)) continue
-
-      // TYPED, NOT DUCK-TYPED. A first cut read `changed` as a number and the field is
-      // an ARRAY of chunk indices, so every sidecar would have counted zero labels and
-      // been skipped -- a fan-out that reported success while rewriting nothing.
-      let next: string
-      let labels: number
-      let note: string | undefined
-
-      if (isSidecar) {
-        const outcome = relabelSidecarJson(raw, from, to)
-        if (!outcome.ok) {
-          if (!isNoMatch(outcome.error)) result.skipped.push({ path, reason: outcome.error })
-          continue
-        }
-        const value: SidecarRelabelResult = outcome.value
-        next = value.json
-        labels = value.changed.length
-        // The primitive's own invariant, carried rather than assumed: a partial relabel
-        // means chunks still hold the old name, and the markdown must NOT then be
-        // rewritten by label. Reported so the operator sees it.
-        if (value.remainingWithFrom > 0) {
-          note = `${value.remainingWithFrom} chunk(s) still carry "${from}"`
-        }
-      } else {
-        // A SECOND TRANSCRIPT FORMAT EXISTS AND THE PRIMITIVE DOES NOT HANDLE IT.
-        //
-        // `relabelMeetingMarkdown` rewrites `[Name]:` turn labels, anchored to line
-        // start. Measured across the real library for the Luke rename: 17 files and 97
-        // labels in that form -- and 20 files, 77 labels in a `**Name**` form it does
-        // not match, 13 of those files in LIVE quilt meetings, not the archive.
-        //
-        // That is a 39% silent miss. Detected and REPORTED rather than fixed here: the
-        // primitive is shared with the live per-meeting relabel route, and widening its
-        // matcher changes behaviour for a path nobody asked me to touch. The operator
-        // gets a number instead of a surprise.
-        const unhandled = countBoldLabels(raw, from)
-        const outcome = relabelMeetingMarkdown(raw, from, to)
-        if (!outcome.ok) {
-          if (!isNoMatch(outcome.error)) result.skipped.push({ path, reason: outcome.error })
-          continue
-        }
-        const value: MarkdownRelabelResult = outcome.value
-        next = value.markdown
-        labels = value.attendees + value.transcript
-        // Narrative prose is deliberately untouched by the primitive. Surfaced here so a
-        // stale summary is something the operator knows about rather than discovers.
-        const notes: string[] = []
-        if (unhandled > 0) notes.push(`${unhandled} label(s) in an unhandled **${from}** format`)
-        if (value.proseStale) {
-          notes.push(`prose still mentions "${from}"${value.proseHits.length ? `: ${value.proseHits.slice(0, 3).join(', ')}` : ''}`)
-        }
-        if (notes.length > 0) note = notes.join('; ')
-
-        // A file whose ONLY labels are in the unhandled form changes nothing, and would
-        // otherwise fall out of the report entirely -- the exact silent miss this guard
-        // exists to prevent. Recorded as a skip so it is visible.
-        if (labels === 0 && unhandled > 0) {
-          result.skipped.push({ path, reason: `${unhandled} label(s) in an unhandled **${from}** format` })
-          continue
-        }
+    }
+  }
+  const sessions = new Set<string>()
+  const coveredMarkdown = new Set<string>()
+  for (const [path, raw] of entries) {
+    if (!path.endsWith(SIDECAR_SUFFIX)) continue
+    const markdownPath = path.slice(0, -SIDECAR_SUFFIX.length) + '.md'
+    coveredMarkdown.add(markdownPath)
+    if (!raw.includes(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')
+      if (!carriesSpeaker(doc, from)) continue
+      if (typeof doc.sessionId !== 'string' || !doc.sessionId.trim()) {
+        throw new Error('missing session identity; cannot verify both meeting copies')
       }
-
-      if (labels === 0) continue
-      if (apply) {
-        try {
-          atomicWriteFileSync(path, next)
-        } catch (error) {
-          result.skipped.push({ path, reason: `write failed: ${(error as Error).message}` })
-          continue
+      if (sessions.has(doc.sessionId)) {
+        result.skipped.push({ path, reason: 'duplicate session sidecar; session already examined' })
+        continue
+      }
+      sessions.add(doc.sessionId)
+      const outcome = await renameMeetingSpeaker(doc.sessionId, from, to, {
+        apply, operationsDir: realpathSync(operationsDir), expectedSidecarPath: path,
+      })
+      if (outcome.error) throw new Error(outcome.error)
+      for (const copy of outcome.copies) {
+        const note = copy.unresolvedTurns > 0
+          ? `${copy.unresolvedTurns} transcript turn(s) could not be aligned; labels newer than graph`
+          : undefined
+        if (copy.labels > 0) result.sidecars.push({ path: copy.sidecarPath, labels: copy.labels, note })
+        if (copy.transcript + copy.attendees > 0) {
+          const prose = canonicalSources.get(copy.meetingPath) ?? entries.get(copy.meetingPath)
+          const stale = prose && proseMentions(prose, from) ? `prose still mentions "${from}"` : undefined
+          result.markdown.push({ path: copy.meetingPath, labels: copy.transcript + copy.attendees,
+            note: [note, stale].filter(Boolean).join('; ') || undefined })
         }
+        coveredMarkdown.add(copy.meetingPath)
       }
-      ;(isSidecar ? result.sidecars : result.markdown).push({ path, labels, note })
+    } catch (error) {
+      result.skipped.push({ path, reason: `${apply ? 'write failed' : 'preview refused'}: ${errorText(error)}` })
     }
   }
+  // 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 (hasNamedLabel(raw, from)) result.skipped.push({
+      path, reason: 'no G2 session sidecar; transcript labels cannot be safely aligned',
+    })
+  }
   return result
 }
 
-/**
- * Is this refusal simply "the name is not in here", rather than a problem?
- *
- * SKIPS ARE FOR THINGS A HUMAN SHOULD LOOK AT. The loose pre-filter above lets through
- * every file holding the NEW name, because the old one is a substring of it -- measured
- * on the real library, that padded the skip list with 15 files that were never affected.
- * A report where most entries are non-issues is one nobody reads, and it hides the two
- * that matter.
- */
-function isNoMatch(error: string): boolean {
-  return /no chunk carries|not found|does not appear|no .* labelled/i.test(error)
+function errorText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
 }
 
-/**
- * Speaker labels in the `**Name**` transcript form, which the primitive does not rewrite.
- *
- * Counted so the report can say how much a rename LEAVES BEHIND. Anchored to line start
- * for the same reason the primitive anchors its own matcher: a bolded name inside spoken
- * text is a quote, not a label.
- */
-export function countBoldLabels(markdown: string, name: string): number {
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  return (markdown.match(new RegExp(`^\\*\\*${escaped}\\*\\*`, 'gm')) ?? []).length
+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))
+    || (Array.isArray(doc.batchSegments) && doc.batchSegments.some((segment: any) =>
+      Array.isArray(segment?.speakerWords) && segment.speakerWords.some((word: any) => word?.speaker === name)))
+}
+
+function escapedName(name: string): string { return name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') }
+function hasNamedLabel(markdown: string, name: string): boolean {
+  const escaped = escapedName(name)
+  return new RegExp(`^(?:\\[${escaped}\\]:|\\*\\*${escaped}(?::\\*\\*|\\*\\*)|[-*] ${escaped}$)`, 'm').test(markdown)
+}
+function proseMentions(markdown: string, name: string): boolean {
+  const prose = markdown.replace(/^## (?:Attendees|Transcript)[^\n]*\n[\s\S]*?(?=^## |$(?![\s\S]))/gm, '')
+  return new RegExp(`(?<![\\p{L}\\p{N}])${escapedName(name)}(?![\\p{L}\\p{N}])`, 'u').test(prose)
 }
 
+/** Kept for callers that count the older bold speaker-label format. */
+export function countBoldLabels(markdown: string, name: string): number {
+  return (markdown.match(new RegExp(`^\\*\\*${escapedName(name)}\\*\\*`, 'gm')) ?? []).length
+}

package/server/lib/training-audio-save.ts

@@ -0,0 +1,24 @@
+import { readdirSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export const MAX_SAVED_TRAINING_CHUNKS = 30
+const pending = new Map<string, Set<string>>()
+/** Disk is authoritative after training or TTL deletion. Reservations cover the
+ * asynchronous write window so concurrent captures cannot exceed the cap. */
+export async function saveTrainingAudioSample(directory: string, filename: string, audio: Buffer): Promise<boolean> {
+  const files = new Set(readdirSync(directory).filter(f => f.endsWith('.wav')))
+  const reservations = pending.get(directory) ?? new Set<string>()
+  if (files.has(filename) || reservations.has(filename)) return false
+  const count = new Set([...files, ...reservations]).size
+  if (count >= MAX_SAVED_TRAINING_CHUNKS) return false
+  reservations.add(filename)
+  pending.set(directory, reservations)
+  try {
+    await writeFile(join(directory, filename), audio, { mode: 0o600 })
+    return true
+  } finally {
+    reservations.delete(filename)
+    if (!reservations.size) pending.delete(directory)
+  }
+}

package/server/lib/voice-directory.ts

@@ -14,7 +14,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 { dataPath } from './data-dir.js'
-import { confirmedLabels } from './meeting-corrections.js'
+import { confirmedLabels, confirmedChunks } from './meeting-corrections.js'
 import { resolveCosOperationsDir, resolveMeetingLibrary } from './cos-operations-meetings.js'
 import {
   isUnattributed,
@@ -298,6 +298,7 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
         owner,
         phrasesPerVoice: 1,
         confirmed: confirmedLabels(sessionId),
+      confirmedChunks: confirmedChunks(sessionId),
         durationMs: typeof record.durationMs === 'number' ? record.durationMs : undefined,
         batchSegments: Array.isArray(record.batchSegments)
           ? record.batchSegments as SpeakerWordSegment[]

package/server/lib/voice-enrolment-selection.ts

@@ -226,3 +226,28 @@ export function greedyDiversitySelect(embeddings: Float32Array[], maxN: number):
 
   return [...selected].map(i => embeddings[i])
 }
+
+/** A mutually coherent cluster anchored to EVERY explicitly named sample.
+ * Indices refer to [...seedMembers, ...candidates]. A larger unrelated voice
+ * can never win. Inconsistent seeds fail closed; a valid seed with no wider
+ * match remains represented so the caller may still label its exact position.
+ */
+export function coherentClusterContaining(
+  seedMembers: Float32Array[], candidates: Float32Array[], floor = VOICE_COHERENCE_FLOOR,
+): CoherentCluster {
+  if (!seedMembers.length) return { members: [], seed: -1 }
+  const all = [...seedMembers, ...candidates]
+  const valid = (v: Float32Array) => v.length === seedMembers[0].length
+    && v.length > 0 && Array.from(v).every(Number.isFinite) && v.some(n => n !== 0)
+  if (!Number.isFinite(floor) || seedMembers.some(v => !valid(v))) return { members: [], seed: -1 }
+  const sim = pairwiseSimilarityMatrix(all)
+  const members = seedMembers.map((_, i) => i)
+  for (const i of members) for (const j of members) {
+    if (i !== j && !(sim[i][j] >= floor)) return { members: [], seed: -1 }
+  }
+  const eligible = candidates.map((_, i) => i + seedMembers.length)
+    .filter(i => valid(all[i]))
+    .sort((a, b) => Math.min(...members.map(j => sim[b][j])) - Math.min(...members.map(j => sim[a][j])) || a - b)
+  for (const i of eligible) if (members.every(j => sim[i][j] >= floor)) members.push(i)
+  return { members: members.sort((a,b) => a-b), seed: 0 }
+}

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

@@ -15,6 +15,7 @@ import { checkSpeakerName, type SpeakerNameRejection } from './speaker-name.js'
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs'
 import { basename, dirname, join, resolve } from 'node:path'
 import { durableAtomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
+import { EVICTION_ORDER, provenanceTier } from './embedding-eviction.js'
 
 export interface VoiceProfile {
   name: string
@@ -454,7 +455,7 @@ export function profileSimilarity(a: VoiceProfile, b: VoiceProfile): number {
 /** Pick the N most acoustically diverse samples, carrying provenance along.
  *
  *  A merge routinely produces more samples than the per-speaker cap (two
- *  capped profiles make 40 against a cap of 20), and which 20 survive matters:
+ *  capped profiles make 80 against a cap of 40), and which 40 survive matters:
  *  taking the first N would keep one profile's acoustic conditions and discard
  *  the other's, which is the opposite of what merging is for. Greedy
  *  max-min-distance keeps the spread.
@@ -517,7 +518,7 @@ export function mergeProfilesInStore(
   from: string[],
   options: { cap?: number } = {},
 ): MergeOutcome {
-  const cap = options.cap ?? 20
+  const cap = options.cap ?? 40
   const target = store.profiles.find(p => p.name === into)
   const outcome: MergeOutcome = {
     similarity: {},
@@ -552,7 +553,11 @@ export function mergeProfilesInStore(
 
   if (outcome.mergedFrom.length === 0) return outcome
 
-  const keep = selectDiverseIndices(embeddings, cap)
+  // Preserve stronger label provenance. Within one
+  // source tier retain newer evidence, matching weakest-first/oldest eviction.
+  const keep = embeddings.map((_, i) => i).sort((a, b) =>
+    EVICTION_ORDER.indexOf(provenanceTier(sources[b])) - EVICTION_ORDER.indexOf(provenanceTier(sources[a])) || b - a,
+  ).slice(0, cap).sort((a, b) => a - b)
   outcome.droppedToCap = embeddings.length - keep.length
   target.embeddings = keep.map(i => embeddings[i])
   target.sources = keep.map(i => sources[i])

package/server/routes/meeting.ts

@@ -15,7 +15,8 @@ import { sendAudioFile } from '../lib/send-audio.js'
 import { adaptivePlaybackAudio } from '../lib/adaptive-playback-audio.js'
 import { chunkDiagnostics } from '../lib/chunk-embedding-diagnostics.js'
 import { errMsg } from '../lib/utils.js'
-import { confirmedLabels } from '../lib/meeting-corrections.js'
+import { setNamingSessionLiveness } from '../lib/held-naming-batches.js'
+import { confirmedLabels, confirmedChunks } from '../lib/meeting-corrections.js'
 import {
   extAudioChunkPath,
   listExtAudioChunks,
@@ -457,6 +458,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
   const finalizationJobs = deps.finalizationJobs ?? new MeetingFinalizationJobStore()
   const router = Router()
   const savingSessions = new Set<string>()
+  setNamingSessionLiveness(id => sessions.getStartTime(id) !== null || savingSessions.has(id) || activeFinalizationJobs.has(id))
 
   router.get('/meeting/sessions/:sessionId/status', (req, res) => {
     const sessionId = String(req.params.sessionId ?? '')
@@ -773,6 +775,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       // floor re-demotes a confirmed name on every reload, and the reviewer
       // confirms the same voice forever.
       confirmed: confirmedLabels(sessionId),
+      confirmedChunks: confirmedChunks(sessionId),
       phrasesPerVoice: Math.max(1, Math.min(6, Number(req.query.phrases) || 3)),
       // The sidecar's own durationMs is the meeting's true end. Deriving it from
       // max(elapsed) uses the START of the last chunk, which made the final
@@ -870,6 +873,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     const review = reviewMeetingSpeakers(attachRawChunkIndices(chunks, sidecar.chunkEntries), {
       owner: getOwnerSpeakerLabel(),
       confirmed: confirmedLabels(sessionId),
+      confirmedChunks: confirmedChunks(sessionId),
       // This route renders no phrases; the default of 3 per voice computed and
       // discarded 48 transcript excerpts on a 16-voice meeting.
       phrasesPerVoice: 1,

package/server/routes/transcribe-stream.ts

@@ -39,7 +39,7 @@ import { errMsg } from '../lib/utils.js'
 import { transcribeLocal, applyCorrections, type WhisperWord } from '../lib/whisper-local.js'
 import { enhanceAudio } from '../lib/audio-enhance.js'
 import { trimSilence, isSileroAvailable } from '../lib/vad-silero.js'
-import { identifySpeaker, isEmbeddingAvailable, autoEnroll, getEmbeddingCount, AUTO_ENROLL_CANDIDATE_SIMILARITY } from '../lib/speaker-embeddings.js'
+import { identifySpeaker, isEmbeddingAvailable, autoEnroll, AUTO_ENROLL_CANDIDATE_SIMILARITY } from '../lib/speaker-embeddings.js'
 import {
   assertOpenAIWhisperBudget,
   recordOpenAIWhisperUsage,
@@ -78,6 +78,7 @@ import {
   sweepOrphanedSessionAudio,
 } from '../lib/unsaved-audio-quarantine.js'
 import { durableAtomicWriteFileSync } from '../lib/atomic-fs.js'
+import { saveTrainingAudioSample } from '../lib/training-audio-save.js'
 import {
   LOCAL_FIRST_MEETING_IDLE_RETENTION_MS,
   compressIndexRanges,
@@ -157,7 +158,6 @@ function meetingTurboPreviewEnabled(): boolean {
 // Audio persistence: save G2-mic chunks for speakers who need more training data
 const AUDIO_SAVE_DIR = dataPath('training-audio')
 ensurePrivateDirectory(AUDIO_SAVE_DIR)
-const MAX_SAVED_CHUNKS_PER_SPEAKER = 30  // ~5 min of audio per speaker, cleaned after training
 // Age bound. The count cap above is NOT a retention policy: a speaker who never
 // gets trained keeps 30 WAVs of their voice indefinitely, and the only cleanup
 // path was a manual /voice/train-g2 call. ext-audio has had a 72h sweep since it
@@ -218,25 +218,6 @@ function hasFreshPreservedAudioMarker(dirPath: string): boolean {
   }
 }
 
-// In-memory training audio counts — lazy-initialized from disk on first access per speaker
-const trainingAudioCounts = new Map<string, number>()
-function getTrainingCount(speakerDir: string): number {
-  let count = trainingAudioCounts.get(speakerDir)
-  if (count === undefined) {
-    try {
-      if (existsSync(speakerDir)) {
-        count = readdirSync(speakerDir).filter((f: string) => f.endsWith('.wav')).length
-      } else {
-        count = 0
-      }
-    } catch {
-      count = 0
-    }
-    trainingAudioCounts.set(speakerDir, count)
-  }
-  return count
-}
-
 function sha256Hex(buffer: Buffer): string {
   return createHash('sha256').update(buffer).digest('hex')
 }
@@ -1907,26 +1888,17 @@ function identifyChunkSpeaker(audioBuffer: Buffer, sessionId: string, chunkIndex
   }
 
   if (speaker !== 'Ext' && embeddingResult.similarity > 0.50) {
-    const embCount = getEmbeddingCount(speaker)
-    if (embCount < 20) {
-      try {
-        const speakerDir = resolve(AUDIO_SAVE_DIR, speaker.replace(/\s+/g, '_'))
-        ensurePrivateDirectory(speakerDir)
-        const existing = getTrainingCount(speakerDir)
-        if (existing < MAX_SAVED_CHUNKS_PER_SPEAKER) {
-          const filename = `${sessionId}_chunk${chunkIndex}_sim${embeddingResult.similarity.toFixed(2)}.wav`
-          const savePath = resolve(speakerDir, filename)
-          writeFile(savePath, audioBuffer, { mode: 0o600 }).catch(err =>
-            console.warn(`[training-audio] Async save failed for ${speaker}: ${err.message}`)
-          )
-          trainingAudioCounts.set(speakerDir, existing + 1)
-          console.log(`[training-audio] Saved ${speaker} chunk (sim=${embeddingResult.similarity.toFixed(2)}, ${audioBuffer.length}b, total=${existing + 1})`)
-        }
-      } catch (audioSaveErr: unknown) {
-        console.warn(`[training-audio] Save failed for ${speaker}: ${errMsg(audioSaveErr)}`)
-      }
-    } else if (chunkIndex % 20 === 0) {
-      console.log(`[training-audio] ${speaker} at ${embCount} embeddings (>= 15), skipping save`)
+    // Audio has its own count and TTL. A full profile still needs examples
+    // from new meetings; deleting/expiring old audio immediately frees a slot.
+    try {
+      const speakerDir = resolve(AUDIO_SAVE_DIR, speaker.replace(/\s+/g, '_'))
+      ensurePrivateDirectory(speakerDir)
+      const filename = `${sessionId}_chunk${chunkIndex}_sim${embeddingResult.similarity.toFixed(2)}.wav`
+      saveTrainingAudioSample(speakerDir, filename, audioBuffer).then(saved => {
+        if (saved) console.log(`[training-audio] Saved ${speaker} chunk (sim=${embeddingResult.similarity.toFixed(2)}, ${audioBuffer.length}b)`)
+      }).catch(err => console.warn(`[training-audio] Async save failed for ${speaker}: ${err.message}`))
+    } catch (audioSaveErr: unknown) {
+      console.warn(`[training-audio] Save failed for ${speaker}: ${errMsg(audioSaveErr)}`)
     }
   }