@gotcos/glasses-server 6.89.0 → 6.90.0

package/.env.example

@@ -60,6 +60,13 @@ BIND_HOST=0.0.0.0
 # See docs/tailscale-self-heal.md.
 # COS_TAILSCALE_NUDGE=0
 
+# 6.90.0 Mac recording voice labels. After a Mac recording is saved, one Nemotron
+# pass over the whole meeting labels its voices Voice 1, Voice 2, ... (unnamed,
+# stable for the meeting). No voice profile is read or written, and renaming a
+# Voice N is text only. Crowded or unclear rooms stay Ext. On by default; 0 turns
+# it off and Mac recordings stay all Ext.
+# COS_MAC_VOICE_LABELS=0
+
 # Build 204+ uses server-owned durable query jobs by default. The server fsyncs an
 # accepted prompt before returning 202, then keeps provider work running if the
 # phone backgrounds, reloads, or changes networks. Reopening COS reattaches to

package/CHANGELOG.md

@@ -1,3 +1,39 @@
+## 6.90.0 - Mac recordings tell voices apart: unnamed Voice 1, Voice 2, renamed as text only
+
+Miles, 2026-10-23 09:35: "Voice 1/2 + rename", split out of 6.87.0 at 10:06. Every saved Mac recording was 100% `Ext`:
+Nemotron heard a second voice in about 1 chunk in 10, and the 0.88 naming floor and same-label turn merge threw that
+away. This keeps Mac audio unnamed (no calibration exists to name anyone from call audio) and keeps its voices apart.
+
+- **Unnamed meeting-wide voices** (`server/lib/nemotron-final.ts`, `unnamedVoicePass`). At save, a Mac recording (the
+  `mac_system_audio` sidecar or a `mac_` id, every chunk with words strict `high-confidence`, none carrying a real name)
+  now takes the meeting-wide Nemotron final pass in an unnamed mode instead of `skipped: speaker_policy`. A channel that
+  holds the floor, one-sided, in 3 or more chunks becomes `Voice 1`, `Voice 2`, ... in order of first speech. No voice
+  profile is read or written, the wearer is never consulted, and `speakers` is left as saved. A crowded room (more than
+  4 such voices, or all 8 Nemotron channels in use) is `voices_crowded`, and a room with no such channel is
+  `voices_unconfident`: both stay `Ext`, byte for byte. A voice that would have turns but lead no chunk (or the reverse)
+  is dropped back to `Ext` and the rest renumbered, so every `Voice N` can be renamed in one action. Words, line breaks
+  and the human-correction rule are the final pass's own guarantees, unchanged; the original transcript stays under
+  `diarization.originalTranscript` with `labels: "unnamed"`. Glasses and every other strict capture keep the 6.73.6 skip.
+- **Switch:** `COS_MAC_VOICE_LABELS`, on by default; `0`, `false`, `off` or `no` gives 6.89.0's behaviour. Forwarded by
+  the managed runtime contract.
+- **`Voice N` is a placeholder everywhere a name is checked:** `isUnattributed` (review panel, final pass), the relabel
+  `PLACEHOLDER_LABEL`, the sidecar `speakers` filter at save, the batch segment `speakers` filters
+  (`isNamedSegmentSpeaker`), `isRealLabel` in live naming, and a merge into a Voice label never writes it into `speakers`.
+- **Rename is text only.** The existing `POST /meeting/:id/relabel` renames `Voice 2` to a person. `enrolNamedVoice` now
+  refuses any Mac recording with `skipped: "mac_capture"` before it reads a store, so a Mac rename can never enrol or
+  train a profile (until now that was true only because Mac banks no embeddings).
+- **Shadow scoring (calibration only).** A Mac chunk the 0.88 floor leaves `Ext` also logs its best profile match at the
+  ordinary 0.55 floor to `speaker-calibration.jsonl` under `event: "mac-shadow"`, `matched: false`. The label stays
+  `Ext`; nothing is enrolled; nothing goes to server.log.
+- **Mac Nemotron tracks** are identified with `prioritizeOwner: false` and tagged `mac-nemotron-track`, so their
+  calibration rows are separable from the glasses' `nemotron-track`.
+- **Replay** (read-only, clones of six 10/16 to 10/22 Mac sidecars against Miles's private audio copy, scratch data dir):
+  3 of 6 took voices (4, 1 and 1 voices; 76 of 370 chunks with words split into two or more voices in the 4-voice call),
+  3 stayed `Ext` as crowded (all 8 channels in use, 7, 5 and 7 confident channels). Found and fixed on the way: text-less
+  Mac entries carry no policy marker, which refused every real recording.
+- **Tailscale nudge follow-up (6.89.0):** a boot, wake, network or tailscale trigger that finds the phone already back logs
+  one line, `[tailscale-nudge] trigger=<t> outcome=already_reconnected`. Trigger and outcome only, never an address.
+
 ## 6.89.0 - LAN first removed; the Mac nudges a stale Tailscale tunnel back to life
 
 Miles, 2026-10-23 19:57: no LAN-only code, because he uses COS away from home; and checks around the nudge so the

package/managed-runtime-contract.json

@@ -37,6 +37,7 @@
     "COS_LIVE_CUES_V2_DAILY_WRITER_CALLS",
     "COS_LIVE_CUES_V2_MAC",
     "COS_TAILSCALE_NUDGE",
+    "COS_MAC_VOICE_LABELS",
     "COS_LIVE_CUES_JEV_DAILY_TOKENS",
     "COS_LIVE_CUES_SUBQ_DAILY_TOKENS",
     "COS_DECISION_PROVIDER_CUES",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.89.0",
+  "version": "6.90.0",
   "description": "COS Glasses: self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {
@@ -138,6 +138,7 @@
     "!server/scripts/live-meeting-6870-mutation-gate.mjs",
     "!server/scripts/integrity-6880-mutation-gate.mjs",
     "!server/scripts/tailscale-nudge-6890-mutation-gate.mjs",
+    "!server/scripts/mac-voices-6900-mutation-gate.mjs",
     "docs/tailscale-self-heal.md",
     "docs/test-plan-6.71.8.md",
     "docs/test-plan-6.71.9.md",

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

@@ -0,0 +1,50 @@
+// 6.90.0: unnamed, meeting-stable voice labels for Mac recordings.
+//
+// A Mac recording hears call audio, video and podcasts through one global tap.
+// Naming a voice from that audio is not safe (no calibration exists, see
+// CHANGELOG 6.73.6 and the 2026-10-14 Mac plan section 5), so every Mac chunk is
+// `Ext`. What IS safe is telling voices apart: one Nemotron pass over the whole
+// saved meeting gives channels that are consistent for the call, and each
+// confident channel becomes `Voice 1`, `Voice 2`, ... in order of first speech.
+//
+// A `Voice N` label asserts NO identity. Everywhere a real name is checked it is
+// a placeholder, exactly like `Ext` and `Unidentified N`: it is never a profile
+// name, never enrolled, never trained, never written into the meeting's
+// `speakers` list. A person may rename it (text only) through the relabel route.
+//
+// Switch: COS_MAC_VOICE_LABELS, on by default; 0, false, off or no turns it off
+// and Mac recordings stay all `Ext` exactly as 6.89.0 saved them.
+
+// No imports on purpose: placeholder checks are read from the speaker-review,
+// relabel and store layers, and this must never pull the Mac registry into them.
+const MAC_SOURCE_TYPE = 'mac_system_audio'
+
+/** `Voice 1` .. `Voice 99`. No leading zero, single space, nothing after. */
+export const VOICE_LABEL = /^Voice [1-9]\d?$/
+
+export function isVoiceLabel(label: unknown): boolean {
+  return typeof label === 'string' && VOICE_LABEL.test(label)
+}
+
+export function voiceLabel(n: number): string {
+  if (!Number.isInteger(n) || n < 1 || n > 99) throw new Error('voice number out of range')
+  return `Voice ${n}`
+}
+
+/** On unless explicitly switched off. Read at use, so a managed restart is not needed to turn it off. */
+export function macVoiceLabelsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  const raw = String(env.COS_MAC_VOICE_LABELS ?? '').trim().toLowerCase()
+  return !['0', 'false', 'off', 'no'].includes(raw)
+}
+
+/**
+ * A sidecar written by the Mac recording save path (`sourceType`), or any `mac_`
+ * id. Deliberately broader than MAC_CAPTURE_ID: this answers "could this be Mac
+ * audio", and a guard that asks it must fail closed on a malformed Mac id too.
+ */
+export function isMacCaptureSidecar(sidecar: Record<string, unknown> | null | undefined, sessionId?: string): boolean {
+  if (typeof sessionId === 'string' && sessionId.startsWith('mac_')) return true
+  if (!sidecar || typeof sidecar !== 'object') return false
+  if (sidecar.sourceType === MAC_SOURCE_TYPE) return true
+  return typeof sidecar.sessionId === 'string' && sidecar.sessionId.startsWith('mac_')
+}

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

@@ -2,6 +2,7 @@
 // larger windows so Whisper gets enough context to improve the live stream.
 // The candidate is never canonical until batch-transcript-quality accepts it.
 
+import { isVoiceLabel } from './mac-voice-labels.js'
 import { createHash } from 'node:crypto'
 import { existsSync, readFileSync, readdirSync, utimesSync, writeFileSync } from 'node:fs'
 import { availableParallelism } from 'node:os'
@@ -109,6 +110,11 @@ export function concatenateWavChunks(audioDir: string, startChunk: number, endCh
   return Buffer.concat([createWavHeader(pcm.length), pcm])
 }
 
+/** A segment's `speakers` list holds names only: never `Ext`, and (6.90.0) never a Mac `Voice N` placeholder. */
+export function isNamedSegmentSpeaker(speaker: string): boolean {
+  return Boolean(speaker) && speaker !== 'Ext' && !isVoiceLabel(speaker)
+}
+
 /** Group live transcript chunks into roughly 30-second Whisper windows. */
 export function segmentTranscriptChunks(
   entries: IndexedTranscriptChunk[],
@@ -135,7 +141,7 @@ export function segmentTranscriptChunks(
       segments.push({
         startChunkIdx: first.chunkIndex, endChunkIdx: last.chunkIndex,
         startElapsed: first.chunk.elapsed, endElapsed: last.chunk.elapsed,
-        speakers: [...new Set(window.map(item => policyLabel(item.chunk, captureSpeakerMode(item.chunk.speakerPolicy)).speaker).filter(speaker => speaker && speaker !== 'Ext'))],
+        speakers: [...new Set(window.map(item => policyLabel(item.chunk, captureSpeakerMode(item.chunk.speakerPolicy)).speaker).filter(isNamedSegmentSpeaker))],
         speakerPolicy: captureSpeakerMode(first.chunk.speakerPolicy),
       })
       segmentStartPosition = position
@@ -148,7 +154,7 @@ export function segmentTranscriptChunks(
         endChunkIdx: entry.chunkIndex,
         startElapsed: first.chunk.elapsed,
         endElapsed: chunk.elapsed,
-        speakers: [...new Set(window.map(item => policyLabel(item.chunk, captureSpeakerMode(item.chunk.speakerPolicy)).speaker).filter(speaker => speaker && speaker !== 'Ext'))],
+        speakers: [...new Set(window.map(item => policyLabel(item.chunk, captureSpeakerMode(item.chunk.speakerPolicy)).speaker).filter(isNamedSegmentSpeaker))],
         speakerPolicy: captureSpeakerMode(first.chunk.speakerPolicy),
       })
       segmentStartPosition = position + 1
@@ -165,7 +171,7 @@ export function segmentTranscriptChunks(
         endChunkIdx: last.chunkIndex,
         startElapsed: first.chunk.elapsed,
         endElapsed: last.chunk.elapsed,
-        speakers: [...new Set(window.map(item => policyLabel(item.chunk, captureSpeakerMode(item.chunk.speakerPolicy)).speaker).filter(speaker => speaker && speaker !== 'Ext'))],
+        speakers: [...new Set(window.map(item => policyLabel(item.chunk, captureSpeakerMode(item.chunk.speakerPolicy)).speaker).filter(isNamedSegmentSpeaker))],
         speakerPolicy: captureSpeakerMode(first.chunk.speakerPolicy),
       })
     }

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

@@ -48,6 +48,7 @@ import {
   readVoiceProfiles,
 } from './speaker-embeddings.js'
 import { attachRawChunkIndices, type ReviewChunk } from './meeting-speaker-review.js'
+import { isMacCaptureSidecar } from './mac-voice-labels.js'
 import {
   MAX_ENROL_PER_CORRECTION,
   dominantCoherentCluster,
@@ -56,7 +57,8 @@ import {
 
 /** Labels the diariser invents when it does not know who is speaking. Naming one
  *  of these is a FIRST TRAINING RUN for a new person, not a correction. */
-const PLACEHOLDER_LABEL = /^(ext|unknown|unidentified(\s+\d+)?|speaker\s*\d+)$/i
+// 6.90.0: `Voice N`, the unnamed Mac recording voice, is a placeholder too.
+const PLACEHOLDER_LABEL = /^(ext|unknown|unidentified(\s+\d+)?|speaker\s*\d+|voice\s+[1-9]\d?)$/i
 
 export const isPlaceholderLabel = (label: string): boolean => PLACEHOLDER_LABEL.test(label.trim())
 
@@ -81,6 +83,8 @@ export type EnrolmentSkipReason =
   | 'disabled'
   | 'expired'
   | 'store_unavailable'
+  /** 6.90.0: a Mac recording. Its audio is call or video playback and never trains a profile. */
+  | 'mac_capture'
 
 export interface EnrolmentReport {
   /** Samples the voice store actually accepted. */
@@ -217,6 +221,13 @@ export function enrolNamedVoice(input: EnrolNamedVoiceInput): EnrolmentReport {
   // placeholder-only `from` labelled the meeting and taught the store nothing.
   if (isPlaceholderLabel(to) || changed.length === 0) return IDLE
 
+  // 6.90.0: a Mac recording renames TEXT ONLY, always. Mac audio is call, video
+  // and podcast playback through one global tap; naming `Voice 2` must never
+  // turn that into a voice profile. Today Mac banks no embeddings, so this would
+  // also stop at `no_embeddings`, but only by accident of the store. This guard
+  // says it on purpose, before any store is read.
+  if (isMacCaptureSidecar(sidecar, sessionId)) return { ...IDLE, skipped: 'mac_capture' }
+
   if (!chunkEmbeddingsEnabled()) return { ...IDLE, skipped: 'disabled' }
   // No extractor/manager means every enrollEmbedding would return success:false.
   // Naming that beats looping twenty times and reporting a bare zero.

package/server/lib/meeting-relabel.ts

@@ -26,6 +26,8 @@
 // a first-name substitution in narrative text would rewrite sentences about
 // somebody else. Reported as `proseStale` instead.
 
+import { isVoiceLabel } from './mac-voice-labels.js'
+
 /** A label that would corrupt the file formats it gets written into. */
 export function invalidLabelReason(label: string): string | null {
   if (label.trim() === '') return 'label is empty'
@@ -126,7 +128,12 @@ export function relabelSidecarJson(
   // attributed anything.
   const existing = Array.isArray(doc.speakers) ? doc.speakers.filter((s): s is string => typeof s === 'string') : []
   const speakers = [...existing]
-  if (!speakers.includes(to)) {
+  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)
+    if (at >= 0 && remainingWithFrom === 0) speakers.splice(at, 1)
+  } else if (!speakers.includes(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)

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

@@ -22,6 +22,8 @@
 //
 // Everything here is pure over a chunk array so it can be tested by execution.
 
+import { isVoiceLabel } from './mac-voice-labels.js'
+
 /** One transcript chunk as stored in the `.g2-chunks.json` sidecar. */
 export interface ReviewChunk {
   text?: string
@@ -64,7 +66,8 @@ export const DEATTRIBUTED_PREFIX = 'Unidentified'
 /** True when a label asserts no identity — the exact set, or a numbered
  *  de-attribution. Prefix-aware so `Unidentified 3` is treated as unnamed. */
 export function isUnattributed(label: string): boolean {
-  return UNATTRIBUTED.has(label) || new RegExp(`^${DEATTRIBUTED_PREFIX} \\d+$`).test(label)
+  // 6.90.0: `Voice N` (an unnamed, meeting-stable Mac recording voice) asserts no identity either.
+  return UNATTRIBUTED.has(label) || new RegExp(`^${DEATTRIBUTED_PREFIX} \\d+$`).test(label) || isVoiceLabel(label)
 }
 
 /** Calibrated from the control pair above. A pair must be BOTH flip-happy and

package/server/lib/meeting-store.ts

@@ -1,3 +1,4 @@
+import { isVoiceLabel } from './mac-voice-labels.js'
 import { MAC_SOURCE_TYPE, readMacRecording, closeMacRecording } from './mac-recording.js'
 import {
   chmodSync,
@@ -429,8 +430,9 @@ export class MeetingStore {
       providers,
       providerCandidates: input.providerCandidates ?? {},
       // 6.61.0: a chunk can hold two named voices; its segments count too.
+      // 6.90.0: a Mac `Voice N` placeholder is no more a speaker than `Ext` is.
       speakers: [...new Set(input.chunks.flatMap(chunk => [chunk.speaker, ...(chunk.segments ?? []).map(segment => segment.speaker)])
-        .filter(speaker => speaker && speaker !== 'Ext'))],
+        .filter(speaker => speaker && speaker !== 'Ext' && !isVoiceLabel(speaker)))],
       chunks: input.chunks,
       chunkEntries: input.chunkEntries ?? input.chunks.map((chunk, chunkIndex) => ({ chunkIndex, chunk })),
       transferIntegrity: input.transferIntegrity ?? null,

package/server/lib/nemotron-final.ts

@@ -68,6 +68,7 @@ import {
   wavHeader,
 } from './nemotron-segments.js'
 import { captureSpeakerMode, type SpeakerMode } from './meeting-speaker-policy.js'
+import { isMacCaptureSidecar, isVoiceLabel, macVoiceLabelsEnabled, voiceLabel } from './mac-voice-labels.js'
 import { NEMOTRON_CHANNELS } from './nemotron-cli.js'
 import type { WhisperWord } from './whisper-local.js'
 
@@ -633,7 +634,7 @@ export const FINAL_REASON_CODES = [
   'no_transcript', 'already_applied', 'no_chunks', 'nemotron_timeout', 'nemotron_cli_failed',
   'nemotron_bad_output', 'nemotron_spawn_failed', 'nemotron_error', 'no_speaker_words', 'chunk_map_ambiguous',
   'word_mismatch', 'no_change', 'changed_during_pass', 'markdown_write', 'sidecar_restore_failed', 'too_long',
-  'metadata_not_persisted', 'speaker_policy', 'error',
+  'metadata_not_persisted', 'speaker_policy', 'voices_crowded', 'voices_unconfident', 'error',
 ] as const
 export type FinalReasonCode = typeof FINAL_REASON_CODES[number]
 const REASON_SET: ReadonlySet<string> = new Set(FINAL_REASON_CODES)
@@ -659,6 +660,10 @@ export interface FinalPassOutcome {
   /** Distinct speakers in the transcript before and after. */
   speakersBefore?: number
   speakersAfter?: number
+  /** 6.90.0: a Mac recording labelled with unnamed `Voice N` turns (no profile was read). */
+  unnamed?: boolean
+  /** How many `Voice N` labels the meeting carries after an unnamed pass. */
+  voices?: number
 }
 
 export interface FinalPassOptions {
@@ -738,7 +743,7 @@ export function runNemotronFinalPass(options: FinalPassOptions): Promise<FinalPa
     lastFinal = published
     const log = options.log ?? console.log
     if (outcome.status === 'applied') {
-      log(`[diarizer] final pass applied (${outcome.mode}${outcome.crowded ? `, crowded: ${outcome.identities} identities, per-chunk turns only` : ''}) in ${outcome.ms} ms: ${outcome.channels} channels, mapped ${JSON.stringify(outcome.mapped)}, ${outcome.words?.relabeled}/${outcome.words?.total} words relabelled, speakers ${outcome.speakersBefore} -> ${outcome.speakersAfter}${excludedNote(outcome)}`)
+      log(`[diarizer] final pass applied (${outcome.mode}${outcome.unnamed ? `, unnamed: ${outcome.voices} voices, no profile read` : ''}${outcome.crowded ? `, crowded: ${outcome.identities} identities, per-chunk turns only` : ''}) in ${outcome.ms} ms: ${outcome.channels} channels, mapped ${JSON.stringify(outcome.mapped)}, ${outcome.words?.relabeled}/${outcome.words?.total} words relabelled, speakers ${outcome.speakersBefore} -> ${outcome.speakersAfter}${excludedNote(outcome)}`)
     } else if (outcome.reason === 'sidecar_restore_failed') {
       log(`[diarizer] final pass FAILED and could not restore the sidecar: ${outcome.detail}`)
     } else {
@@ -798,9 +803,14 @@ async function finalPassNow(options: FinalPassOptions): Promise<FinalPassOutcome
   // Final diarization builds meeting-wide channel/name maps. Earlier Standard
   // identities cannot safely authorize names for later strict-policy audio.
   // Preserve the canonical transcript (including earlier names) byte-for-byte.
+  const sidecarChunks = (Array.isArray(sidecar.chunks) ? sidecar.chunks : []) as SidecarChunk[]
+  let unnamed = false
   if (entries.some(entry => captureSpeakerMode(entry.chunk.speakerPolicy) !== 'standard')
-    || (Array.isArray(sidecar.chunks) && sidecar.chunks.some((chunk: SidecarChunk) => captureSpeakerMode(chunk.speakerPolicy) !== 'standard'))) {
-    return { status: 'skipped', reason: 'speaker_policy' }
+    || sidecarChunks.some(chunk => captureSpeakerMode(chunk.speakerPolicy) !== 'standard')) {
+    // 6.90.0: a Mac recording may still take UNNAMED voices (see unnamedVoicePass).
+    // Every other strict capture keeps the 6.73.6 skip, byte for byte.
+    if (!unnamedVoicesEligible(sidecar, entries, sidecarChunks, env)) return { status: 'skipped', reason: 'speaker_policy' }
+    unnamed = true
   }
 
   const timeline = await buildMeetingTimeline(entries, options.audioDir)
@@ -850,6 +860,9 @@ async function finalPassNow(options: FinalPassOptions): Promise<FinalPassOutcome
   // A channel is in use once it holds a track's worth of speech (QA 6.61.0 N2:
   // one 10 ms blip on a third channel made a two-person call "crowded").
   const channelsUsed = new Set(tracksIn(activity, 0, activity.frames).map(track => track.channel))
+  if (unnamed) {
+    return unnamedVoicePass({ options, sidecar, sidecarText, markdown, transcript, entries, timeline, activity, run, channelsUsed: channelsUsed.size, started })
+  }
   // The canary's rule for a meeting-wide map (OUTCOME_2026-10-01, retro plan 4):
   // four or fewer identities and fewer than eight channels. A crowded room
   // (Wed 07:31 filled all eight with five names) gets no channel map; its words
@@ -955,6 +968,37 @@ async function finalPassNow(options: FinalPassOptions): Promise<FinalPassOutcome
   const nextMarkdown = replaceTranscriptSection(markdown, next)
   if (nextMarkdown === null) return { status: 'skipped', reason: 'no_transcript' }
 
+  const committed = commitFinalPass(options, sidecarText, markdown, nextSidecar, nextMarkdown, excluded)
+  if (committed) return committed
+  return {
+    status: 'applied',
+    mode,
+    crowded,
+    identities,
+    ms,
+    audioSec: Math.round(timeline.durationSec),
+    channels: channelsUsed.size,
+    mapped,
+    words: stats,
+    excluded,
+    speakersBefore: distinctSpeakers(transcript),
+    speakersAfter: distinctSpeakers(next),
+  }
+}
+
+/**
+ * Write a computed pass: re-read both files first (a human edit during the CLI
+ * run makes the pass stale), then sidecar, then markdown, restoring the sidecar
+ * if the markdown write fails. Null means both files were written.
+ */
+function commitFinalPass(
+  options: FinalPassOptions,
+  sidecarText: string,
+  markdown: string,
+  nextSidecar: Record<string, any>,
+  nextMarkdown: string,
+  excluded: MeetingTimeline['excluded'],
+): FinalPassOutcome | null {
   // The CLI ran for tens of seconds. A human relabel or deattribution, or a
   // summary, may have landed meanwhile; writing from the copy read before the
   // run would erase it. Re-read both files: any change and this pass is stale.
@@ -997,14 +1041,277 @@ async function finalPassNow(options: FinalPassOptions): Promise<FinalPassOutcome
     }
     return { status: 'failed', reason: 'markdown_write', detail: `${why}; sidecar restored`, excluded }
   }
+  return null
+}
+
+// ── 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`).
+// 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,
+// so the wearer guard cannot fire and no name can enter. A crowded room (more
+// than FINAL_MAX_IDENTITIES voices, or every channel in use) and a room with no
+// confident channel stay `Ext` exactly as saved.
+
+/** A channel becomes a voice only if it holds the floor, one-sided, in at least this many chunks. */
+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).
+ */
+export function unnamedVoicesEligible(
+  sidecar: Record<string, unknown>,
+  entries: SidecarEntry[],
+  chunks: SidecarChunk[],
+  env: NodeJS.ProcessEnv,
+): boolean {
+  if (!macVoiceLabelsEnabled(env) || !isMacCaptureSidecar(sidecar)) return false
+  const hasText = (chunk: SidecarChunk) => typeof chunk?.text === 'string' && chunk.text.trim().length > 0
+  const spoken = [...entries.map(entry => entry.chunk), ...chunks].filter(hasText)
+  if (!spoken.length) return false
+  // Measured on the six 10/16-10/22 Mac recordings: every text-less entry (an
+  // empty completion) is stored with no policy marker, so only the chunks that
+  // carry words must prove the Mac pin. A text-less entry may be unmarked or
+  // 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))
+}
+
+export interface VoiceChannels {
+  /** Accepted channels, in order of first supporting chunk. */
+  channels: number[]
+  evidence: Array<{ channel: number; support: number; firstSec: number; accepted: boolean }>
+  eligible: number
+}
+
+/** Channels that hold the floor, one-sided, in VOICE_MIN_SUPPORT or more chunks. Names are never read. */
+export function mapChannelsToVoices(windows: TimelineWindow[], a: Activity, options: { oneSided?: number; minSupport?: number } = {}): VoiceChannels {
+  const oneSided = options.oneSided ?? FINAL_ONE_SIDED
+  const minSupport = options.minSupport ?? VOICE_MIN_SUPPORT
+  const support = new Map<number, { support: number; firstSec: number }>()
+  let eligible = 0
+  for (const window of windows) {
+    const [f0, f1] = frameRange(a, window.start, window.end)
+    const counts = new Array<number>(NEMOTRON_CHANNELS).fill(0)
+    let speech = 0
+    for (let f = f0; f < f1; f++) {
+      let any = false
+      for (let c = 0; c < NEMOTRON_CHANNELS; c++) if (isActive(a, f, c)) { counts[c]++; any = true }
+      if (any) speech++
+    }
+    if (speech === 0) continue
+    let dom = 0
+    for (let c = 1; c < NEMOTRON_CHANNELS; c++) if (counts[c] > counts[dom]) dom = c
+    if (counts[dom] / speech < oneSided) continue
+    eligible++
+    const row = support.get(dom) ?? { support: 0, firstSec: window.start }
+    row.support++
+    row.firstSec = Math.min(row.firstSec, window.start)
+    support.set(dom, row)
+  }
+  const ordered = [...support.entries()].sort((x, y) => x[1].firstSec - y[1].firstSec || x[0] - y[0])
+  const evidence = ordered.map(([channel, row]) => ({ channel, support: row.support, firstSec: Math.round(row.firstSec * 100) / 100, accepted: row.support >= minSupport }))
+  return { channels: evidence.filter(row => row.accepted).map(row => row.channel), evidence, eligible }
+}
+
+/** `Voice 1` for the first channel, `Voice 2` for the next, and so on. */
+export function numberVoices(channels: number[]): Map<number, string> {
+  return new Map(channels.map((channel, i) => [channel, voiceLabel(i + 1)]))
+}
+
+function voicesIn(transcript: string): Set<string> {
+  const out = new Set<string>()
+  for (const line of transcript.split('\n')) {
+    const match = /^\[([^\]\n]+)\]:/.exec(line)
+    if (match && isVoiceLabel(match[1])) out.add(match[1])
+  }
+  return out
+}
+
+/** The label with the most words, ties to the earlier label. */
+function mostWords(counts: Map<string, number>): string | null {
+  let best: string | null = null
+  let n = -1
+  for (const [label, count] of counts) if (count > n) { best = label; n = count }
+  return best
+}
+
+interface UnnamedInput {
+  options: FinalPassOptions
+  sidecar: Record<string, any>
+  sidecarText: string
+  markdown: string
+  transcript: string
+  entries: SidecarEntry[]
+  timeline: MeetingTimeline
+  activity: Activity
+  run: NemotronPreds
+  channelsUsed: number
+  started: number
+}
+
+interface UnnamedLabelling {
+  next: string
+  stats: RelabelStats
+  /** chunkIndex -> the chunk's label (the one with the most words). */
+  chunkSpeakers: Map<number, string>
+  batchSegments?: SidecarBatchSegment[]
+  finals?: Map<number, { speaker: string; segments: ChunkSpeakerSegment[] }>
+}
+
+function labelUnnamed(input: UnnamedInput, mode: 'batch' | 'streaming', map: Map<number, string>): UnnamedLabelling | FinalPassOutcome {
+  const { sidecar, timeline, activity, transcript, entries } = input
+  if (mode === 'batch') {
+    const segments = (Array.isArray(sidecar.batchSegments) ? sidecar.batchSegments : []) as SidecarBatchSegment[]
+    if (!segments.length) return { status: 'skipped', reason: 'no_speaker_words' }
+    const selected = selectBatchTranscriptForPersistence(
+      String(sidecar.batchTranscript ?? ''),
+      segments.map(segment => ({ text: segment.text, speakerWords: segment.speakerWords })),
+    )
+    if (selected.source !== 'speaker-words') return { status: 'skipped', reason: 'no_speaker_words' }
+    const relabeled = relabelBatchSegments(segments, timeline, activity, map, null)
+    const sequence = relabeled.segments.flatMap(segment => segment.speakerWords
+      .map(word => ({ word: String(word.word ?? '').trim(), speaker: word.speaker || 'Ext' }))
+      .filter(word => word.word))
+    const next = (input.options.relabelWords ?? relabelTranscriptWords)(transcript, sequence)
+    const perChunk = new Map<number, Map<string, number>>()
+    for (const segment of relabeled.segments) {
+      for (const word of segment.speakerWords) {
+        const at = batchWordToTimeline(segment, Number(word.start), timeline)
+        if (!at) continue
+        const counts = perChunk.get(at.window.chunkIndex) ?? new Map<string, number>()
+        counts.set(word.speaker || 'Ext', (counts.get(word.speaker || 'Ext') ?? 0) + 1)
+        perChunk.set(at.window.chunkIndex, counts)
+      }
+    }
+    const chunkSpeakers = new Map<number, string>()
+    for (const [index, counts] of perChunk) { const top = mostWords(counts); if (top) chunkSpeakers.set(index, top) }
+    return { next, stats: relabeled.stats, chunkSpeakers, batchSegments: relabeled.segments }
+  }
+  const relabeled = relabelStreamingChunks(timeline, activity, map, null)
+  const textEntries = entries.filter(entry => typeof entry.chunk?.text === 'string' && entry.chunk.text.trim())
+  const next = relabelStreamingTranscript(transcript, textEntries.map(entry => ({ chunkIndex: entry.chunkIndex, text: entry.chunk.text })), relabeled.finals)
+  const chunkSpeakers = new Map<number, string>([...relabeled.finals.entries()].map(([index, final]) => [index, final.speaker]))
+  return { next, stats: relabeled.stats, chunkSpeakers, finals: relabeled.finals }
+}
+
+/**
+ * The unnamed pass. Labels are kept consistent between the transcript and the
+ * chunks the relabel route edits: a voice that would appear in turns but lead no
+ * chunk (or lead a chunk but have no turn, or neither) could never be renamed in
+ * one action, so its channel is dropped back to `Ext` and the rest are
+ * renumbered. A pass with no voice left is `voices_unconfident`.
+ */
+async function unnamedVoicePass(input: UnnamedInput): Promise<FinalPassOutcome> {
+  const { options, sidecar, sidecarText, markdown, transcript, entries, timeline, activity, run, channelsUsed, started } = input
+  const excluded = timeline.excluded
+  const mode: 'batch' | 'streaming' = sidecar.batchApplied === true ? 'batch' : 'streaming'
+  const found = mapChannelsToVoices(timeline.windows, activity)
+  const crowded = isCrowded(found.channels.length, channelsUsed)
+  if (crowded) {
+    return { status: 'skipped', reason: 'voices_crowded', unnamed: true, mode, crowded: true, identities: found.channels.length, channels: channelsUsed, excluded }
+  }
+
+  const nextSidecar: Record<string, any> = JSON.parse(sidecarText)
+  const chunks = Array.isArray(nextSidecar.chunks) ? nextSidecar.chunks as SidecarChunk[] : []
+  const nextEntries = (Array.isArray(nextSidecar.chunkEntries) ? nextSidecar.chunkEntries : []) as SidecarEntry[]
+  const textNext = nextEntries.filter(entry => typeof entry.chunk?.text === 'string' && entry.chunk.text.trim())
+  const aligned = textNext.length === chunks.length && textNext.every((entry, i) => entry.chunk.text === chunks[i]?.text)
+  if (!aligned) return { status: 'skipped', reason: 'chunk_map_ambiguous', unnamed: true, mode, excluded }
+
+  let channels = [...found.channels]
+  let map = numberVoices(channels)
+  let labelled: UnnamedLabelling | null = null
+  for (let round = 0; round <= NEMOTRON_CHANNELS && channels.length; round++) {
+    map = numberVoices(channels)
+    const attempt = labelUnnamed(input, mode, map)
+    if ('status' in attempt) return { ...attempt, unnamed: true, mode, excluded }
+    const inTurns = voicesIn(attempt.next)
+    const leading = new Set(textNext.map(entry => attempt.chunkSpeakers.get(entry.chunkIndex)).filter((label): label is string => isVoiceLabel(label)))
+    // A voice must both speak a turn and lead a chunk. One that does neither (a
+    // channel with no words) is dropped too, so numbering never skips a voice.
+    const kept = channels.filter(channel => inTurns.has(map.get(channel)!) && leading.has(map.get(channel)!))
+    if (kept.length === channels.length) { labelled = attempt; break }
+    channels = kept
+  }
+  // No confident channel at all, or none left once orphans are dropped: the room stays Ext.
+  if (!labelled || !channels.length) return { status: 'skipped', reason: 'voices_unconfident', unnamed: true, mode, channels: channelsUsed, excluded }
+  const { next, stats } = labelled
+
+  if (!sameWords(transcript, next)) return { status: 'skipped', reason: 'word_mismatch', unnamed: true, mode, excluded }
+  if (next === transcript) return { status: 'skipped', reason: 'no_change', unnamed: true, mode, words: stats, excluded, channels: channelsUsed }
+
+  textNext.forEach((entry, i) => {
+    const label = labelled!.chunkSpeakers.get(entry.chunkIndex)
+    if (!label) return
+    const final = labelled!.finals?.get(entry.chunkIndex)
+    for (const chunk of [entry.chunk, chunks[i]]) {
+      const original = typeof chunk.originalSpeaker === 'string' ? chunk.originalSpeaker : chunk.speaker
+      if (final) chunk.finalSegments = final.segments
+      chunk.speaker = label
+      if (label !== original) chunk.originalSpeaker = original
+      else delete chunk.originalSpeaker
+    }
+  })
+  if (labelled.batchSegments) {
+    nextSidecar.batchSegments = labelled.batchSegments
+    if (typeof sidecar.batchTranscript === 'string') nextSidecar.batchTranscript = next
+  }
+
+  const voices = voicesIn(next).size
+  const ms = (options.now ?? Date.now)() - started
+  const mapped = Object.fromEntries([...map.entries()].map(([channel, label]) => [String(channel), label]))
+  // `speakers` is left exactly as saved: a `Voice N` placeholder is never a speaker name.
+  nextSidecar.lifecycleRevision = Number(sidecar.lifecycleRevision ?? 0) + 1
+  nextSidecar.diarization = {
+    engine: 'nemotron3',
+    variant: NEMOTRON_VARIANT,
+    bundle: NEMOTRON_BUNDLE,
+    computeUnits: 'ane',
+    status: 'applied',
+    mode,
+    labels: 'unnamed',
+    appliedAt: new Date((options.now ?? Date.now)()).toISOString(),
+    ms,
+    audioSec: Math.round(timeline.durationSec * 10) / 10,
+    frames: run.frames,
+    channelsUsed,
+    channelMap: mapped,
+    mapping: {
+      unnamed: true,
+      crowded: false,
+      voices,
+      eligibleChunks: found.eligible,
+      oneSided: FINAL_ONE_SIDED,
+      minSupport: VOICE_MIN_SUPPORT,
+      evidence: found.evidence,
+    },
+    words: stats,
+    excludedChunks: timeline.excluded,
+    originalTranscript: transcript,
+    outputSha256: sha(next),
+  }
+  const nextMarkdown = replaceTranscriptSection(markdown, next)
+  if (nextMarkdown === null) return { status: 'skipped', reason: 'no_transcript' }
+  const committed = commitFinalPass(options, sidecarText, markdown, nextSidecar, nextMarkdown, excluded)
+  if (committed) return { ...committed, unnamed: true }
   return {
     status: 'applied',
+    unnamed: true,
+    voices,
     mode,
-    crowded,
-    identities,
+    crowded: false,
+    identities: 0,
     ms,
     audioSec: Math.round(timeline.durationSec),
-    channels: channelsUsed.size,
+    channels: channelsUsed,
     mapped,
     words: stats,
     excluded,

package/server/lib/nemotron-live.ts

@@ -15,6 +15,7 @@
 //
 // No LLM anywhere. Transcription must never call `claude -p`.
 
+import { isVoiceLabel } from './mac-voice-labels.js'
 import { createHash } from 'node:crypto'
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
 import { homedir, tmpdir } from 'node:os'
@@ -104,7 +105,8 @@ const round = (value: number, places = 2): number => Math.round(value * 10 ** pl
 
 function isRealLabel(label: string): boolean {
   const value = label.trim()
-  return value.length > 0 && value !== 'Unknown' && value !== 'Ext'
+  // 6.90.0: a Mac `Voice N` placeholder is not a name either.
+  return value.length > 0 && value !== 'Unknown' && value !== 'Ext' && !isVoiceLabel(value)
 }
 
 /**

package/server/lib/speaker-embeddings.ts

@@ -376,7 +376,10 @@ export function identifySpeaker(
   expectedSpeakers?: string[],
   /** 6.61.0: `event` tags the calibration rows, e.g. 'nemotron-track' for one
    *  Nemotron track's audio, so they are never read as whole-chunk checks. */
-  options: { event?: string; minSimilarity?: number; prioritizeOwner?: boolean } = {},
+  /** 6.90.0 `shadowEvent`: when the strict floor finds nobody, also log the best
+   *  match at the 0.55 search floor under this event. Calibration only: the
+   *  returned label is unchanged (`Ext`), and nothing is enrolled. */
+  options: { event?: string; minSimilarity?: number; prioritizeOwner?: boolean; shadowEvent?: string } = {},
 ): { speaker: string; similarity: number; embedding?: Float32Array } | null {
   if (!extractor || !manager) return null
   const minimum = Number.isFinite(options.minSimilarity) ? Math.max(0, Math.min(1, options.minSimilarity!)) : 0
@@ -422,6 +425,10 @@ export function identifySpeaker(
     // unidentified voice's vector is the most valuable thing to retain, because
     // naming it later is exactly the correction that has no other evidence.
     logCalibration('Ext', 0, false, options.event)
+    if (options.shadowEvent) {
+      const shadow = shadowBestMatch(manager, embedding)
+      logCalibration(shadow.speaker, shadow.similarity, false, options.shadowEvent)
+    }
     return { speaker: 'Ext', similarity: 0, embedding }
   } catch (err: unknown) {
     console.error('[speaker] Identification error:', errMsg(err))
@@ -829,6 +836,37 @@ function computeCosineSimilarity(_embedding: Float32Array, _name: string): numbe
   return (lo + hi) / 2
 }
 
+/** The subset of the sherpa manager the shadow score needs. */
+export interface ShadowSearchManager {
+  search(query: { v: Float32Array; threshold: number }): string
+  verify(query: { name: string; v: Float32Array; threshold: number }): boolean
+}
+
+/** The floor shadow scoring reports against: the ordinary search floor. */
+export const SHADOW_FLOOR = SEARCH_THRESHOLD
+
+/**
+ * 6.90.0 shadow score for Mac chunks: who the voice would be at the ordinary
+ * 0.55 search floor, and how close. Calibration data only. The caller never
+ * labels, enrols or trains from it. `Ext` with 0 when nobody clears the floor.
+ */
+export function shadowBestMatch(m: ShadowSearchManager, embedding: Float32Array, floor = SHADOW_FLOOR): { speaker: string; similarity: number } {
+  try {
+    const found = m.search({ v: embedding, threshold: floor })
+    if (!found) return { speaker: 'Ext', similarity: 0 }
+    let lo = 0
+    let hi = 1
+    for (let i = 0; i < 10; i++) {
+      const mid = (lo + hi) / 2
+      if (m.verify({ name: found, v: embedding, threshold: mid })) lo = mid
+      else hi = mid
+    }
+    return { speaker: found, similarity: (lo + hi) / 2 }
+  } catch {
+    return { speaker: 'Ext', similarity: 0 }
+  }
+}
+
 /** Log calibration data for threshold tuning */
 function logCalibration(speaker: string, similarity: number, matched: boolean, event?: string): void {
   try {

package/server/lib/tailscale-nudge.ts

@@ -434,10 +434,14 @@ export class TailscaleNudger {
       const t = this.peers.get(ip)
       return !!t && t.lastAuthenticatedAt > 0 && at - t.lastAuthenticatedAt <= L.knownPeerWindowMs
     }
-    const candidates = status.peers
-      .filter(p => p.online && (known(p.ip) || isMobileOs(p.os)))
-      // Already back since the event: nothing to heal.
-      .filter(p => (this.peers.get(p.ip)?.lastRequestAt ?? 0) < pending.firedAt)
+    const eligible = status.peers.filter(p => p.online && (known(p.ip) || isMobileOs(p.os)))
+    // Already back since the event: nothing to heal.
+    const backSince = (p: PeerStatus) => (this.peers.get(p.ip)?.lastRequestAt ?? 0) >= pending.firedAt
+    // 6.90.0: say so once per event, so a quiet log after a wake reads as "the phone came back
+    // on its own", not "the trigger never ran". Trigger and outcome only, never an address.
+    if (eligible.some(backSince)) this.log(`[tailscale-nudge] trigger=${pending.trigger} outcome=already_reconnected`)
+    const candidates = eligible
+      .filter(p => !backSince(p))
       .sort((a, b) => Number(known(b.ip)) - Number(known(a.ip)))
       .slice(0, L.eventMaxPeers)
     for (const peer of candidates) {

package/server/routes/transcribe-stream.ts

@@ -2215,6 +2215,10 @@ async function transcribeWithServerWhisper(audioBuffer: Buffer, whisperAudio: Bu
   }
 }
 
+/** 6.90.0 calibration tags for Mac audio: the whole-chunk shadow score, and one Nemotron track. */
+export const MAC_SHADOW_EVENT = 'mac-shadow'
+export const MAC_TRACK_EVENT = 'mac-nemotron-track'
+
 /** The wearer's label for the 6.61.1 owner guard; null when the profile cannot say. */
 function ownerLabelOrNull(): string | null {
   try { return getOwnerSpeakerLabel() } catch { return null }
@@ -2227,7 +2231,7 @@ function identifyChunkSpeaker(audioBuffer: Buffer, sessionId: string, chunkIndex
   if (!isEmbeddingAvailable() || audioDurationSec < VOICEPRINT_MIN_AUDIO_SEC) return policyLabel({ speaker: clientSpeaker, similarity: 0 }, policy)
 
   const tEmb = performance.now()
-  const embeddingResult = identifySpeaker(audioBuffer, expectedSpeakers, { minSimilarity: policy === 'high-confidence' ? AUTO_ENROLL_THRESHOLD : undefined, ...(MAC_CAPTURE_ID.test(sessionId) ? { prioritizeOwner: false, event: 'mac-system-audio' } : {}) })
+  const embeddingResult = identifySpeaker(audioBuffer, expectedSpeakers, { minSimilarity: policy === 'high-confidence' ? AUTO_ENROLL_THRESHOLD : undefined, ...(MAC_CAPTURE_ID.test(sessionId) ? { prioritizeOwner: false, event: 'mac-system-audio', shadowEvent: MAC_SHADOW_EVENT } : {}) })
   console.log(`[perf] identifySpeaker: ${(performance.now() - tEmb).toFixed(1)}ms`)
   if (!embeddingResult) return policyLabel({ speaker: clientSpeaker, similarity: 0 }, policy)
 
@@ -2537,7 +2541,14 @@ async function processStreamChunk(opts: {
         identify: wav => {
           const policy = capturePolicy
           if (policy === 'anonymous') return { speaker: 'Ext', similarity: 0 }
-          const named = identifySpeaker(wav, undefined, { event: 'nemotron-track', minSimilarity: policy === 'high-confidence' ? AUTO_ENROLL_THRESHOLD : undefined })
+          // 6.90.0: a Mac track is never checked against the wearer first (the wearer
+          // is not in Mac playback) and is tagged so its calibration rows are separable.
+          const mac = MAC_CAPTURE_ID.test(sessionId)
+          const named = identifySpeaker(wav, undefined, {
+            event: mac ? MAC_TRACK_EVENT : 'nemotron-track',
+            minSimilarity: policy === 'high-confidence' ? AUTO_ENROLL_THRESHOLD : undefined,
+            ...(mac ? { prioritizeOwner: false } : {}),
+          })
           return named ? policyLabel({ speaker: named.speaker, similarity: named.similarity }, policy) : null
         },
       })