@gotcos/glasses-server 6.59.0 → 6.61.0

package/server/lib/session-hooks-runtime.ts

@@ -335,6 +335,13 @@ export interface SessionHooksHealth {
   state: HookStatus['state']
   installed: boolean
   scriptSha: string | null
+  /**
+   * 6.60.0: our PermissionRequest hook's `timeout` in the Claude settings file (630 after
+   * Install hooks, 130 on an install from before 6.60.0), or null when it cannot be read.
+   */
+  permissionHookTimeoutS: number | null
+  /** 6.60.0: the only drift is that earlier PermissionRequest wait (`HookStatus.priorWaitOnly`). */
+  priorWaitOnly: boolean
   tokenPresent: boolean
   lastEventAt: string | null
   spoolBacklog: number
@@ -377,6 +384,8 @@ export function sessionHooksHealthFields(): { sessionHooks: SessionHooksHealth }
       state: status.state,
       installed: status.installed,
       scriptSha: status.scriptSha,
+      permissionHookTimeoutS: status.permissionHookTimeoutS,
+      priorWaitOnly: status.priorWaitOnly,
       tokenPresent: status.tokenPresent,
       lastEventAt: newest ? new Date(newest).toISOString() : null,
       spoolBacklog: spool?.backlog ?? 0,
@@ -398,6 +407,14 @@ export function signalFor(sessionId: string): SessionSignal | undefined {
   return sessionId.length >= 36 ? sessionSignalStore.get(sessionId) : sessionSignalStore.getByPrefix(sessionId)
 }
 
+/** 6.60.0: told when a row derives `ended`, so the broker stops saying the Mac is waiting on it. */
+const rowEndedListeners = new Set<(sessionId: string) => void>()
+
+export function onSessionRowEnded(listener: (sessionId: string) => void): () => void {
+  rowEndedListeners.add(listener)
+  return () => { rowEndedListeners.delete(listener) }
+}
+
 /**
  * Derive with the two-scan memory kept here, keyed by full id when known. Rows the
  * caller has no facts for at all get nothing, so an older payload stays byte-identical.
@@ -419,6 +436,11 @@ export function deriveForRow(input: { sessionId: string; registry?: RegistryFact
     prevDeadSince: prev?.since ?? null,
     attachedTurn: input.attachedTurn === true,
   })
+  if (derived.agent_state === 'ended') {
+    for (const listener of rowEndedListeners) {
+      try { listener(key) } catch { /* a listener never breaks a row */ }
+    }
+  }
   // A reader with no registry facts (the live feed derives from the signal alone) must
   // not touch the two-scan memory the row readers keep: a derive that saw no registry
   // would reset a dead pid's count between two list requests.
@@ -431,6 +453,7 @@ export function deriveForRow(input: { sessionId: string; registry?: RegistryFact
 }
 
 export function __resetSessionHooksForTests(): void {
+  rowEndedListeners.clear()
   sessionSignalStore.__resetForTests()
   deadById.clear()
   parentCache.clear()

package/server/lib/speaker-embeddings.ts

@@ -372,6 +372,9 @@ export function enrollEmbedding(name: string, embedding: Float32Array, source: s
 export function identifySpeaker(
   wavBuffer: Buffer,
   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 } = {},
 ): { speaker: string; similarity: number; embedding?: Float32Array } | null {
   if (!extractor || !manager) return null
 
@@ -385,7 +388,7 @@ export function identifySpeaker(
       const isOwner = manager.verify({ name: owner, v: embedding, threshold: VERIFY_THRESHOLD })
       if (isOwner) {
         const similarity = computeCosineSimilarity(embedding, owner)
-        logCalibration(owner, similarity, true)
+        logCalibration(owner, similarity, true, options.event)
         return { speaker: owner, similarity, embedding }
       }
     }
@@ -398,7 +401,7 @@ export function identifySpeaker(
         const matches = manager.verify({ name, v: embedding, threshold: SEARCH_THRESHOLD })
         if (matches) {
           const similarity = computeCosineSimilarity(embedding, name)
-          logCalibration(name, similarity, true)
+          logCalibration(name, similarity, true, options.event)
           return { speaker: name, similarity, embedding }
         }
       }
@@ -408,14 +411,14 @@ export function identifySpeaker(
     const found = manager.search({ v: embedding, threshold: SEARCH_THRESHOLD })
     if (found && found.length > 0) {
       const similarity = computeCosineSimilarity(embedding, found)
-      logCalibration(found, similarity, true)
+      logCalibration(found, similarity, true, options.event)
       return { speaker: found, similarity, embedding }
     }
 
     // No match — external speaker. The embedding still goes back: an
     // 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)
+    logCalibration('Ext', 0, false, options.event)
     return { speaker: 'Ext', similarity: 0, embedding }
   } catch (err: unknown) {
     console.error('[speaker] Identification error:', errMsg(err))

package/server/lib/voiceprint-floor.ts

@@ -0,0 +1,4 @@
+// The least audio the voiceprint names a voice from. One source for the
+// whole-chunk check in transcribe-stream and the per-track check in Nemotron
+// naming, so the two can never drift apart.
+export const VOICEPRINT_MIN_AUDIO_SEC = 2.0

package/server/routes/health.ts

@@ -10,6 +10,8 @@ import { getServerInstanceId } from '../lib/server-instance-id.js'
 import { localFirstMeetingsCapability } from '../lib/local-first-meetings-contract.js'
 import { isSileroAvailable } from '../lib/vad-silero.js'
 import { profileProvenanceSummary, speakerModelState, speakerReadiness } from '../lib/speaker-embeddings.js'
+import { nemotronLive } from '../lib/nemotron-live.js'
+import { finalPassSnapshot } from '../lib/nemotron-final.js'
 import { chunkEmbeddingStoreStats } from '../lib/chunk-embedding-store.js'
 import { mintDisplayTicket, DISPLAY_TICKET_TTL_SECONDS } from '../lib/display-ticket.js'
 import { correctionStoreStats } from '../lib/meeting-corrections.js'
@@ -336,6 +338,14 @@ healthRouter.get('/health', async (_req, res) => {
     // Asserted, not merely reported: `speaker_id` above says what the state IS,
     // this says whether that state is acceptable.
     speakerId: speakerReadinessState,
+    // 6.61.0: what is labelling chunks RIGHT NOW. `active` reads `nemotron` only
+    // while the model is warm, the breaker is closed and most of the last five
+    // chunks really were labelled by Nemotron; otherwise `warming` or `embedding`
+    // with the reason. Plus the per-chunk outcome counts since start and the last
+    // save-time final pass, as codes and counts only: this route is public and
+    // must never carry a speaker name, a path or raw error text. A Nemotron
+    // fallback is the designed voiceprint path, so it never degrades `status`.
+    diarizer: { ...nemotronLive.snapshot(), final: finalPassSnapshot() },
   }
   const openai_whisper_budget = getOpenAIWhisperBudgetState()
   const meeting_summary = {

package/server/routes/meeting.ts

@@ -160,6 +160,10 @@ import {
   type MeetingFinalizationJob,
 } from '../lib/meeting-finalization-jobs.js'
 import { enrichStandaloneMeeting } from '../lib/meeting-summary-persistence.js'
+import { recordFinalPassSkip, runNemotronFinalPass, type FinalPassOptions, type FinalPassOutcome } from '../lib/nemotron-final.js'
+
+/** 6.61.0: the save-time Nemotron pass. Injectable so tests never spawn the CLI. */
+export type FinalDiarize = (options: Pick<FinalPassOptions, 'meetingPath' | 'sidecarPath' | 'audioDir'>) => Promise<FinalPassOutcome>
 
 function cosOpsPipelineConfigured(): boolean {
   // Read env live (not the module-load COS_SCRIPTS_DIR const) so unit tests that
@@ -200,6 +204,7 @@ export interface MeetingRouteDependencies {
   scheduleBackground?: (task: Promise<void>) => void
   emit?: typeof emitDisplay
   finalizationJobs?: MeetingFinalizationJobStore
+  finalDiarize?: FinalDiarize
 }
 
 const activeFinalizationJobs = new Set<string>()
@@ -210,6 +215,7 @@ interface FinalizationRuntime {
   runBatch: NonNullable<MeetingRouteDependencies['runBatch']>
   scheduleBackground: (task: Promise<void>) => void
   sessions?: MeetingSessionSource
+  finalDiarize?: FinalDiarize
 }
 
 function validReplayEntries(raw: unknown[]): IndexedTranscriptChunk[] | null {
@@ -311,6 +317,7 @@ function scheduleFinalizationJob(job: MeetingFinalizationJob, runtime: Finalizat
           sidecarPath: current.sidecarPath,
           sessionId: current.sessionId,
           runBatch: runtime.runBatch,
+          finalDiarize: runtime.finalDiarize ?? runNemotronFinalPass,
         })
       } else {
         console.warn(`[meeting/save] Pending HQ audio missing for ${current.sessionId}; preserving streaming canonical`)
@@ -469,6 +476,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
   const scheduleBackground = deps.scheduleBackground ?? (task => { void task })
   const emit = deps.emit ?? emitDisplay
   const finalizationJobs = deps.finalizationJobs ?? new MeetingFinalizationJobStore()
+  const finalDiarize = deps.finalDiarize ?? runNemotronFinalPass
   const router = Router()
   const savingSessions = new Set<string>()
   setNamingSessionLiveness(id => sessions.getStartTime(id) !== null || savingSessions.has(id) || activeFinalizationJobs.has(id))
@@ -553,6 +561,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
           runBatch,
           scheduleBackground,
           sessions,
+          finalDiarize,
         })
         res.set('Cache-Control', 'private, no-store')
         res.json(publicSaveResponse(alreadySaved, true))
@@ -717,6 +726,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
           runBatch,
           scheduleBackground,
           sessions,
+          finalDiarize,
         })
       }
     } catch (error) {
@@ -797,6 +807,25 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     }
   }
 
+  /**
+   * 6.61.0 (QA W2): refuse a correction while the meeting is finalizing.
+   *
+   * The Nemotron final pass rewrites the sidecar and the transcript inside the
+   * finalization job, after a CLI run of tens of seconds. A relabel or a
+   * deattribution landing in that window would race it (the pass also re-reads
+   * both files and stands down, but the edit and the pass should not interleave
+   * at all). Same rule held naming uses: while a finalization job exists for the
+   * session the answer is 409, and a retry after it finishes works.
+   */
+  function finalizingRefusal(sessionId: string): { status: number; body: Record<string, unknown> } | null {
+    const running = [...activeFinalizationJobs].some(key => key.endsWith(`:${sessionId}`))
+    if (!running && !finalizationJobs.get(sessionId)) return null
+    return {
+      status: 409,
+      body: { error: 'Meeting is finalizing; retry after it finishes', reason: 'meeting_finalizing', retryable: true },
+    }
+  }
+
   // ── Speaker review (6.21.12) ──────────────────────────────────────────
   // Backs COS Control's naming panel. Read-only: it reports what a saved
   // meeting's sidecar already contains and never writes. Naming, merging, and
@@ -1191,7 +1220,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     // A merged G2 session is NOT refused here: it is a real capture with real
     // audio, and relabelling it is how its profile gets better. Only an imported
     // or derived IDENTITY is refused.
-    const evidenceRefusal = assertVoiceEvidenceSource([sessionId]) ?? refuseDerivedMutation(req.body?.recordId)
+    const evidenceRefusal = assertVoiceEvidenceSource([sessionId]) ?? refuseDerivedMutation(req.body?.recordId) ?? finalizingRefusal(sessionId)
     if (evidenceRefusal) {
       res.status(evidenceRefusal.status).json(evidenceRefusal.body)
       return
@@ -1525,7 +1554,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
       res.status(400).json({ error: 'Invalid sessionId', reason: 'invalid_session_id' })
       return
     }
-    const evidenceRefusal = assertVoiceEvidenceSource([sessionId]) ?? refuseDerivedMutation(req.body?.recordId)
+    const evidenceRefusal = assertVoiceEvidenceSource([sessionId]) ?? refuseDerivedMutation(req.body?.recordId) ?? finalizingRefusal(sessionId)
     if (evidenceRefusal) {
       res.status(evidenceRefusal.status).json(evidenceRefusal.body)
       return
@@ -2194,6 +2223,7 @@ async function finalizeBatch(options: {
   sidecarPath: string
   sessionId?: string
   runBatch: NonNullable<MeetingRouteDependencies['runBatch']>
+  finalDiarize?: FinalDiarize
 }): Promise<void> {
   const result = await options.runBatch(
     options.audioDir,
@@ -2236,6 +2266,29 @@ async function finalizeBatch(options: {
     )
   }
 
+  // 6.61.0: the Nemotron final pass relabels the transcript just persisted,
+  // while the raw chunk audio still exists and BEFORE this job reaches
+  // ops_pending, so COS sync (sync_meetings.py --g2-import-file, run by the
+  // handoff after this function returns) only ever imports the relabelled
+  // meeting. It never throws and writes nothing unless every word survives;
+  // on any failure the meeting stays exactly as saved above.
+  // Skipped when the batch text landed but its sidecar did not: the two would
+  // disagree about which transcript is canonical. Counted and logged like any
+  // other skip, so health shows it.
+  if (options.finalDiarize && transcriptApplied && !metadataPersisted) {
+    recordFinalPassSkip('metadata_not_persisted', 'the batch transcript was applied but its sidecar was not written')
+  } else if (options.finalDiarize) {
+    try {
+      await options.finalDiarize({
+        meetingPath: options.meetingPath,
+        sidecarPath: options.sidecarPath,
+        audioDir: options.audioDir,
+      })
+    } catch (error) {
+      console.warn(`[diarizer] final pass threw; the saved transcript is unchanged: ${error instanceof Error ? error.message : String(error)}`)
+    }
+  }
+
   if (canDeletePendingBatchAudio(transcriptApplied, metadataPersisted)) {
     rmSync(options.audioDir, { recursive: true, force: true })
   } else {

package/server/routes/permission-broker.ts

@@ -25,6 +25,10 @@
 // so a surface that only shows a count can poll without making the Mac hold questions it
 // cannot answer. It checks X-Cos-Token itself as well, in constant time, and a request
 // without it is refused and never counted, whatever sits in front of this router.
+// 6.60.0: a poll with `&hold=1&presenceAgeMs=<int>` (COS Glasses 6.9.563 and later) records
+// wearer presence for the away hold instead of the 6.59.0 liveness; a `hold=1` poll without
+// a valid `presenceAgeMs` makes no client live and enables no hold. The response adds
+// `awayHoldMs`, `awayRecentClientMs`, `settled`, `waitingAtMac` and `serverStartedAt`.
 
 import express, { Router, type NextFunction, type Request, type Response } from 'express'
 import { timingSafeTokenEqual } from '../lib/token-auth.js'
@@ -37,7 +41,7 @@ import {
   type HookReplyChannel,
   type PermissionBroker,
 } from '../lib/permission-broker.js'
-import { noteQuestionsPoll } from '../lib/client-liveness.js'
+import { noteQuestionsPoll, validPresenceAgeMs, type QuestionsPollFacts } from '../lib/client-liveness.js'
 
 export const PERMISSION_BROKER_HOOK_PATH = '/api/permission-requests/ask'
 /** The hook posts its spool envelope, capped at 1 MiB by the script itself. */
@@ -133,8 +137,26 @@ export interface SessionQuestionsRouterDeps {
   /** The pairing token (X-Cos-Token). A poll counts as a live client only with it. */
   apiToken: () => string
   /** Where a counted poll is recorded; `noteQuestionsPoll` in production. */
-  notePoll?: (at: number) => void
+  notePoll?: (at: number, poll: QuestionsPollFacts) => void
   now?: () => number
+  /** 6.60.0: when this server process started (ISO); defaults to the process's own start. */
+  serverStartedAt?: string
+}
+
+/** 6.60.0: this process's start, so a client can tell a restart from "nothing waiting". */
+export const SERVER_STARTED_AT = new Date(Date.now() - Math.round(process.uptime() * 1000)).toISOString()
+
+/**
+ * 6.60.0, the contract shared with COS Glasses 6.9.563: `hold=1` (this client shows held
+ * questions) and `presenceAgeMs`, a whole number of ms within [0, 24 h] since the latest real
+ * wearer evidence. Anything else is no presence: the poll then counts only as a 6.59.0 poll
+ * (without `hold=1`) or as a `hold=1` poll with no presence.
+ */
+export function questionsPollFacts(query: Record<string, unknown>): QuestionsPollFacts {
+  const hold = query.hold === '1'
+  const raw = typeof query.presenceAgeMs === 'string' ? query.presenceAgeMs : ''
+  const parsed = /^\d{1,8}$/.test(raw) ? Number(raw) : Number.NaN
+  return { hold, presenceAgeMs: hold && validPresenceAgeMs(parsed) ? parsed : null }
 }
 
 export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps): Router {
@@ -152,7 +174,7 @@ export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps):
     }
     // Only a client that says it can answer (and shows the cards) counts as live.
     const client = typeof req.query.client === 'string' ? req.query.client : ''
-    if (ANSWERING_CLIENTS.has(client)) notePoll(now())
+    if (ANSWERING_CLIENTS.has(client)) notePoll(now(), questionsPollFacts(req.query as Record<string, unknown>))
     const health = deps.broker.health()
     // Listed first: a deadline the timer has not caught yet is settled by the listing.
     const items = deps.broker.list()
@@ -165,6 +187,18 @@ export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps):
       pending: deps.broker.pendingCount(),
       stats: deps.broker.stats(),
       items,
+      // 6.60.0, additive: the away hold now (0 when off) and the recent-client window it needs,
+      // recently settled items (codes and times only, newest first), and how many of them the
+      // Mac's own dialog still waits on.
+      awayHoldMs: health.enabled ? deps.broker.awayHoldNowMs() : 0,
+      awayRecentClientMs: health.enabled && deps.broker.awayHoldNowMs() > 0 ? deps.broker.awayRecentClientWindowMs() : 0,
+      settled: deps.broker.settledList(),
+      waitingAtMac: deps.broker.waitingAtMacCount(),
+      serverStartedAt: deps.serverStartedAt ?? SERVER_STARTED_AT,
+      // 6.60.0 (Ghost Hunter W1): a waiting entry settled at or before this time may have been
+      // forgotten (the server started then, or dropped it while it still waited). Missing from
+      // `settled` and settled after it: the session moved past it.
+      waitingAtMacForgottenBefore: new Date(deps.broker.waitingAtMacForgottenBeforeMs()).toISOString(),
     })
   })
   router.post('/session-questions/:id/answer', (req: Request, res: Response) => {

package/server/routes/transcribe-stream.ts

@@ -40,6 +40,8 @@ import { transcribeLocal, applyCorrections, type WhisperWord } from '../lib/whis
 import { enhanceAudio } from '../lib/audio-enhance.js'
 import { trimSilence, isSileroAvailable } from '../lib/vad-silero.js'
 import { identifySpeaker, isEmbeddingAvailable, autoEnroll, AUTO_ENROLL_CANDIDATE_SIMILARITY } from '../lib/speaker-embeddings.js'
+import { nemotronLive, resolveLiveLabels, resplitSegments, type ChunkSpeakerSegment } from '../lib/nemotron-live.js'
+import { VOICEPRINT_MIN_AUDIO_SEC } from '../lib/voiceprint-floor.js'
 import {
   assertOpenAIWhisperBudget,
   recordOpenAIWhisperUsage,
@@ -266,6 +268,23 @@ export interface TranscriptChunk {
   audioSha256?: string
   canonical?: boolean
   evenHubSpeakerRole?: EvenSpeakerRoleHistogram
+  /** 6.61.0: who spoke when inside this chunk, in time order. Present when
+   *  Nemotron separated the chunk's voices; `speaker` is then the dominant name. */
+  segments?: ChunkSpeakerSegment[]
+  /** 6.61.0: which path labelled the chunk. Absent when COS_DIARIZER selects the voiceprint. */
+  diarizer?: ChunkDiarizerInfo
+}
+
+export interface ChunkDiarizerInfo {
+  engine: 'nemotron' | 'voiceprint'
+  /** Why Nemotron did not label this chunk although it was requested. */
+  fallback?: string
+  /** The whole-chunk voiceprint label, kept when the dominant track's name differs. */
+  voiceprintSpeaker?: string
+  voiceprintSimilarity?: number
+  tracks?: number
+  timing?: 'words' | 'estimated'
+  ms?: number
 }
 
 export interface ProviderCandidateRecord {
@@ -345,6 +364,9 @@ interface StreamChunkCompletionResponse {
   backend?: string
   asrProvider?: string
   fallbackReason?: string
+  /** 6.61.0, additive: the chunk's speaker turns in time order. Their texts
+   *  joined with one space equal `text`; `speaker` stays the dominant name. */
+  segments?: ChunkSpeakerSegment[]
 }
 
 const closedSessionRecords = new Map<string, ClosedTranscriptSession>()
@@ -772,6 +794,12 @@ function recoverSessions(): void {
                 const stripped = stripInlineHallucinations(chunk.text, data.sessionId)
                 if (stripped !== chunk.text) {
                   chunk.text = stripped
+                  // 6.61.0: the stored turns must still join to the text.
+                  if (chunk.segments) {
+                    const refit = resplitSegments(chunk.segments, stripped)
+                    if (refit?.length) chunk.segments = refit
+                    else delete chunk.segments
+                  }
                   cleaned++
                 }
               }
@@ -1837,6 +1865,7 @@ function canonicalChunkResponse(
     backend: existing.backend,
     asrProvider: existing.asrProvider,
     fallbackReason: existing.fallbackReason,
+    ...(existing.segments?.length ? { segments: existing.segments } : {}),
   }
 }
 
@@ -1882,7 +1911,7 @@ async function transcribeWithServerWhisper(audioBuffer: Buffer, whisperAudio: Bu
 function identifyChunkSpeaker(audioBuffer: Buffer, sessionId: string, chunkIndex: number, clientSpeaker: string): { speaker: string; similarity: number } {
   const expectedSpeakers = undefined
   const audioDurationSec = Math.max(0, (audioBuffer.length - 44)) / 32000
-  if (!isEmbeddingAvailable() || audioDurationSec < 2.0) return { speaker: clientSpeaker, similarity: 0 }
+  if (!isEmbeddingAvailable() || audioDurationSec < VOICEPRINT_MIN_AUDIO_SEC) return { speaker: clientSpeaker, similarity: 0 }
 
   const tEmb = performance.now()
   const embeddingResult = identifySpeaker(audioBuffer, expectedSpeakers)
@@ -2033,6 +2062,15 @@ async function processStreamChunk(opts: {
   recordReceivedChunk(session, chunkIndex)
   persistSessionRequired(sessionId)
 
+  // 6.61.0: Nemotron reads the durable WAV just written, in parallel with
+  // Whisper, on the Neural Engine, inside its own budget. It is started before
+  // the synchronous voiceprint so the process is already running while that
+  // blocks. diarize() never throws; a fallback returns a reason.
+  const diarizeStartedAt = performance.now()
+  const diarizePromise = nemotronLive.diarize(
+    resolve(SESSION_AUDIO_DIR, sessionId, `chunk_${String(chunkIndex).padStart(4, '0')}.wav`),
+  )
+
   const pcmData = audioBuffer.subarray(44)
   let sumSq = 0
   const nSamples = Math.floor(pcmData.length / 2)
@@ -2090,14 +2128,14 @@ async function processStreamChunk(opts: {
     sanitized = sanitizeStreamTranscript(sessionId, session, rawText, isQuiet)
   }
 
-  const { speaker, similarity } = await speakerPromise
+  const voiceprint = await speakerPromise
   if (evenHubSpeakerRole) {
     console.log(formatEvenRoleAgreement({
       chunkIndex,
       even: evenHubSpeakerRole,
       amp: clientSpeaker,
-      emb: speaker,
-      similarity,
+      emb: voiceprint.speaker,
+      similarity: voiceprint.similarity,
     }))
   }
   // Client time is authoritative for live network jitter and deferred replay.
@@ -2106,6 +2144,26 @@ async function processStreamChunk(opts: {
     : Date.now() - session.startTime
   const trimmedText = sanitized.text
 
+  // Nemotron separates the voices; the voiceprint names each one. Any fallback
+  // keeps today's whole-chunk voiceprint label. Only chunks with text count.
+  const labels = trimmedText
+    ? await resolveLiveLabels({
+        diarize: diarizePromise,
+        startedAt: diarizeStartedAt,
+        text: trimmedText,
+        words,
+        audio: audioBuffer,
+        voiceprint,
+        clientSpeaker,
+        identify: wav => {
+          const named = identifySpeaker(wav, undefined, { event: 'nemotron-track' })
+          return named ? { speaker: named.speaker, similarity: named.similarity } : null
+        },
+      })
+    : { speaker: voiceprint.speaker, similarity: voiceprint.similarity }
+  if (labels.record) nemotronLive.record({ sessionId, chunkIndex }, labels.record)
+  const { speaker, similarity } = labels
+
   if (!trimmedText) {
     console.log(`[hallucination] Filtered (${sanitized.fallbackReason || fallbackReason || 'empty'}): "${rawText.slice(0, 60)}"`)
     if (candidate && candidateRecordKey && session.providerCandidates?.[candidateRecordKey]) {
@@ -2145,6 +2203,8 @@ async function processStreamChunk(opts: {
     audioSha256,
     canonical: true,
     evenHubSpeakerRole,
+    ...(labels.segments?.length ? { segments: labels.segments } : {}),
+    ...(labels.diarizer ? { diarizer: labels.diarizer } : {}),
   }
   const finalExisting = session.chunks[chunkIndex]
   if (finalExisting?.text) {
@@ -2174,7 +2234,10 @@ async function processStreamChunk(opts: {
 
   scheduleSessionProgressiveHq(sessionId)
 
-  emitDisplay({ type: 'transcript_chunk', data: { text: trimmedText, speaker, chunkIndex, elapsed, sessionId } })
+  emitDisplay({
+    type: 'transcript_chunk',
+    data: { text: trimmedText, speaker, chunkIndex, elapsed, sessionId, ...(chunk.segments ? { segments: chunk.segments } : {}) },
+  })
   // Live Cues feed — fire-and-forget, NEVER awaited: transcription must not
   // block on a cue, and no LLM runs on this path. .catch() is required — a
   // bare `void` on a rejecting promise is an unhandled rejection, which Node