@gotcos/glasses-server 6.94.1 → 6.94.3

package/server/lib/mac-voice-assignment.ts

@@ -77,6 +77,7 @@ import {
   greedyDiversitySelect,
 } from './voice-enrolment-selection.js'
 import { VOICEPRINT_MIN_AUDIO_SEC } from './voiceprint-floor.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 /** A turn shorter than this is not sliced out of a mixed chunk. */
 export const MAC_ASSIGN_MIN_SLICE_SEC = 3.0
@@ -239,7 +240,7 @@ export async function planMacVoiceAssignment(input: MacAssignInput): Promise<Mac
   if (isPlaceholderLabel(to)) return none('unknown_profile')
   if (input.ownerLabel && sameName(to, input.ownerLabel)) return none('owner_profile')
   let profile: { name: string; embeddings: number[][]; sources?: string[] } | undefined
-  try { profile = readVoiceProfiles().profiles.find(p => p.name === to) } catch { return none('store_unavailable') }
+  try { profile = readVoiceProfiles().profiles.find(p => sameSpeakerName(p.name, to)) } catch { return none('store_unavailable') }
   if (!profile) return none('unknown_profile')
   if (!chunkEmbeddingsEnabled()) return none('disabled')
   if (!isEmbeddingAvailable()) return none('store_unavailable')

package/server/lib/meeting-corrections.ts

@@ -27,6 +27,7 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 import { dataPath } from './data-dir.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 export const CORRECTIONS_DIR = 'meeting-corrections'
 
@@ -268,7 +269,7 @@ export function currentLabelFor(sessionId: string, originalLabel: string): strin
   for (let hop = 0; hop < applied.length; hop++) {
     // Latest applied correction FROM the current label wins: a later human
     // decision supersedes an earlier one.
-    const next = [...applied].reverse().find(r => r.from === label)
+    const next = [...applied].reverse().find(r => sameSpeakerName(r.from, label))
     if (!next || seen.has(next.to)) break
     label = next.to
     seen.add(label)

package/server/lib/meeting-relabel-enrolment.ts

@@ -37,6 +37,7 @@
 // every future meeting. A wrong write is permanent and silent. So every step below
 // fails CLOSED: no mapping means no enrolment, never a fall back to positions.
 
+import { sameSpeakerName } from './speaker-name-nfc.js'
 import {
   chunkEmbeddingTtlMs,
   chunkEmbeddingsEnabled,
@@ -163,7 +164,7 @@ function missingReason(sidecar: Record<string, unknown>): EnrolmentSkipReason {
  *  append as a creation. */
 function profileExists(name: string): boolean {
   try {
-    return readVoiceProfiles().profiles.some(p => p.name === name)
+    return readVoiceProfiles().profiles.some(p => sameSpeakerName(p.name, name))
   } catch {
     // Unknowable is not "new". Claiming creation is the lie that matters here.
     return true

package/server/lib/meeting-relabel.ts

@@ -27,6 +27,7 @@
 // somebody else. Reported as `proseStale` instead.
 
 import { isVoiceLabel } from './mac-voice-labels.js'
+import { nameForms, nfc, sameSpeakerName } from './speaker-name-nfc.js'
 
 /** A label that would corrupt the file formats it gets written into. */
 export function invalidLabelReason(label: string): string | null {
@@ -75,6 +76,10 @@ export function relabelSidecarJson(
   to: string,
   chunks: number[] = [],
 ): RelabelOutcome<SidecarRelabelResult> {
+  // Names are NFC here whatever arrived (a decomposed spelling must never be written), and matched NFC on both sides, so a chunk
+  // already stored decomposed still counts as carrying `from`.
+  from = nfc(from)
+  to = nfc(to)
   if (from === to) return { ok: false, error: 'from and to are the same label' }
   for (const [which, label] of [['from', from], ['to', to]] as const) {
     const bad = invalidLabelReason(label)
@@ -100,7 +105,7 @@ export function relabelSidecarJson(
   if (restrict) {
     const mismatched = chunks.filter(i => {
       const row = rows[i]
-      return !row || typeof row !== 'object' || (row as Record<string, unknown>).speaker !== from
+      return !row || typeof row !== 'object' || !sameSpeakerName((row as Record<string, unknown>).speaker, from)
     })
     if (mismatched.length > 0) {
       return { ok: false, error: `chunks do not carry "${from}": ${mismatched.slice(0, 8).join(', ')}` }
@@ -111,11 +116,11 @@ export function relabelSidecarJson(
   let remainingWithFrom = 0
   rows.forEach((row, i) => {
     // The `typeof` half guards the cast below rather than any behaviour — a
-    // truthy non-object can never satisfy `.speaker === from`, so it is
+    // truthy non-object can never satisfy the NFC name match below, so it is
     // deliberately not claimed as tested.
     if (!row || typeof row !== 'object') return
     const r = row as Record<string, unknown>
-    if (r.speaker !== from) return
+    if (!sameSpeakerName(r.speaker, from)) return
     if (restrict && !restrict.has(i)) { remainingWithFrom++; return }
     r.speaker = to
     changed.push(i)
@@ -131,18 +136,18 @@ export function relabelSidecarJson(
   if (isVoiceLabel(to)) {
     // 6.90.0: a Mac `Voice N` placeholder never enters `speakers` (the store
     // keeps it out too), so merging into one adds nothing. Retire `from` only.
-    const at = speakers.indexOf(from)
+    const at = speakers.findIndex(x => sameSpeakerName(x, from))
     if (at >= 0 && remainingWithFrom === 0) speakers.splice(at, 1)
-  } else if (!speakers.includes(to)) {
+  } else if (!speakers.some(x => sameSpeakerName(x, to))) {
     // Replace in place when `from` is being fully retired, so the list keeps its
     // original ordering rather than moving the person to the end.
-    const at = speakers.indexOf(from)
+    const at = speakers.findIndex(x => sameSpeakerName(x, from))
     if (at >= 0 && remainingWithFrom === 0) speakers[at] = to
     else speakers.push(to)
   } else if (remainingWithFrom === 0) {
     // `to` already listed and `from` fully retired — merging a split identity.
     // Drop the old entry rather than leaving a name nothing is attributed to.
-    const at = speakers.indexOf(from)
+    const at = speakers.findIndex(x => sameSpeakerName(x, from))
     if (at >= 0) speakers.splice(at, 1)
   }
   doc.speakers = speakers
@@ -198,6 +203,8 @@ export function relabelMeetingMarkdown(
   to: string,
   options: { removeAttendee?: boolean } = {},
 ): RelabelOutcome<MarkdownRelabelResult> {
+  from = nfc(from)
+  to = nfc(to)
   if (from === to) return { ok: false, error: 'from and to are the same label' }
   for (const [which, label] of [['from', from], ['to', to]] as const) {
     const bad = invalidLabelReason(label)
@@ -215,7 +222,7 @@ export function relabelMeetingMarkdown(
     // Anchored at BOTH ends, and `[ \t]` rather than `\s` so a pattern can never
     // run past its own line. Without the end anchor, `- Theo M` matches the
     // PREFIX of `- Theo Marsh` and deleting it leaves the fragment `enry`.
-    const line = (label: string) => `^-[ \t]+${escapeRegExp(label)}[ \t]*$`
+    const line = (label: string) => `^-[ \t]+${nameForms(label, escapeRegExp)}[ \t]*$`
     // A de-attribution must DELETE the attendee bullet, never rename it. Renaming
     // writes `- Unidentified 2` into the attendee list as though it were a
     // person, and the COS pipeline that BUILDS attendees deliberately excludes
@@ -241,7 +248,7 @@ export function relabelMeetingMarkdown(
   if (tr) {
     const body = out.slice(tr.start, tr.end)
     const rewritten = body.replace(
-      new RegExp(`^\\[${escapeRegExp(from)}\\]:`, 'gm'),
+      new RegExp(`^\\[${nameForms(from, escapeRegExp)}\\]:`, 'gm'),
       () => { transcript++; return `[${to}]:` },
     )
     out = out.slice(0, tr.start) + rewritten + out.slice(tr.end)
@@ -276,7 +283,7 @@ export function detectProseReferences(md: string, label: string): string[] {
   prose += md.slice(cursor)
 
   const hits: string[] = []
-  const full = new RegExp(`\\b${escapeRegExp(label)}\\b`)
+  const full = new RegExp(`\\b${nameForms(label, escapeRegExp)}\\b`)
   if (full.test(prose)) hits.push(label)
   const first = label.split(/\s+/)[0]
   // Only a multi-word label has a distinct bare-first-name form. 'MU' or 'Ext'

package/server/lib/meeting-scribe-content.ts

@@ -276,6 +276,9 @@ export interface AttendeeLine {
    */
   isOwner: boolean
   confirmedByHuman: boolean
+  /** Qualified exact-span machine evidence; raw capture scores stay unchanged. */
+  machineQualified?: boolean
+  machineQualifiedSegments?: number
 }
 
 /**
@@ -406,8 +409,12 @@ export function renderProvenance(
   const clauses: string[] = []
   const owner = named.filter(v => v.isOwner).map(q)
   const human = named.filter(v => !v.isOwner && v.confirmedByHuman).map(q)
-  const matched = named.filter(v => !v.isOwner && !v.confirmedByHuman).map(q)
+  const machine = named.filter(v => !v.isOwner && !v.confirmedByHuman && v.machineQualified).map(q)
+  const combined = named.filter(v => !v.isOwner && !v.confirmedByHuman && !v.machineQualified && (v.machineQualifiedSegments ?? 0) > 0).map(q)
+  const matched = named.filter(v => !v.isOwner && !v.confirmedByHuman && !v.machineQualified && !(v.machineQualifiedSegments ?? 0)).map(q)
   if (owner.length) clauses.push(`${owner.join(', ')} by wearing the device`)
+  if (machine.length) clauses.push(`${machine.join(', ')} by qualified independent long-window profile evidence (not human confirmation)`)
+  if (combined.length) clauses.push(`${combined.join(', ')} by capture matches plus qualified independent long-window profile evidence (not human confirmation)`)
   if (matched.length) clauses.push(`${matched.join(', ')} by voice match`)
   if (human.length) clauses.push(`${human.join(', ')} because a human named that voice`)
   const lines: string[] = [

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

@@ -22,7 +22,9 @@
 //
 // Everything here is pure over a chunk array so it can be tested by execution.
 
+import type { QualifiedMachinePosition } from './mac-speaker-machine-evidence.js'
 import { isVoiceLabel } from './mac-voice-labels.js'
+import { nfc, sameSpeakerName } from './speaker-name-nfc.js'
 
 /** One transcript chunk as stored in the `.g2-chunks.json` sidecar. */
 export interface ReviewChunk {
@@ -152,6 +154,10 @@ export interface VoiceReview {
   isOwner: boolean
   /** A human confirmed this label for this meeting; the floor is waived. */
   confirmedByHuman: boolean
+  /** Independent long-window profile evidence, never a human confirmation. */
+  machineQualified: boolean
+  machineQualifiedSegments: number
+  assertionSource: 'owner' | 'human' | 'qualified-profile' | 'capture-and-qualified-profile' | 'capture-match' | null
   reliability: Reliability
   /**
    * Whether `label` may be shown to a human AS A NAME.
@@ -588,6 +594,9 @@ export function reviewMeetingSpeakers(
      */
     confirmed?: Set<string>
     confirmedChunks?: Map<number, string>
+    /** Reader-validated exact compacted positions from current bound raw audio. */
+    machineEvidenceStatus?: 'absent' | 'qualified' | 'invalid'
+    machineQualifiedPositions?: ReadonlyMap<number, QualifiedMachinePosition>
     /**
      * The sidecar's `batchSegments`, when the HQ pass has run. Their word
      * timings give real voiced time; without them speaking time falls back to
@@ -597,10 +606,10 @@ export function reviewMeetingSpeakers(
   } = {},
 ): MeetingSpeakerReview {
   const owner = options.owner ?? 'Me'
-  const confirmed = new Set(options.confirmed ?? [])
+  const confirmed = new Set([...(options.confirmed ?? [])].map(nfc))
   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)
+    if (positions.length > 0 && positions.every(i => sameSpeakerName(options.confirmedChunks?.get(i), label))) confirmed.add(nfc(label))
   }
   const limit = options.phrasesPerVoice ?? 3
   const sequence = chunks.map(c => c.speaker ?? '')
@@ -646,10 +655,28 @@ export function reviewMeetingSpeakers(
   const voices: VoiceReview[] = labels.map(label => {
     const own = chunks.filter(c => (c.speaker ?? '') === label)
     const sims = own.map(c => c.similarity).filter((s): s is number => typeof s === 'number' && s > 0)
+    const machineQualifiedSegments = chunks.reduce((n, c, i) => {
+      const proof = options.machineQualifiedPositions?.get(i)
+      return n + Number(c.speaker === label && !!proof && proof.label === label
+        && (c.chunkIndex === undefined || c.chunkIndex === proof.rawChunkIndex)
+        && proof.independentWindows >= 2 && proof.minimumSimilarity >= .88 && proof.minimumMargin >= .05)
+    }, 0)
+    const machineQualified = own.length > 0 && machineQualifiedSegments === own.length
+    // Repaired records require support for every occurrence. A legacy mean
+    // from one positive row cannot vouch for repaired zero-score positions.
+    const scopedMachineRecord = (options.machineEvidenceStatus !== undefined && options.machineEvidenceStatus !== 'absent') || (options.machineQualifiedPositions?.size ?? 0) > 0
+    const unsupportedScopedSegments = scopedMachineRecord ? chunks.reduce((n, c, i) => {
+      if (c.speaker !== label) return n
+      const proof = options.machineQualifiedPositions?.get(i)
+      const machine = proof?.label === label && (c.chunkIndex === undefined || c.chunkIndex === proof.rawChunkIndex) && proof.independentWindows >= 2 && proof.minimumSimilarity >= .88 && proof.minimumMargin >= .05
+      const human = confirmed.has(nfc(label)) || sameSpeakerName(options.confirmedChunks?.get(i), label)
+      const capture = typeof c.similarity === 'number' && Number.isFinite(c.similarity) && c.similarity >= ASSERT_MIN_SIMILARITY
+      return n + Number(!machine && !human && !capture)
+    }, 0) : 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 confirmedSegments = unattributed ? 0 : confirmed.has(nfc(label)) ? own.length
+      : chunks.reduce((n, c, i) => n + Number(c.speaker === label && sameSpeakerName(options.confirmedChunks?.get(i), label)), 0)
 
     const thrashesWith: ThrashPair[] = []
     if (!unattributed) {
@@ -674,7 +701,7 @@ export function reviewMeetingSpeakers(
       ? 'unattributed'
       : thrashesWith.length > 0
         ? 'unreliable'
-        : (meanSim ?? 0) >= CONFIDENT_SIMILARITY ? 'confident' : 'weak'
+        : machineQualified || (meanSim ?? 0) >= CONFIDENT_SIMILARITY ? 'confident' : 'weak'
 
     // What stops this label being presented as a name. Collected as reasons
     // rather than a bare boolean: "2 segments" and "similarity 0.58" are
@@ -682,12 +709,17 @@ export function reviewMeetingSpeakers(
     const assertionBlockers: string[] = []
     if (unattributed) {
       assertionBlockers.push('no name was ever assigned to this voice')
-    } else if (confirmed.has(label)) {
+    } else if (confirmed.has(nfc(label))) {
       // A human said this is them. Blockers stay OFF the list rather than being
       // listed-then-overridden, because a reviewer reading "similarity 0.56
       // below 0.65" under a name they personally confirmed would reasonably
       // conclude the confirmation had not taken. `thrashesWith` still renders,
       // so a genuinely mixed row is still visibly mixed.
+    } else if (unsupportedScopedSegments) {
+      // System-audio repairs do not identify the wearer by device ownership.
+      // This gate also precedes the legacy owner exemption.
+      assertionBlockers.push(`${unsupportedScopedSegments} segment${unsupportedScopedSegments === 1 ? '' : 's'} lack current scoped speaker evidence`)
+      if (thrashesWith.length > 0) assertionBlockers.push(`swaps with ${thrashesWith[0].speaker} every ${Math.round(thrashesWith[0].meanRun)} segments`)
     } else if (label === owner) {
       // The wearer is exempt. Their identity is established by wearing the
       // device, not by cosine — and the owner is verified at exactly this floor
@@ -696,6 +728,10 @@ export function reviewMeetingSpeakers(
       // row read "Unidentified voice" in 4 of 9 meetings, including one with 285
       // of their own segments. `thrashesWith` still renders, so a mixed row is
       // still visible — the name is asserted, the caveat is not hidden.
+    } else if (machineQualified) {
+      // Exact positions passed the independent .88/margin/long-window gate.
+      // Keep raw similarities unchanged and retain the mixed-row warning.
+      if (thrashesWith.length > 0) assertionBlockers.push(`swaps with ${thrashesWith[0].speaker} every ${Math.round(thrashesWith[0].meanRun)} segments`)
     } else {
       if (own.length < ASSERT_MIN_SEGMENTS) {
         assertionBlockers.push(`only ${own.length} segment${own.length === 1 ? '' : 's'} (needs ${ASSERT_MIN_SEGMENTS})`)
@@ -718,7 +754,10 @@ export function reviewMeetingSpeakers(
       longestRun: runs.length ? Math.max(...runs) : 0,
       isOwner: label === owner,
       /** True when a human vouched for this label in this meeting. */
-      confirmedByHuman: confirmed.has(label),
+      confirmedByHuman: confirmed.has(nfc(label)),
+      machineQualified: !unattributed && machineQualified,
+      machineQualifiedSegments: unattributed ? 0 : machineQualifiedSegments,
+      assertionSource: assertionBlockers.length ? null : confirmed.has(nfc(label)) ? 'human' : label === owner ? 'owner' : machineQualified ? 'qualified-profile' : machineQualifiedSegments > 0 ? 'capture-and-qualified-profile' : 'capture-match',
       reliability,
       nameAsserted: assertionBlockers.length === 0,
       assertionBlockers,

package/server/lib/nemotron-final.ts

@@ -40,6 +40,7 @@ import {
   nemotronCliPath,
   prepareNemotronModelsDir,
 } from './diarizer-backend.js'
+import { readCorrections } from './meeting-corrections.js'
 import { CONFIDENT_SIMILARITY, isUnattributed } from './meeting-speaker-review.js'
 import { getOwnerSpeakerLabel } from './profile.js'
 import { OWNER_VERIFY_SIMILARITY } from './voiceprint-floor.js'
@@ -370,6 +371,24 @@ function liveSpeakerAt(chunk: SidecarChunk, t: number, owner?: string | null): s
   return best && typeof best.speaker === 'string' ? guardOwnerName(best.speaker, best.similarity, chunk, owner) : null
 }
 
+/** Existing strict Mac names are local immutable claims, never a name source
+ * for a global anonymous channel. Exact token/word labels win over chunk names.
+ * An unplaced named segment withholds anonymous refinement for the whole chunk. */
+function protectedMacName(chunk: SidecarChunk, t: number, exact?: string): { name: string | null; hold: boolean } {
+  if (chunk.speakerPolicy !== 'high-confidence') return { name: null, hold: false }
+  if (typeof exact === 'string' && isName(exact)) return { name: exact, hold: true }
+  const named = (chunk.segments ?? []).filter(s => isName(s.speaker))
+  for (const segment of named) {
+    if (!Number.isFinite(segment.startSec) || !Number.isFinite(segment.endSec)
+      || Number(segment.startSec) < 0 || Number(segment.endSec) <= Number(segment.startSec)) return { name: null, hold: true }
+    if (t >= Number(segment.startSec) && t < Number(segment.endSec)) return { name: segment.speaker, hold: true }
+  }
+  // A segment-less legacy chunk has only its head claim. Explicit anonymous
+  // turns, however, must never inherit a real name from the majority/head label.
+  if (isName(chunk.speaker) && !chunk.segments?.length) return { name: chunk.speaker, hold: true }
+  return { name: null, hold: false }
+}
+
 export interface RelabelStats {
   total: number
   /** Words whose label changed. */
@@ -418,13 +437,15 @@ export function relabelBatchSegments(
       const end = batchWordToTimeline(segment, Number(word.end), timeline)
       // Existing live anonymous turns are established capture evidence. A
       // meeting-wide channel may refine unknown speech, never overwrite them.
-      const live = start ? liveSpeakerAt(start.window.chunk, start.inChunk, owner) : null
-      let name: string | null = isVoiceLabel(live) ? live : null
-      if (name === null && start) {
+      const liveCandidate = start ? liveSpeakerAt(start.window.chunk, start.inChunk, owner) : null
+      const protectedName = start ? protectedMacName(start.window.chunk, start.inChunk, word.speaker) : { name: null, hold: false }
+      const live = start?.window.chunk.speakerPolicy === 'high-confidence' && isName(liveCandidate) ? protectedName.name : liveCandidate
+      let name: string | null = protectedName.name ?? (isVoiceLabel(live) ? live : null)
+      if (name === null && !protectedName.hold && start) {
         const channel = channelForSpan(a, start.at, Math.max(start.at, end?.window === start.window ? end.at : start.at + 0.01))
         if (channel !== null && map.has(channel)) { name = map.get(channel)!; stats.viaChannel++ }
       }
-      if (isVoiceLabel(live)) stats.kept++
+      if (isVoiceLabel(live) || protectedName.name !== null) stats.kept++
       if (name === null) {
         stats.kept++
         name = live
@@ -479,20 +500,34 @@ export function relabelStreamingChunks(
     if (typeof chunk.text !== 'string' || !chunk.text.trim()) continue
     const tokens = splitTokens(chunk.text)
     const times = streamingTokenTimes(chunk, tokens, window, a)
-    const base = guardOwnerName(typeof chunk.originalSpeaker === 'string' ? chunk.originalSpeaker : chunk.speaker, chunk.similarity, chunk, owner)
+    const originalBase = guardOwnerName(typeof chunk.originalSpeaker === 'string' ? chunk.originalSpeaker : chunk.speaker, chunk.similarity, chunk, owner)
+    const base = chunk.speakerPolicy === 'high-confidence' && chunk.segments?.length && isName(originalBase) ? 'Ext' : originalBase
     const labels: string[] = []
     const liveTokens = (chunk.segments ?? []).flatMap(segment => splitTokens(String(segment.text ?? '')).map(token => ({ token, speaker: segment.speaker })))
     const exactLive = liveTokens.length === tokens.length && liveTokens.every((part, i) => part.token === tokens[i]) ? liveTokens : null
+    // Without token alignment or a clock, preserve the original named chunk
+    // rather than spreading a nearby named turn across its unmatched text.
+    if (chunk.speakerPolicy === 'high-confidence' && chunk.segments?.some(s => isName(s.speaker)) && !exactLive && !times) continue
     let carry: string | null = null
     for (let i = 0; i < tokens.length; i++) {
       const established = exactLive?.[i].speaker
-      if (!isWordToken(tokens[i]) || !times) { labels.push(isVoiceLabel(established) ? established! : carry ?? liveSpeakerAt(chunk, 0, owner) ?? base); continue }
+      if (!isWordToken(tokens[i]) || !times) {
+        const protectedName = !times && established === undefined && chunk.segments?.length ? { name: null, hold: true } : protectedMacName(chunk, times?.[i]?.start ?? 0, established)
+        const local = liveSpeakerAt(chunk, times?.[i]?.start ?? 0, owner)
+        const safeLocal = chunk.speakerPolicy === 'high-confidence' && isName(local) ? protectedName.name : local
+        labels.push(protectedName.name ?? (chunk.speakerPolicy === 'high-confidence' && established !== undefined ? established : isVoiceLabel(established) ? established! : carry ?? safeLocal ?? base))
+        continue
+      }
       stats.total++
       const span = times[i]
       const channel = channelForSpan(a, window.start + span.start, window.start + Math.max(span.end, span.start + 0.01))
       let name: string
-      const live = isVoiceLabel(established) ? established! : liveSpeakerAt(chunk, span.start, owner)
-      if (isVoiceLabel(live)) { name = live!; stats.kept++ }
+      const liveCandidate = isVoiceLabel(established) ? established! : liveSpeakerAt(chunk, span.start, owner)
+      const protectedName = protectedMacName(chunk, span.start, established)
+      const live = chunk.speakerPolicy === 'high-confidence' && isName(liveCandidate) ? protectedName.name : liveCandidate
+      if (protectedName.name !== null) { name = protectedName.name; stats.kept++ }
+      else if (protectedName.hold) { name = live ?? base; stats.kept++ }
+      else if (isVoiceLabel(live)) { name = live!; stats.kept++ }
       else if (channel !== null && map.has(channel)) { name = map.get(channel)!; stats.viaChannel++ }
       else { name = live ?? base; stats.kept++ }
       labels.push(name)
@@ -787,6 +822,14 @@ function distinctSpeakers(transcript: string): number {
   return names.size
 }
 
+/** Legacy corrections may have a ledger without a sidecar revision. Unknown
+ * or incomplete recorded history is held, never treated as automatic evidence. */
+function hasHumanCorrectionHistory(sidecar: Record<string, unknown>): boolean {
+  if (typeof sidecar.sessionId !== 'string') return false
+  const corrections = readCorrections(sidecar.sessionId)
+  return corrections.rows.length > 0 || corrections.unusable > 0
+}
+
 async function finalPassNow(options: FinalPassOptions): Promise<FinalPassOutcome> {
   const started = (options.now ?? Date.now)()
   const env = options.env ?? process.env
@@ -801,6 +844,7 @@ async function finalPassNow(options: FinalPassOptions): Promise<FinalPassOutcome
   const sidecar = JSON.parse(sidecarText) as Record<string, any>
   const owner = options.owner !== undefined ? options.owner : ownerLabelOrNull()
   if (Number(sidecar.correctionRevision ?? 0) > 0) return { status: 'skipped', reason: 'human_corrected' }
+  if (hasHumanCorrectionHistory(sidecar)) return { status: 'skipped', reason: 'human_corrected' }
   const markdown = readFileSync(options.meetingPath, 'utf8')
   const transcript = readTranscriptSection(markdown)
   if (transcript === null) return { status: 'skipped', reason: 'no_transcript' }
@@ -1025,6 +1069,9 @@ function commitFinalPass(
     return { status: 'skipped', reason: 'changed_during_pass', detail: sidecarNow !== sidecarText ? 'sidecar changed' : 'markdown changed' }
   }
 
+  // A legacy confirmation can land only in its ledger while native work runs.
+  if (hasHumanCorrectionHistory(nextSidecar)) return { status: 'skipped', reason: 'changed_during_pass', detail: 'correction history changed' }
+
   // Sidecar first, markdown second, as the store does: the markdown is the
   // visible commit. If the markdown write fails, put the sidecar back, and say
   // so loudly if even that fails (the two files then disagree).
@@ -1056,8 +1103,8 @@ function commitFinalPass(
 // ── 6.90.0: unnamed, meeting-stable voices for Mac recordings ───────────────────
 //
 // The named pass above maps a channel to a name from chunks the voiceprint was
-// sure of. A Mac recording has no such chunks (every one is `Ext` at the 0.88
-// floor) and must never borrow a name, so it skips that pass (`speaker_policy`).
+// sure of. Strict Mac recordings never borrow names across a global channel;
+// rare existing names are preserved locally while other words stay anonymous.
 // This pass keeps the channels and drops the names: each channel that holds the
 // floor in enough chunks becomes `Voice 1`, `Voice 2`, ... in order of first
 // speech. No profile is read or written anywhere below; `owner` is never passed,
@@ -1070,9 +1117,9 @@ export const VOICE_MIN_SUPPORT = FINAL_MIN_SUPPORT
 
 /**
  * Unnamed mode applies to a Mac recording, with the switch on, when every chunk
- * that carries words is the Mac strict policy and none already carries a real
- * name (a 0.88 match is rare, and a pass must never overwrite one with a
- * placeholder).
+ * that carries words is the Mac strict policy. Rare existing names are protected
+ * per span by the relabellers; one match must not disable anonymous refinement
+ * for the remainder of an otherwise strict recording.
  */
 export function unnamedVoicesEligible(
   sidecar: Record<string, unknown>,
@@ -1090,7 +1137,7 @@ export function unnamedVoicesEligible(
   // strict; anything else (anonymous, a malformed marker) still refuses.
   const silentOk = entries.filter(entry => !hasText(entry.chunk))
     .every(entry => entry.chunk?.speakerPolicy === undefined || entry.chunk.speakerPolicy === 'high-confidence')
-  return silentOk && spoken.every(chunk => chunk.speakerPolicy === 'high-confidence' && !isName(chunk.speaker))
+  return silentOk && spoken.every(chunk => chunk.speakerPolicy === 'high-confidence')
 }
 
 export interface VoiceChannels {
@@ -1360,6 +1407,9 @@ async function unnamedVoicePass(input: UnnamedInput): Promise<FinalPassOutcome>
     for (const chunk of [entry.chunk, chunks[i]]) {
       const original = typeof chunk.originalSpeaker === 'string' ? chunk.originalSpeaker : chunk.speaker
       if (final) chunk.finalSegments = final.segments
+      // A pre-existing strict name is immutable even when a legacy chunk's
+      // segments disagree. The anonymous pass never asserts a different name.
+      if (chunk.speakerPolicy === 'high-confidence' && isName(chunk.speaker)) continue
       chunk.speaker = label
       if (label !== original) chunk.originalSpeaker = original
       else delete chunk.originalSpeaker