@gotcos/glasses-server 6.45.5 → 6.46.0

package/server/lib/held-voice-groups.ts

@@ -49,11 +49,12 @@ import { dataPath } from './data-dir.js'
 import { extAudioChunkPath, listExtAudioChunks } from './meeting-audio-archive.js'
 import { EXPECTED_EMBEDDING_DIM, decodeEmbedding, encodeEmbedding, readChunkEmbeddings } from './chunk-embedding-store.js'
 import {
-  AUTO_ENROLL_THRESHOLD, enrollEmbedding, extractEmbedding, isEmbeddingAvailable, rawCosineSimilarity, readVoiceProfiles,
+  AUTO_ENROLL_THRESHOLD, MAX_EMBEDDINGS_PER_SPEAKER, enrollEmbedding, extractEmbedding, isEmbeddingAvailable, rawCosineSimilarity, readVoiceProfiles,
   type VoiceProfile,
 } from './speaker-embeddings.js'
-import { vouchesForIdentity } from './embedding-eviction.js'
+import { chooseEviction, vouchesForIdentity } from './embedding-eviction.js'
 import { getOwnerSpeakerLabel } from './profile.js'
+import { alignedSources, appendEmbedding, dropEmbeddingAt, profileSimilarity } from './voice-profile-store.js'
 import {
   MAX_ENROL_PER_CORRECTION,
   VOICE_COHERENCE_FLOOR,
@@ -112,6 +113,7 @@ export const HELD_GROUP_SOURCE = 'ext-group'
 export interface HeldSampleRef {
   sessionId: string
   chunkIndex: number
+  suggestion?: HeldGroupSuggestion | null
 }
 
 export interface HeldSample extends HeldSampleRef {
@@ -131,6 +133,10 @@ export interface HeldGroupSuggestion {
   of: number
   /** The provenance of the strongest agreeing sample that may vouch. */
   anchor: string
+  runnerUpSimilarity?: number
+  margin?: number
+  ownerSimilarity?: number
+  ownerCaution?: boolean
 }
 
 export interface HeldVoiceGroup {
@@ -365,6 +371,9 @@ export function foldDuplicates(sim: number[][], count: number): { reps: number[]
   return { reps: [...copies.keys()], copies }
 }
 
+export const HELD_SUGGESTION_MIN_MARGIN = 0.05
+export const HELD_NEAR_PROFILE_SIMILARITY = 0.95
+
 export interface SuggestOptions {
   /** The wearer's own label. Never offered: one click would write a stranger
    *  into the profile that drives owner detection. */
@@ -386,15 +395,22 @@ export interface SuggestOptions {
 export function suggestProfile(embedding: Float32Array, profiles: VoiceProfile[], opts: SuggestOptions = {}): HeldGroupSuggestion | null {
   type Candidate = { name: string; score: number; tier: HeldSuggestionTier; agreeing: number; of: number; anchor: string | null }
   let best: Candidate | null = null
+  const candidates: Candidate[] = []
+  let ownerScore = 0
   for (const profile of profiles) {
-    if (opts.ownerLabel && profile.name === opts.ownerLabel) continue
     const rows: Array<{ sim: number; source: string }> = []
     profile.embeddings.forEach((candidate, i) => {
-      if (candidate.length !== embedding.length) return
+      if (candidate.length !== embedding.length || !candidate.every(Number.isFinite)) return
       rows.push({ sim: rawCosineSimilarity(embedding, new Float32Array(candidate)), source: profile.sources?.[i] ?? 'unknown' })
     })
     if (rows.length === 0) continue
     rows.sort((a, b) => b.sim - a.sim)
+    // Caution is proximity evidence, not permission to suggest/enrol the owner.
+    // One very close owner sample warrants listening even without two anchors.
+    if (opts.ownerLabel && profile.name.normalize('NFKC').toLowerCase() === opts.ownerLabel.normalize('NFKC').toLowerCase()) {
+      ownerScore = Math.max(ownerScore, rows[0].sim)
+      continue
+    }
     const agreeing = rows.filter(r => r.sim >= HELD_GROUP_SUGGESTION_FLOOR)
     let score: number
     let tier: HeldSuggestionTier
@@ -412,10 +428,26 @@ export function suggestProfile(embedding: Float32Array, profiles: VoiceProfile[]
       name: profile.name, score, tier, agreeing: agreeing.length, of: profile.embeddings.length,
       anchor: anchored ? anchored.source.split(':')[0] : null,
     }
+    candidates.push(candidate)
     if (!best || candidate.score > best.score) best = candidate
   }
   if (!best || best.anchor === null) return null
-  return { name: best.name, similarity: Number(best.score.toFixed(4)), tier: best.tier, agreeing: best.agreeing, of: best.of, anchor: best.anchor }
+  const winner = profiles.find(p => p.name === best!.name)!
+  // Near-duplicate profile pairs represent an existing identity ambiguity, not
+  // independent competing acoustic evidence. Do not let that pair erase the
+  // margin against genuinely different voices. Never merge or rename here.
+  const runnerUp = candidates.filter(c => c.name !== best!.name).filter(c => {
+    const other = profiles.find(p => p.name === c.name)!
+    return profileSimilarity(winner, other) < HELD_NEAR_PROFILE_SIMILARITY
+  }).reduce((score, c) => Math.max(score, c.score), 0)
+  const margin = best.score - runnerUp
+  if (margin < HELD_SUGGESTION_MIN_MARGIN) return null
+  return {
+    name: best.name, similarity: Number(best.score.toFixed(4)), tier: best.tier,
+    agreeing: best.agreeing, of: best.of, anchor: best.anchor,
+    runnerUpSimilarity: Number(runnerUp.toFixed(4)), margin: Number(margin.toFixed(4)),
+    ownerSimilarity: Number(ownerScore.toFixed(4)), ownerCaution: ownerScore >= 0.65 || ownerScore > best.score,
+  }
 }
 
 export interface BuildOptions extends SuggestOptions {
@@ -469,7 +501,12 @@ export function buildHeldVoiceGroups(samples: HeldSample[], profiles: VoiceProfi
     active = active.filter(i => !taken.has(i))
   }
   groups.sort((a, b) => b.sampleCount - a.sampleCount || b.coherence - a.coherence || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-  return { groups, loose: refsOf(active) }
+  const byKey = new Map(samples.map(s => [sampleKey(s), s]))
+  const loose = refsOf(active).map(ref => {
+    const suggestion = suggestProfile(byKey.get(sampleKey(ref))!.embedding, profiles, opts)
+    return suggestion ? { ...ref, suggestion } : ref
+  })
+  return { groups, loose }
 }
 
 // ── Listing ────────────────────────────────────────────────────────────────
@@ -495,6 +532,7 @@ export function heldVoiceGroups(opts: { budgetMs?: number; now?: () => number }
   if (listingMemo && listingMemo.fingerprint === fingerprint && now() - listingMemo.at < HELD_LISTING_MEMO_MS && listingMemo.result.pending === 0) {
     return listingMemo.result
   }
+  const started = performance.now()
   const collected = collectHeldSamples({ budgetMs: opts.budgetMs, now })
   const { groups, loose } = buildHeldVoiceGroups(collected.samples, readVoiceProfiles().profiles, { ownerLabel: getOwnerSpeakerLabel() })
   if (collected.pending.length > 0) scheduleHeldEmbeddingSweep()
@@ -509,6 +547,11 @@ export function heldVoiceGroups(opts: { budgetMs?: number; now?: () => number }
     speakerModel: isEmbeddingAvailable(),
     generatedAt: new Date().toISOString(),
   }
+  console.log(`[held-voice] scored listing: samples=${result.samples} suggestions=${loose.filter(r => r.suggestion).length} ms=${(performance.now() - started).toFixed(1)} floor=${HELD_GROUP_SUGGESTION_FLOOR} support=${HELD_SUGGESTION_MIN_SUPPORT} margin=${HELD_SUGGESTION_MIN_MARGIN}`)
+  for (const ref of loose) if (ref.suggestion) {
+    const p = ref.suggestion
+    console.log(`[held-voice] suggestion: key=${sampleKey(ref)} voice=${JSON.stringify(p.name)} secondBest=${p.similarity} agreeing=${p.agreeing}/${p.of} anchor=${p.anchor} runnerUp=${p.runnerUpSimilarity} margin=${p.margin} ownerScore=${p.ownerSimilarity} ownerCaution=${p.ownerCaution}`)
+  }
   listingMemo = { fingerprint, at: now(), result }
   return result
 }
@@ -657,6 +700,10 @@ export interface EnrollHeldGroupPlan {
 
 export interface EnrollHeldGroupResult extends EnrollHeldGroupPlan {
   dryRun: boolean
+  coreMembers?: HeldSampleRef[]
+  /** Exact selected vectors accepted/refused by the store, not expanded duplicates. */
+  enrolledMembers?: HeldSampleRef[]
+  rejectedMembers?: HeldSampleRef[]
   enrolled: number
   /** Wavs removed: the whole core, selected or not, because all of it is now a known voice. */
   deleted: number
@@ -676,7 +723,7 @@ export interface EnrollHeldGroupResult extends EnrollHeldGroupPlan {
  * written. With the speaker model not loaded nothing can be written, so the
  * request is refused before it touches anything.
  */
-export function enrollHeldGroup(name: string, refs: HeldSampleRef[], opts: { dryRun?: boolean } = {}): EnrollHeldGroupResult {
+export function enrollHeldGroup(name: string, refs: HeldSampleRef[], opts: { dryRun?: boolean; deleteAudio?: boolean } = {}): EnrollHeldGroupResult {
   const dryRun = opts.dryRun === true
   const collected = collectHeldSamples({ only: onlyMap(refs), budgetMs: HELD_ENROLL_DECODE_BUDGET_MS })
   if (collected.pending.length > 0) scheduleHeldEmbeddingSweep()
@@ -732,21 +779,65 @@ export function enrollHeldGroup(name: string, refs: HeldSampleRef[], opts: { dry
   }
   // A dry run writes no profile and deletes no wav. It may still decode and
   // cache vectors for the samples it was asked about, and arm the sweep.
-  if (dryRun) return { ...plan, dryRun: true, enrolled: 0, deleted: 0 }
+  if (dryRun) return { ...plan, coreMembers: core.map(({ sessionId, chunkIndex }) => ({ sessionId, chunkIndex })), dryRun: true, enrolled: 0, deleted: 0 }
   if (!isEmbeddingAvailable()) {
     throw new HeldGroupError(503, 'speaker_model_unavailable', 'The speaker model is not loaded on this Mac, so nothing can be enrolled. Nothing was changed.', { ...plan })
   }
 
   let enrolled = 0
+  const enrolledMembers: HeldSampleRef[] = [], rejectedMembers: HeldSampleRef[] = []
   for (const emb of selected) {
     const sample = bySample.get(emb)
     const source = sample ? `${HELD_GROUP_SOURCE}:${sample.sessionId}` : HELD_GROUP_SOURCE
-    if (enrollEmbedding(name, emb, source, true).success) enrolled++
+    const accepted = enrollEmbedding(name, emb, source, true).success
+    if (accepted) enrolled++
+    if (sample) (accepted ? enrolledMembers : rejectedMembers).push({ sessionId: sample.sessionId, chunkIndex: sample.chunkIndex })
   }
   if (enrolled === 0) {
-    throw new HeldGroupError(409, 'nothing_enrolled', `The profile store refused every sample for ${name}; nothing was deleted.`, { ...plan })
+    throw new HeldGroupError(409, 'nothing_enrolled', `The profile store refused every sample for ${name}; nothing was deleted.`, { ...plan, enrolledMembers, rejectedMembers })
   }
-  const { removed } = discardHeldSamples(core.map(s => ({ sessionId: s.sessionId, chunkIndex: s.chunkIndex })))
+  const coreMembers = core.map(s => ({ sessionId: s.sessionId, chunkIndex: s.chunkIndex }))
+  const { removed } = opts.deleteAudio === false ? { removed: [] } : discardHeldSamples(coreMembers)
   console.log(`[held-voice] enroll "${name}" (${existing ? 'appended' : 'created'}): submitted=${refs.length} resolved=${resolved.length} distinct=${reps.length} coherent=${core.length} selected=${selected.length} enrolled=${enrolled} deleted=${removed.length} leftBehind=${leftBehind.length} notReady=${notReady.length} sessions=[${plan.sessions.join(',')}]`)
-  return { ...plan, dryRun: false, enrolled, deleted: removed.length, profileEmbeddings: existingCount + enrolled }
+  return { ...plan, coreMembers, enrolledMembers, rejectedMembers, dryRun: false, enrolled, deleted: removed.length, profileEmbeddings: existingCount + enrolled }
+}
+
+
+/** Preview the exact evidence enrollment will retain, without touching the store.
+ * Duplicate recordings count once; selection and cap eviction match enrollment.
+ * Wider matching must use this projection, never every submitted held vector. */
+export function projectHeldEnrollment(name: string, refs: HeldSampleRef[]): {
+  plan: EnrollHeldGroupResult; profiles: VoiceProfile[]; selectedMembers: HeldSampleRef[]
+} {
+  const plan = enrollHeldGroup(name, refs, { dryRun: true })
+  const coreRefs = plan.coreMembers ?? []
+  const collected = collectHeldSamples({ only: onlyMap(coreRefs), budgetMs: HELD_ENROLL_DECODE_BUDGET_MS })
+  const byKey = new Map(collected.samples.map(sample => [sampleKey(sample), sample]))
+  const core = coreRefs.map(ref => byKey.get(sampleKey(ref)))
+  if (core.some(sample => !sample)) throw new HeldGroupError(409, 'samples_changed', 'The held samples changed while preparing the preview. Preview again.')
+  const samples = core as HeldSample[]
+  const matrix = pairwiseSimilarityMatrix(samples.map(sample => sample.embedding))
+  const { reps } = foldDuplicates(matrix, samples.length)
+  const representatives = reps.map(i => samples[i])
+  const selected = greedyDiversitySelect(representatives.map(sample => sample.embedding), MAX_ENROL_PER_CORRECTION)
+  const byEmbedding = new Map(representatives.map(sample => [sample.embedding, sample]))
+  // readVoiceProfiles shares embedding arrays with the cache. Clone every row
+  // before simulating append/eviction so a preview cannot alter live evidence.
+  const profiles = readVoiceProfiles().profiles.map(profile => ({
+    ...profile, embeddings: profile.embeddings.map(row => [...row]), sources: [...(profile.sources ?? [])],
+  }))
+  let target = profiles.find(profile => profile.name === name)
+  if (!target) { target = { name, embeddings: [], sources: [] }; profiles.push(target) }
+  const selectedMembers: HeldSampleRef[] = []
+  for (const embedding of selected) {
+    const sample = byEmbedding.get(embedding)!
+    const source = `${HELD_GROUP_SOURCE}:${sample.sessionId}`
+    if (target.embeddings.length >= MAX_EMBEDDINGS_PER_SPEAKER) {
+      const choice = chooseEviction(alignedSources(target), source, MAX_EMBEDDINGS_PER_SPEAKER)
+      dropEmbeddingAt(target, choice?.index ?? 0)
+    }
+    appendEmbedding(target, Array.from(embedding), source)
+    selectedMembers.push({ sessionId: sample.sessionId, chunkIndex: sample.chunkIndex })
+  }
+  return { plan, profiles, selectedMembers }
 }

package/server/lib/meeting-batch-persistence.ts

@@ -28,6 +28,7 @@ export function persistBatchDecisionSidecar(
   if (batchResult.qualityReport) sidecar.batchQualityReport = batchResult.qualityReport
 
   if (batchApplied) {
+    sidecar.lifecycleRevision = Number(sidecar.lifecycleRevision ?? 0) + 1
     sidecar.batchTranscript = batchResult.batchTranscript
     sidecar.batchSegments = batchResult.batchSegments?.map(result => ({
       startChunkIdx: result.segment.startChunkIdx,

package/server/lib/meeting-corrections.ts

@@ -35,7 +35,7 @@ export const CORRECTIONS_DIR = 'meeting-corrections'
  * `intent` goes down before any file is touched; `applied` or `failed` closes it.
  * An unclosed intent is an incomplete correction, not a successful one.
  */
-export type CorrectionPhase = 'intent' | 'applied' | 'failed' | 'confirmed'
+export type CorrectionPhase = 'intent' | 'applied' | 'failed' | 'confirmed' | 'confirmed-chunks' | 'reverted'
 /**
  * A human confirming the identifier was RIGHT about a label the display floor
  * demoted.
@@ -54,7 +54,7 @@ export type CorrectionPhase = 'intent' | 'applied' | 'failed' | 'confirmed'
 export const CONFIRMATION_PHASE = 'confirmed' as const
 
 /** Runtime counterpart of CorrectionPhase. Must stay in step with it. */
-const VALID_PHASES = new Set<string>(['intent', 'applied', 'failed', 'confirmed'])
+const VALID_PHASES = new Set<string>(['intent', 'applied', 'failed', 'confirmed', 'confirmed-chunks', 'reverted'])
 
 /** Narrowing guard, so the reader keeps its type safety with one phase list. */
 function isCorrectionPhase(value: unknown): value is CorrectionPhase {
@@ -91,6 +91,9 @@ export interface CorrectionRow {
    * mistake becomes an unrecoverable one.
    */
   scope: 'meeting'
+  source?: string
+  batchId?: string
+  priorLabels?: Record<string, string>
   surfaces?: CorrectionSurfaces
   /** True when narrative prose still carries the old label. See the header. */
   proseStale?: boolean
@@ -160,6 +163,9 @@ export function readCorrections(sessionId: string): CorrectionReadResult {
         to: o.to,
         chunks: Array.isArray(o.chunks) ? o.chunks.filter((n): n is number => typeof n === 'number') : [],
         scope: 'meeting',
+        source: typeof o.source === 'string' ? o.source : undefined,
+        batchId: typeof o.batchId === 'string' ? o.batchId : undefined,
+        priorLabels: o.priorLabels && typeof o.priorLabels === 'object' ? o.priorLabels as Record<string, string> : undefined,
         surfaces: isSurfaces(o.surfaces) ? o.surfaces : undefined,
         proseStale: typeof o.proseStale === 'boolean' ? o.proseStale : undefined,
         error: typeof o.error === 'string' ? o.error : undefined,
@@ -194,8 +200,10 @@ function isSurfaces(v: unknown): v is CorrectionSurfaces {
  */
 export function confirmedLabels(sessionId: string): Set<string> {
   const confirmed = new Set<string>()
-  for (const row of readCorrections(sessionId).rows) {
-    if (row.phase === 'confirmed') confirmed.add(row.to)
+  const rows = readCorrections(sessionId).rows
+  const revoked = new Set(rows.filter(r => r.phase === 'reverted').map(r => r.batchId ?? r.id))
+  for (const row of rows) {
+    if (row.phase === 'confirmed' && row.chunks.length === 0 && !revoked.has(row.batchId ?? row.id)) confirmed.add(row.to)
   }
   return confirmed
 }
@@ -208,7 +216,9 @@ export function pendingCorrections(sessionId: string): CorrectionRow[] {
 
 /** Only the corrections that actually landed — the ones piece 3 may train on. */
 export function appliedCorrections(sessionId: string): CorrectionRow[] {
-  return readCorrections(sessionId).rows.filter(r => r.phase === 'applied')
+  const rows = readCorrections(sessionId).rows
+  const reverted = new Set(rows.filter(r => r.phase === 'reverted').map(r => r.batchId ?? r.id))
+  return rows.filter(r => r.phase === 'applied' && !reverted.has(r.batchId ?? r.id))
 }
 
 /**
@@ -260,3 +270,31 @@ export function correctionStoreStats(): {
   } catch { /* report what we have */ }
   return { sessions, applied, pending, failed }
 }
+
+/** Chunk-scoped vouching never promotes other positions carrying the same label. */
+export function confirmedChunks(sessionId: string): Map<number, string> {
+  const rows = readCorrections(sessionId).rows
+  const revoked = new Set(rows.filter(r => r.phase === 'reverted').map(r => r.batchId ?? r.id))
+  const out = new Map<number, string>()
+  for (const row of rows) {
+    if (revoked.has(row.batchId ?? row.id)) continue
+    if (row.phase === 'confirmed-chunks' || row.phase === 'confirmed') {
+      for (const position of row.chunks) out.set(position, row.to)
+    }
+  }
+  return out
+}
+
+/** Boot closeout records interrupted intent explicitly; no automatic retry. */
+export function closeInterruptedCorrections(): number {
+  const dir = dataPath(CORRECTIONS_DIR)
+  if (!existsSync(dir)) return 0
+  let count = 0
+  for (const file of readdirSync(dir).filter(n => n.endsWith('.jsonl'))) {
+    const sessionId = file.slice(0, -6)
+    for (const row of pendingCorrections(sessionId)) {
+      if (appendCorrection(sessionId, { ...row, phase: 'failed', at: new Date().toISOString(), error: 'interrupted naming — review to resume or revert' })) count++
+    }
+  }
+  return count
+}

package/server/lib/meeting-speaker-labels.ts

@@ -0,0 +1,192 @@
+/** Shared, position-scoped correction primitive. Transcript words are immutable. */
+import { attachRawChunkIndices, type ReviewChunk } from './meeting-speaker-review.js'
+import { invalidLabelReason } from './meeting-relabel.js'
+
+export type SpeakerPatch = { path: Array<string | number>; before: unknown; after: unknown }
+export type PrefixPatch = { line: number; before: string; after: string }
+export interface LabelEdit {
+  doc: Record<string, any>
+  markdown: string
+  patches: SpeakerPatch[]
+  prefixes: PrefixPatch[]
+  changed: number[]
+  transcript: number
+  attendees: number
+  unresolvedTurns: number
+}
+const prefix = /^(\[([^\]\r\n]+)\]:|\*\*([^*\r\n]+)\*\*(?:[ \t]+_\[[^\]\r\n]*\]_)?:?)([ \t]*)/
+const normalized = (value: string) => value.replace(/\s+/gu, ' ').trim()
+export function strippedTranscript(markdown: string): string {
+  const section = /^## Transcript[^\n]*\n([\s\S]*?)(?=^## |$(?![\s\S]))/m.exec(markdown)
+  return (section?.[1] ?? '').split('\n').map(line => line.replace(prefix, '')).join('\n')
+}
+function setPatch(doc: Record<string, any>, path: Array<string | number>, value: unknown, patches: SpeakerPatch[]) {
+  let obj: any = doc
+  for (const key of path.slice(0, -1)) obj = obj[key]
+  const key = path[path.length - 1]
+  if (obj[key] === value) return
+  patches.push({ path, before: obj[key], after: value })
+  obj[key] = value
+}
+export function patchValue(doc: Record<string, any>, patch: SpeakerPatch, reverse = false): void {
+  let obj: any = doc
+  for (const key of patch.path.slice(0, -1)) {
+    if (obj?.[key] == null) throw new Error('Transcript shape changed; review before undo')
+    obj = obj[key]
+  }
+  const key = patch.path[patch.path.length - 1]
+  if (reverse && JSON.stringify(obj[key]) === JSON.stringify(patch.before)) return
+  if (JSON.stringify(obj[key]) !== JSON.stringify(reverse ? patch.after : patch.before)) throw new Error('A later correction touched this position')
+  const value = reverse ? patch.before : patch.after
+  if (value === undefined) delete obj[key]
+  else obj[key] = value
+}
+
+/** Complete compacted-to-raw mapping; no trusting chunkIndex on compacted rows. */
+export function validatedRawMap(doc: Record<string, any>): number[] {
+  if (!Array.isArray(doc.chunks)) throw new Error('Sidecar has no chunks')
+  const mapped = attachRawChunkIndices(doc.chunks as ReviewChunk[], doc.chunkEntries)
+  if (mapped === doc.chunks) throw new Error('Chunk counts disagree or no raw index map')
+  const raw = mapped.map(c => c.chunkIndex)
+  if (raw.some(i => !Number.isInteger(i) || Number(i) < 0) || new Set(raw).size !== raw.length) throw new Error('Invalid or ambiguous raw index map')
+  // Counts alone are insufficient: a damaged entry ordering can have the right length.
+  const entries = doc.chunkEntries.filter((e: any) => e?.chunk?.text)
+  if (entries.some((e: any, i: number) => e.chunk.text !== doc.chunks[i].text)) throw new Error('Chunk text and raw index map disagree')
+  return raw as number[]
+}
+
+export function relabelSpeakerPositions(input: Record<string, any>, markdown: string, positions: number[], name: string, batchId?: string): LabelEdit {
+  if (invalidLabelReason(name)) throw new Error('Invalid speaker label')
+  const raw = validatedRawMap(input)
+  const wanted = new Set(positions)
+  if (positions.some(i => !Number.isInteger(i) || !input.chunks[i])) throw new Error('Unknown transcript position')
+  const doc = structuredClone(input)
+  const patches: SpeakerPatch[] = []
+  const changed = [...wanted].sort((a,b) => a-b)
+  for (const position of changed) {
+    setPatch(doc, ['chunks', position, 'speaker'], name, patches)
+    if (batchId) setPatch(doc, ['chunks', position, 'speakerCorrectionBatchId'], batchId, patches)
+    const entry = doc.chunkEntries.findIndex((e: any) => e.chunkIndex === raw[position])
+    setPatch(doc, ['chunkEntries', entry, 'chunk', 'speaker'], name, patches)
+    if (batchId) setPatch(doc, ['chunkEntries', entry, 'chunk', 'speakerCorrectionBatchId'], batchId, patches)
+  }
+  // Match capture HQ's exact nearest-chunk rule, raw segment bounds, 3.5s
+  // maximum. Never use compacted positions as raw capture indices (6.27.10).
+  for (const [si, segment] of (doc.batchSegments ?? []).entries()) {
+    for (const [wi, word] of (segment.speakerWords ?? []).entries()) {
+      if (!Number.isFinite(word.start)) continue
+      const absolute = Number(segment.startElapsed ?? 0) + word.start * 1000
+      let nearest = -1, distance = Infinity
+      for (let i = 0; i < raw.length; i++) {
+        if (raw[i] < segment.startChunkIdx || raw[i] > segment.endChunkIdx) continue
+        const d = Math.abs(Number(input.chunks[i].elapsed) - absolute)
+        if (d < distance) { distance = d; nearest = i }
+      }
+      if (distance <= 3500 && wanted.has(nearest)) {
+        setPatch(doc, ['batchSegments', si, 'speakerWords', wi, 'speaker'], name, patches)
+        if (batchId) setPatch(doc, ['batchSegments', si, 'speakerWords', wi, 'speakerCorrectionBatchId'], batchId, patches)
+      }
+      // similarity remains capture-time evidence; it is never refreshed here.
+    }
+  }
+  const speakers = [...new Set(doc.chunks.map((c: any) => c.speaker).filter((s: any) => typeof s === 'string' && s))]
+  doc.speakers = speakers
+  doc.correctionRevision = Number(input.correctionRevision ?? 0) + 1
+  doc.labelsNewerThanGraph = true
+
+  const lines = markdown.split('\n')
+  const prefixes: PrefixPatch[] = []
+  let section = '', transcript = 0, unresolvedTurns = 0, attendees = 0
+  const chunks: string[] = input.chunks.map((c: any) => normalized(String(c.text ?? '')))
+  for (let i = 0; i < lines.length; i++) {
+    if (/^## /.test(lines[i])) section = lines[i].slice(3).trim()
+    if (section !== 'Transcript') continue
+    const match = prefix.exec(lines[i])
+    if (!match) continue
+    let end = i + 1
+    while (end < lines.length && !prefix.test(lines[end]) && !/^## /.test(lines[end])) end++
+    const text = normalized([lines[i].slice(match[0].length), ...lines.slice(i+1,end)].join('\n').replace(/\n?<!-- speaker-labels-newer-than-graph -->\n?/g,''))
+    const runs: number[][] = []
+    for (let a = 0; a < chunks.length; a++) {
+      let joined = ''
+      for (let b = a; b < chunks.length; b++) {
+        joined = normalized(joined + ' ' + chunks[b])
+        if (joined === text) runs.push(Array.from({length:b-a+1},(_,k)=>a+k))
+        if (joined.length >= text.length) break
+      }
+    }
+    if (runs.length === 1 && runs[0].every(j => wanted.has(j))) {
+      const next = match[2] !== undefined ? `[${name}]:${match[4]}` : match[0].replace(`**${match[3]}**`, `**${name}**`)
+      if (next !== match[0]) { prefixes.push({line:i,before:match[0],after:next}); lines[i] = next + lines[i].slice(match[0].length); transcript++ }
+    } else if (runs.length !== 1 || runs[0].some(j => wanted.has(j))) unresolvedTurns++
+  }
+  // Attendees preserve every existing person and never add an unidentified label.
+  const att = lines.findIndex(line => /^## Attendees\s*$/.test(line))
+  if (att >= 0 && !/^(ext|unknown|unidentified|speaker\s*\d+)/i.test(name)) {
+    let end = att+1
+    while (end < lines.length && !/^## /.test(lines[end])) end++
+    if (!lines.slice(att+1,end).some(line => line.trim() === `- ${name}`)) {
+      const first = doc.chunks.findIndex((c: any) => c.speaker === name)
+      let insertion = end
+      for (let line = att + 1; line < end; line++) {
+        const listed = /^- (.+)$/.exec(lines[line])?.[1]
+        const appeared = listed ? doc.chunks.findIndex((c: any) => c.speaker === listed) : -1
+        if (appeared > first) { insertion = line; break }
+      }
+      lines.splice(insertion,0,`- ${name}`,'')
+      for (const p of prefixes) if (p.line >= insertion) p.line += 2
+      attendees = 1
+    }
+  }
+  if (att < 0 && !/^(ext|unknown|unidentified|speaker\s*\d+)/i.test(name) && changed.length > 0) {
+    const transcriptStart = lines.findIndex(line => /^## Transcript\s*$/.test(line))
+    if (transcriptStart >= 0) { lines.splice(transcriptStart,0,'## Attendees','',`- ${name}`,''); attendees = 1 }
+  }
+  let nextMarkdown = lines.join('\n')
+  if (!nextMarkdown.includes('<!-- speaker-labels-newer-than-graph -->')) nextMarkdown += '\n<!-- speaker-labels-newer-than-graph -->\n'
+  // Marker is metadata, outside the stripped-text comparison.
+  const clean = (s: string) => s.replace(/\n?<!-- speaker-labels-newer-than-graph -->\n?/g,'')
+  if (strippedTranscript(clean(markdown)) !== strippedTranscript(clean(nextMarkdown))) throw new Error('Transcript word preservation assertion failed')
+  return {doc,markdown:nextMarkdown,patches,prefixes,changed,transcript,attendees,unresolvedTurns}
+}
+
+/** Restore only this batch's label prefixes, using immutable turn text as the
+ * join key. Attendee insertions and disjoint later corrections do not shift it. */
+export function undoSpeakerMarkdown(before:string,after:string,current:string,currentSpeakers:string[]):string {
+  const turns=(md:string)=>{
+    const lines=md.split('\n'),result:Array<{line:number;label:string;text:string}>=[]
+    let section=''
+    for(let i=0;i<lines.length;i++){
+      if(/^## /.test(lines[i]))section=lines[i].slice(3).trim()
+      if(section!=='Transcript')continue
+      const match=prefix.exec(lines[i]);if(!match)continue
+      let end=i+1
+      while(end<lines.length&&!prefix.test(lines[end])&&!/^## /.test(lines[end]))end++
+      const content=[lines[i].slice(match[0].length),...lines.slice(i+1,end)].join('\n').replace(/\n?<!-- speaker-labels-newer-than-graph -->\n?/g,'')
+      result.push({line:i,label:match[0],text:normalized(content)})
+    }
+    return result
+  }
+  const beforeTurns=turns(before),afterTurns=turns(after),currentTurns=turns(current)
+  if(beforeTurns.length!==afterTurns.length)throw new Error('Receipt transcript shape changed')
+  const lines=current.split('\n')
+  for(let i=0;i<beforeTurns.length;i++){
+    const a=afterTurns[i],b=beforeTurns[i]
+    if(a.label===b.label)continue
+    if(a.text!==b.text)throw new Error('Receipt transcript words changed')
+    const matches=currentTurns.filter(t=>t.text===a.text)
+    if(matches.length!==1)throw new Error('Transcript turn is missing or ambiguous; review before undo')
+    const match=matches[0]
+    if(match.label===b.label)continue // a prior interrupted Undo already restored it
+    if(match.label!==a.label)throw new Error('Later naming touched transcript prefix')
+    lines[match.line]=b.label+lines[match.line].slice(a.label.length)
+  }
+  const attendees=(md:string)=>{
+    const match=/^## Attendees\s*\n([\s\S]*?)(?=^## |$(?![\s\S]))/m.exec(md)
+    return new Set((match?.[1]??'').split('\n').flatMap(line=>/^- (.+)$/.exec(line)?.[1]?[line.slice(2)]:[]))
+  }
+  const priorAttendees=attendees(before),added=[...attendees(after)].filter(name=>!priorAttendees.has(name)&&!currentSpeakers.includes(name))
+  let section=''
+  const out=lines.filter(line=>{if(/^## /.test(line))section=line.slice(3).trim();return !(section==='Attendees'&&added.some(name=>line===`- ${name}`))}).join('\n')
+  return out.includes('<!-- speaker-labels-newer-than-graph -->')?out:out+'\n<!-- speaker-labels-newer-than-graph -->\n'
+}

package/server/lib/meeting-speaker-review.ts

@@ -133,6 +133,9 @@ export interface Phrase {
 export interface VoiceReview {
   label: string
   segments: number
+  /** Exact positions a human vouched for. A partial count does not waive the
+   *  display floor for other positions carrying the same label. */
+  confirmedSegments: number
   /** Voiced milliseconds credited to this voice. See `SpeakingTimeSource` for
    *  how it was measured — the two methods are not comparable. */
   speakingMs: number
@@ -242,15 +245,15 @@ export interface MeetingSpeakerReview {
   /** False when no chunk carries a real speaker — a recovered capture. */
   attributed: boolean
   /**
-   * Segments belonging to voices this review asserts a NAME for.
+   * Segments belonging to asserted voices, plus individually confirmed
+   * positions in a voice whose remaining segments are still candidates.
    *
    * `attributed` is a boolean that only goes false at 100% unidentified, so a
    * meeting where 295 of 299 chunks matched nobody still reports `true` and
    * renders as though it were normally attributed. This is the graded version:
    * measured Ext share across 14 retained sessions ran from 24% to 100%.
    *
-   * Counts SEGMENTS OF ASSERTED VOICES, not chunks carrying a person-shaped
-   * label — see the derivation for why those differ. Denominator is `segments`
+   * A name-shaped label alone earns no credit. Denominator is `segments`
    * (every chunk, including unlabelled ones), so `assertedSegments / segments`
    * is the ratio every client should compute.
    *
@@ -581,6 +584,7 @@ export function reviewMeetingSpeakers(
      * the sidecar already carries it.
      */
     confirmed?: Set<string>
+    confirmedChunks?: Map<number, string>
     /**
      * The sidecar's `batchSegments`, when the HQ pass has run. Their word
      * timings give real voiced time; without them speaking time falls back to
@@ -590,7 +594,11 @@ export function reviewMeetingSpeakers(
   } = {},
 ): MeetingSpeakerReview {
   const owner = options.owner ?? 'Me'
-  const confirmed = options.confirmed ?? new Set<string>()
+  const confirmed = new Set(options.confirmed ?? [])
+  for (const label of new Set(chunks.map(c => c.speaker ?? ''))) {
+    const positions = chunks.flatMap((c, i) => c.speaker === label ? [i] : [])
+    if (positions.length > 0 && positions.every(i => options.confirmedChunks?.get(i) === label)) confirmed.add(label)
+  }
   const limit = options.phrasesPerVoice ?? 3
   const sequence = chunks.map(c => c.speaker ?? '')
   // The caller's durationMs (the sidecar's own) is the meeting's true end.
@@ -637,6 +645,8 @@ export function reviewMeetingSpeakers(
     const sims = own.map(c => c.similarity).filter((s): s is number => typeof s === 'number' && s > 0)
     const runs = speakerRuns(sequence, label)
     const unattributed = isUnattributed(label)
+    const confirmedSegments = unattributed ? 0 : confirmed.has(label) ? own.length
+      : chunks.reduce((n, c, i) => n + Number(c.speaker === label && options.confirmedChunks?.get(i) === label), 0)
 
     const thrashesWith: ThrashPair[] = []
     if (!unattributed) {
@@ -698,6 +708,7 @@ export function reviewMeetingSpeakers(
     return {
       label,
       segments: own.length,
+      confirmedSegments,
       speakingMs: speakingFor(label),
       meanSimilarity: meanSim,
       meanRun: Math.round(mean(runs) * 100) / 100,
@@ -724,7 +735,9 @@ export function reviewMeetingSpeakers(
     // labels would claim three quarters of the meeting was identified above a
     // list of rows reading "Unidentified voice", which is the confusion this
     // number exists to remove.
-    assertedSegments: voices.reduce((n, v) => (v.nameAsserted ? n + v.segments : n), 0),
+    // A scoped vouch adds only its exact positions, without promoting the
+    // candidate row or double-counting an already asserted voice.
+    assertedSegments: voices.reduce((n, v) => n + (v.nameAsserted ? v.segments : v.confirmedSegments), 0),
     speakingTimeSource,
     // UNION, not sum. Speakers overlap — crosstalk means two people are each
     // correctly credited for the same wall-clock second, so per-speaker times

package/server/lib/meeting-sync-lock.ts

@@ -0,0 +1,26 @@
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { resolveCosOperationsDir } from './cos-operations-meetings.js'
+
+/** Hold the SAME kernel flock as sync_meetings.py. Child stdin lifetime owns it. */
+export async function acquireMeetingSyncLock(): Promise<{mode:'sync'|'standalone';release:()=>void}> {
+  const operations = resolveCosOperationsDir()
+  if (!operations) return {mode:'standalone',release:()=>{}}
+  const scripts = process.env.COS_SCRIPTS_DIR?.trim() || join(operations,'scripts')
+  const python = join(scripts,'cos_python')
+  if (!existsSync(python)) throw new Error('sync lock holder unavailable: cos_python missing')
+  const code = `import fcntl,sys,time\nf=open(sys.argv[1], 'a+')\nfor i in range(4):\n try:\n  fcntl.flock(f, fcntl.LOCK_EX|fcntl.LOCK_NB)\n  print('LOCKED',flush=True)\n  sys.stdin.read()\n  sys.exit(0)\n except BlockingIOError:\n  time.sleep(0.15*(i+1))\nsys.exit(73)\n`
+  const child = spawn(python,['-c',code,join(scripts,'.sync_meetings.lock')],{stdio:['pipe','pipe','pipe']})
+  return await new Promise((resolve,reject) => {
+    let settled = false, output = '', error = ''
+    const timer = setTimeout(()=>{if(!settled){settled=true;child.kill();reject(new Error('sync running, retry'))}},5000)
+    child.stderr.on('data',d=>{error+=String(d)})
+    child.stdout.on('data',d=>{
+      output += String(d)
+      if (!settled && output.includes('LOCKED')) {settled=true;clearTimeout(timer);resolve({mode:'sync',release:()=>child.stdin.end()})}
+    })
+    child.on('error',err=>{if(!settled){settled=true;clearTimeout(timer);reject(err)}})
+    child.on('exit',()=>{if(!settled){settled=true;clearTimeout(timer);reject(new Error(error.trim() || 'sync running, retry'))}})
+  })
+}

package/server/lib/speaker-embeddings.ts

@@ -101,7 +101,7 @@ const AUTO_ENROLL_CONSENSUS = 2       // Must match N times in same session befo
 // at 20, 40 AND 80 samples per speaker (77 speakers, sherpa SpeakerEmbeddingManager),
 // so the old cap defended nothing — while 61 of 77 profiles sat AT it, meaning
 // every correction cost a sample. 20 extra slots per speaker is ~1.2 MB.
-const MAX_EMBEDDINGS_PER_SPEAKER = 40
+export const MAX_EMBEDDINGS_PER_SPEAKER = 40
 const SAMPLE_RATE = 16000
 
 // Module-level state — sherpa-onnx-node is CJS with no TS types (SDK v0.0.7 interop)