@gotcos/glasses-server 6.95.0 → 6.98.1

package/server/lib/speaker-shadow.ts

@@ -46,7 +46,9 @@ import { Transform } from 'node:stream'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 import { durableAtomicWriteFileSync } from './atomic-fs.js'
 import { MAC_CAPTURE_ID } from './mac-recording.js'
-import { maintenanceLifecycle } from './maintenance-lifecycle.js'
+import { maintenanceLifecycle,acquireMaintenanceWork } from './maintenance-lifecycle.js'
+import {configureMacSpeakerCallProducer,macSpeakerCallProducerEnabled,macSpeakerCallProducerBusy,macSpeakerCallProducerRequestValid,notifyMacSpeakerCallNativeExport,sampleMacSpeakerCallResources} from './mac-speaker-call-producer.js'
+import type {MacSpeakerCallProducerRequest} from './mac-speaker-call-producer-worker.js'
 import { installedCliIntact, installedCliTrust, parakeetCliPath, parakeetInstalled, SANDBOX_EXEC } from './parakeet.js'
 import { SHADOW_GATES } from './speaker-shadow-decide.js'
 import { shadowModelsPresent, speakerShadowHome, speakerShadowModelsDir, speakerShadowRoot } from './speaker-shadow-models.js'
@@ -148,15 +150,16 @@ export interface SpeakerShadowRecord {
   status: SpeakerShadowStatus
   reason: string | null
   detail: string | null
-  gates: { majority: number; minCoveredFraction: number; floorSeconds: number; outlier: string; anchorRatioPostHocColumnOnly: number }
+  gates: { majority: number; minCoveredFraction: number; floorSeconds: number; outlier: string; anchorRatioMax: number }
   facts?: ShadowRunFacts
+  paired?: Extract<ShadowJobOutcome, { status: 'proposed' }>['paired']
   proposals?: ShadowProposals
   resources?: { wallMs: number; peakRssBytes: number | null; cliTrust: string | null }
   /** The readable report, relative to <data>/speaker-shadow/ (reports/<day>/<title>__<session>.md). */
   report?: string | null
 }
 
-const GATES_RECORD = { majority: SHADOW_GATES.majority, minCoveredFraction: SHADOW_GATES.minCoveredFraction, floorSeconds: SHADOW_GATES.floorSeconds, outlier: 'leave-fragment-out cluster p95', anchorRatioPostHocColumnOnly: SHADOW_GATES.anchorRatioPostHoc }
+const GATES_RECORD = { majority: SHADOW_GATES.majority, minCoveredFraction: SHADOW_GATES.minCoveredFraction, floorSeconds: SHADOW_GATES.floorSeconds, outlier: 'leave-fragment-out cluster p95', anchorRatioMax: SHADOW_GATES.anchorRatioMax }
 
 /** Append one record: the whole file is rewritten to a temp file, fsynced and renamed, so a reader never sees half a line. */
 export async function appendSpeakerShadowRecord(root: string, record: SpeakerShadowRecord): Promise<void> {
@@ -203,7 +206,7 @@ export async function readSpeakerShadowRecords(root: string, options: { limit?:
 
 // ── State ────────────────────────────────────────────────────────────────────
 
-interface QueueItem { sessionId: string; sidecarPath: string; labelsHash: string | null; enqueuedAt: number }
+interface QueueItem { sessionId: string; sidecarPath: string; labelsHash: string | null; enqueuedAt: number;producerRequest?:MacSpeakerCallProducerRequest }
 interface ShadowState {
   schema: 1
   day: string
@@ -245,6 +248,7 @@ export interface SpeakerShadowDeps {
   spawnWorker: () => ChildProcess
   /** Resident bytes of the process group led by pid, or null when it cannot be read. */
   sampleRss: (pgid: number) => Promise<number | null>
+  producerResources:typeof sampleMacSpeakerCallResources
   killGroup: (pgid: number) => void
   log: (line: string) => void
   setTimer: (fn: () => void, ms: number) => { unref?: () => void }
@@ -338,6 +342,7 @@ export function defaultSpeakerShadowDeps(): SpeakerShadowDeps {
     tmpRoot: tmpdir(),
     spawnWorker: defaultSpawnWorker,
     sampleRss: defaultSampleRss,
+    producerResources:sampleMacSpeakerCallResources,
     killGroup: pgid => { try { process.kill(-pgid, 'SIGKILL') } catch { /* gone */ } },
     log: line => console.log(`[speaker-shadow] ${line}`),
     setTimer: (fn, ms) => setTimeout(fn, ms),
@@ -351,7 +356,7 @@ type Supervised = ShadowJobOutcome | { status: 'deferred'; reason: string } | {
 
 export class SpeakerShadowRunner {
   private readonly deps: SpeakerShadowDeps
-  private running: { sessionId: string; pgid: number | null } | null = null
+  private running: { sessionId: string; pgid: number | null;producerRequest?:MacSpeakerCallProducerRequest } | null = null
   private pumping = false
   private timer: { unref?: () => void } | null = null
   private deferredReason: string | null = null
@@ -362,6 +367,20 @@ export class SpeakerShadowRunner {
   }
 
   enabled(): boolean { return speakerShadowEnabled(this.deps.env(), this.deps.root()) }
+  nativeEnabled():boolean{return this.enabled()||macSpeakerCallProducerEnabled(this.deps.env())}
+  nativeRunning():boolean{return this.running!==null}
+  async notifyConsumerFinalized(request:MacSpeakerCallProducerRequest):Promise<void> {
+    if(!macSpeakerCallProducerEnabled(this.deps.env())||!macSpeakerCallProducerRequestValid(request))throw Error('independent_consumer_request_invalid_or_disabled')
+    if(this.running?.sessionId===request.captureId){
+      const admitted=this.running.producerRequest
+      if(!admitted)throw Object.assign(Error('native_active_without_prenative_provenance'),{code:'MAC_CALL_NATIVE_PENDING'})
+      if(admitted.policySHA256!==request.policySHA256||admitted.root!==request.root)throw Object.assign(Error('native_running_other_policy'),{code:'MAC_CALL_NATIVE_UNAVAILABLE'})
+      // seedReady already durably registered this exact copy. The one
+      // admitted execution will fan out only fresh per-copy CAS publications.
+      return
+    }
+    await this.enqueue({sessionId:request.captureId,sidecarPath:request.sidecarPath},request)
+  }
 
   switchState(): { enabled: boolean; source: SpeakerShadowSwitchSource } { return resolveSpeakerShadowSwitch(this.deps.env(), this.deps.root()) }
 
@@ -403,13 +422,15 @@ export class SpeakerShadowRunner {
     }
   }
 
-  private async enqueue(input: { sessionId: string; sidecarPath: string }): Promise<void> {
+  private async enqueue(input: { sessionId: string; sidecarPath: string },producerRequest?:MacSpeakerCallProducerRequest): Promise<void> {
     let labelsHash: string | null = null
     try { labelsHash = shadowLabelsHash(shadowEntries(JSON.parse(await readFile(input.sidecarPath, 'utf8')))) } catch { /* the worker reports the sidecar */ }
     // Read, change and write with no await in between: the pump also rewrites this file.
     const state = this.readState()
-    if (state.done.includes(input.sessionId) || state.queue.some(q => q.sessionId === input.sessionId)) return
-    state.queue.push({ sessionId: input.sessionId, sidecarPath: input.sidecarPath, labelsHash, enqueuedAt: this.deps.now() })
+    if (state.done.includes(input.sessionId)) {if(producerRequest)throw Object.assign(Error('native_already_completed_without_retained_export'),{code:'MAC_CALL_NATIVE_UNAVAILABLE'});return}
+    const existing=state.queue.find(q=>q.sessionId===input.sessionId)
+    if(existing){if(producerRequest){existing.producerRequest=producerRequest;this.writeState(state)}return}
+    state.queue.push({ sessionId: input.sessionId, sidecarPath: input.sidecarPath, labelsHash, enqueuedAt: this.deps.now(),...(producerRequest?{producerRequest}:{}) })
     const dropped = state.queue.splice(0, Math.max(0, state.queue.length - MAX_QUEUE))
     for (const item of dropped) state.done.push(item.sessionId)
     this.writeState(state)
@@ -421,7 +442,7 @@ export class SpeakerShadowRunner {
   /** Boot: pick up meetings a previous process queued but never ran. */
   resume(): void {
     try {
-      if (!this.enabled() || !existsSync(this.statePath())) return
+      if (!this.nativeEnabled() || !existsSync(this.statePath())) return
       if (this.readState().queue.length) void this.pump()
     } catch (error) { this.deps.log(`resume failed: ${describe(error)}`) }
   }
@@ -472,14 +493,17 @@ export class SpeakerShadowRunner {
     this.pumping = true
     try {
       for (;;) {
-        if (!this.enabled()) return
+        if (!this.nativeEnabled()) return
+        if(macSpeakerCallProducerBusy()){this.schedule(DEFER_RETRY_MS,'independent_consumer');return}
         const state = this.readState()
         const item = state.queue[0]
         if (!item) { this.deferredReason = null; return }
         const now = this.deps.now()
         const finish = async (status: SpeakerShadowStatus, reason: string | null, detail: string | null, extra: Partial<SpeakerShadowRecord> = {}, report?: { title: string; markdown: string }) => {
-          const reportPath = await this.writeReport(item, status, reason, detail, report)
-          await this.record(item, status, reason, detail, { ...extra, report: reportPath })
+          if(this.enabled()){
+            const reportPath = await this.writeReport(item, status, reason, detail, report)
+            await this.record(item, status, reason, detail, { ...extra, report: reportPath })
+          }
           const next = this.readState()
           next.queue = next.queue.filter(q => q.sessionId !== item.sessionId)
           next.done.push(item.sessionId)
@@ -511,9 +535,21 @@ export class SpeakerShadowRunner {
         if (!this.deps.modelsPresent(modelsDir)) { await finish('skipped', 'models_missing', 'the pinned speaker-diarization models are not on this Mac (the server never downloads them)'); continue }
         const audioDir = this.deps.audioDirFor(item.sessionId)
         if (!existsSync(audioDir)) { await finish('skipped', 'audio_missing', 'no retained chunk audio for this meeting'); continue }
+        let producerRequest=macSpeakerCallProducerEnabled(this.deps.env())?item.producerRequest:undefined
+        if(producerRequest&&(!macSpeakerCallProducerRequestValid(producerRequest)||producerRequest.captureId!==item.sessionId||producerRequest.sidecarPath!==item.sidecarPath)){await finish('skipped','bad_sidecar','untrusted independent consumer request');continue}
+        if(!this.enabled()&&!producerRequest)return
+        const resourceStart=producerRequest?await this.deps.producerResources().catch(()=>null):null
+        if(producerRequest&&(!resourceStart||resourceStart.availableBytes<16*1024**3)){this.schedule(DEFER_RETRY_MS,'producer_resource_admission');return}
+        if(this.deps.captureActive()||!this.deps.admissionsOpen()||!this.nativeEnabled())return
+        if(macSpeakerCallProducerBusy()){this.schedule(DEFER_RETRY_MS,'independent_consumer');return}
 
         // Fresh read: the awaits above let an enqueue rewrite the file since `state` was read.
         const counted = this.readState()
+        // A shared request may have joined while CLI/model checks awaited. Do
+        // not start a log-only execution that strands its admitted consumer.
+        const latest=counted.queue.find(q=>q.sessionId===item.sessionId)?.producerRequest
+        if(!producerRequest&&latest){this.schedule(0,'consumer_joined');return}
+        if(producerRequest&&JSON.stringify(latest)!==JSON.stringify(producerRequest)){this.schedule(0,'consumer_request_changed');return}
         counted.runsToday += 1
         this.writeState(counted)
         this.deferredReason = null
@@ -521,6 +557,7 @@ export class SpeakerShadowRunner {
           sessionId: item.sessionId, sidecarPath: item.sidecarPath, audioDir, expectedLabelsHash: item.labelsHash,
           cliPath: cli.path, cliSha256: cli.sha256, sandboxExec: this.deps.sandboxExec, modelsDir,
           homeDir: this.deps.homeDir(), tmpRoot: this.deps.tmpRoot, cliTimeoutMs: Math.max(5_000, limits.timeoutMs - 5_000),
+          ...(producerRequest?{callProducer:producerRequest,shadowLogRequested:this.enabled(),callProducerSwapStart:resourceStart!.swapBytes}:{}),
         }
         this.deps.log(`start ${item.sessionId}`)
         const started = this.deps.now()
@@ -536,9 +573,20 @@ export class SpeakerShadowRunner {
           return
         }
         if (outcome.status === 'proposed') {
+          if (producerRequest && !outcome.callProducerExport) {
+            // Native ran once: preserve terminal done/history, never re-infer to
+            // manufacture missing pre-native provenance. Expose the consumer
+            // failure even when legacy shadow logging is disabled.
+            const detail = outcome.callProducerFailure
+              ? `${outcome.callProducerFailure.stage}: ${outcome.callProducerFailure.reason}`
+              : 'admitted native completed without a retained export'
+            await finish('failed', 'consumer_export_failed', detail.slice(0, 300), { facts: outcome.facts, proposals: outcome.proposals, paired: outcome.paired, resources }, outcome.report)
+            continue
+          }
+          if(outcome.callProducerExport&&macSpeakerCallProducerEnabled(this.deps.env()))notifyMacSpeakerCallNativeExport(outcome.callProducerExport)
           const f = outcome.facts
           const markdown = `${outcome.report.markdown}\n${renderShadowRunFacts({ rebuildMs: f.timing.rebuildMs, nativeMs: f.timing.nativeMs, wallMs: resources.wallMs, peakRssBytes: resources.peakRssBytes, osTempDirsLeft: f.osTempDirsLeft, sidecarPath: item.sidecarPath, pcmSHA256: f.timelinePCMSHA256, cliTrust: cli.trust })}`
-          await finish('proposed', null, null, { facts: outcome.facts, proposals: outcome.proposals, resources }, { title: outcome.report.title, markdown })
+          await finish('proposed', null, null, { facts: outcome.facts, proposals: outcome.proposals, paired: outcome.paired, resources }, { title: outcome.report.title, markdown })
         }
         else await finish(outcome.status, outcome.reason, outcome.detail, { resources })
       }
@@ -551,28 +599,38 @@ export class SpeakerShadowRunner {
 
   private supervise(job: ShadowJob, limits: SpeakerShadowLimits): Promise<{ outcome: Supervised; peakRss: number | null }> {
     return new Promise(resolvePromise => {
+      let producerLease:ReturnType<typeof acquireMaintenanceWork>|null=null
       let child: ChildProcess
-      try { child = this.deps.spawnWorker() } catch (error) {
+      try {if(job.callProducer)producerLease=acquireMaintenanceWork('mac_speaker_call');child = this.deps.spawnWorker() } catch (error) {
+        producerLease?.release()
         resolvePromise({ outcome: { status: 'failed', reason: 'worker_spawn_failed', detail: describe(error) }, peakRss: null })
         return
       }
       const pgid = child.pid ?? null
-      this.running = { sessionId: job.sessionId, pgid }
+      this.running = { sessionId: job.sessionId, pgid,...(job.callProducer?{producerRequest:job.callProducer}:{}) }
       this.installExitHook()
       if (pgid) { try { setPriority(pgid, 10) } catch { /* runs at normal priority */ } }
       const started = this.deps.now()
       let stdout = '', stderr = '', verdict: Supervised | null = null, peak: number | null = null, sampling = false, settled = false
+      let swapStart:number|null=job.callProducerSwapStart??null
       const stop = (outcome: Supervised) => { if (!verdict) verdict = outcome; if (pgid) this.deps.killGroup(pgid) }
       const tick = setInterval(() => {
         if (verdict) return
         if (this.deps.now() - started > limits.timeoutMs) { stop({ status: 'failed', reason: 'timeout', detail: `no result within ${limits.timeoutMs} ms` }); return }
-        if (!this.enabled()) { stop({ status: 'deferred', reason: 'switched_off' }); return }
+        if (!this.nativeEnabled()||job.callProducer&&!macSpeakerCallProducerEnabled(this.deps.env())) { stop({ status: 'deferred', reason: 'switched_off' }); return }
         if (this.deps.captureActive?.() || !this.deps.admissionsOpen()) { stop({ status: 'deferred', reason: 'capture_live' }); return }
         if (!pgid || sampling) return
         sampling = true
+        if(job.callProducer)void this.deps.producerResources().catch(()=>null).then(r=>{
+          if(settled||verdict)return
+          if(!r||r.availableBytes<8*1024**3){stop({status:'deferred',reason:'producer_resource_reserve'});return}
+          swapStart??=r.swapBytes
+          if(r.swapBytes-swapStart>256*1024**2)stop({status:'deferred',reason:'producer_swap_growth'})
+        })
         void this.deps.sampleRss(pgid).then(bytes => {
           sampling = false
-          if (bytes === null || verdict) return
+          if (verdict||settled)return
+          if(bytes===null){if(job.callProducer)stop({status:'deferred',reason:'producer_rss_unavailable'});return}
           peak = Math.max(peak ?? 0, bytes)
           if (bytes > limits.rssBytes) stop({ status: 'failed', reason: 'rss_cap', detail: `the run used ${Math.round(bytes / 1048576)} MB, over the ${Math.round(limits.rssBytes / 1048576)} MB cap` })
         })
@@ -583,6 +641,8 @@ export class SpeakerShadowRunner {
         settled = true
         clearInterval(tick)
         this.running = null
+        producerLease?.release()
+        if(!verdict&&this.deps.now()-started>limits.timeoutMs)verdict={status:'failed',reason:'timeout',detail:'worker close exceeded absolute wall budget'}
         if (verdict) { resolvePromise({ outcome: verdict, peakRss: peak }); return }
         const line = stdout.trim().split('\n').pop() ?? ''
         try {
@@ -593,7 +653,7 @@ export class SpeakerShadowRunner {
       }
       child.stdout?.on('data', (d: Buffer) => { if (stdout.length < MAX_STDOUT) stdout += d.toString(); else stop({ status: 'failed', reason: 'worker_crashed', detail: 'worker output over 8 MB' }) })
       child.stderr?.on('data', (d: Buffer) => { if (stderr.length < 16_384) stderr += d.toString() })
-      child.on('error', error => { stop({ status: 'failed', reason: 'worker_spawn_failed', detail: error.message }); done(null, null) })
+      child.on('error', error => { stop({ status: 'failed', reason: 'worker_spawn_failed', detail: error.message }); if(!child.pid)done(null, null) })
       child.on('close', done)
       child.stdin?.on('error', () => { /* a crashed worker closes stdin; close reports it */ })
       child.stdin?.end(JSON.stringify(job))
@@ -692,7 +752,8 @@ export function configureSpeakerShadow(probe: { captureActive: () => boolean; ad
   try {
     const runner = getSpeakerShadowRunner()
     runner.setCaptureProbe(probe.captureActive, probe.admissionsOpen)
-    if (!runner.enabled()) return
+    configureMacSpeakerCallProducer({captureActive:()=>probe.captureActive()||runner.nativeRunning(),admissionsOpen:probe.admissionsOpen,requestNative:r=>runner.notifyConsumerFinalized(r)})
+    if (!runner.nativeEnabled()) return
     const swept = sweepStaleSpeakerShadowTmp()
     if (swept) console.log(`[speaker-shadow] removed ${swept} stale temp dir(s)`)
     console.log('[speaker-shadow] enabled (log only)')

package/server/lib/speaker-trainer.ts

@@ -13,6 +13,7 @@ import {
   rawCosineSimilarity, saveProfileStore, rebuildAllProfiles, clearSpeakerEmbeddings,
 } from './speaker-embeddings.js'
 import { COS_SCRIPTS_DIR } from './python-bridge.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 const CACHE_DIR = '/tmp/cos-speaker-training'
 const PROGRESS_PATH = resolve(CACHE_DIR, 'training-progress.json')
@@ -520,7 +521,7 @@ export async function getTrainingStatus(): Promise<TrainingStatus> {
   }
 
   for (const name of enrolledNames) {
-    if (!speakers.some(s => s.name === name)) {
+    if (!speakers.some(s => sameSpeakerName(s.name, name))) {
       speakers.push({ name, segments: 0, meetings: 0, enrolled: true })
     }
   }

package/server/lib/token-audit.ts

@@ -8,12 +8,17 @@ import { homedir } from 'node:os'
 
 import { COS_SCRIPTS_DIR } from './python-bridge.js'
 import type { TokenAuditKeyFields } from './key-relay-contract.js'
+import { cleanProviderId, normalizeRealUsage, type RealUsage } from './provider-usage.js'
 
 // Shared JSONL file — same path as Python's llm_client.py uses
 // Uses COS_SCRIPTS_DIR when available (server mode), falls back to user home
-const AUDIT_FILE = COS_SCRIPTS_DIR
-  ? resolve(COS_SCRIPTS_DIR, '.cos_token_audit.jsonl')
-  : resolve(homedir(), '.cos-glasses', 'token-audit.jsonl')
+// 6.97.0: COS_TOKEN_AUDIT_FILE is set only by the test config, so no test writes a made-up row to a
+// real ledger now that a row can claim to be measured.
+const AUDIT_FILE = process.env.COS_TOKEN_AUDIT_FILE
+  ? resolve(process.env.COS_TOKEN_AUDIT_FILE)
+  : COS_SCRIPTS_DIR
+    ? resolve(COS_SCRIPTS_DIR, '.cos_token_audit.jsonl')
+    : resolve(homedir(), '.cos-glasses', 'token-audit.jsonl')
 
 // Rough char-to-token ratio (1 token ~ 4 chars for English)
 const CHARS_PER_TOKEN = 4
@@ -33,7 +38,12 @@ export interface TokenAuditEntry extends TokenAuditKeyFields {
   runId?: string
   sessionId?: string
   clientJobId?: string
-  usageKind?: 'provider_final' | 'estimated'
+  /** The provider's own session id: Claude's session, Codex's thread, Cursor's chat. `sessionId` is COS's. */
+  cliSessionId?: string
+  /** 6.97.0: what the provider reported. The row says `provider_final` only when these are real numbers. */
+  realUsage?: RealUsage
+  /** 6.97.0, dictation polish only: what the model is sent, system prompt included. `inputChars` stays the words dictated. */
+  promptChars?: number
   /** 6.85.0, dictation polish only: whether the user's polish instructions were in the prompt, and their hash. */
   polishInstructions?: { on: boolean; hash: string }
   /** 6.91.0, dictation polish only: whether the learned style was in the prompt, and its hash. */
@@ -56,6 +66,8 @@ export interface TokenAuditEntry extends TokenAuditKeyFields {
  * (subscription) row is byte-identical to 6.79.0. Callers set them only on keyed turns.
  */
 export function buildTokenAuditRecord(entry: TokenAuditEntry, now: Date = new Date()): Record<string, unknown> {
+  const real = normalizeRealUsage(entry.realUsage)
+  const cliSessionId = cleanProviderId(entry.cliSessionId)
   return {
     ts: now.toISOString(),
     source: entry.source,
@@ -66,7 +78,7 @@ export function buildTokenAuditRecord(entry: TokenAuditEntry, now: Date = new Da
     est_output_tokens: estimateTokens(entry.outputChars),
     duration_ms: entry.durationMs,
     caller: entry.caller,
-    usage_kind: entry.usageKind ?? 'estimated',
+    usage_kind: real ? 'provider_final' : 'estimated',
     ...(entry.turnId ? { turn_id: entry.turnId } : {}),
     ...(entry.runId ? { run_id: entry.runId } : {}),
     ...(entry.sessionId ? { session_id: entry.sessionId } : {}),
@@ -91,12 +103,30 @@ export function buildTokenAuditRecord(entry: TokenAuditEntry, now: Date = new Da
     ...(entry.polishGuard ? { polish_guard: entry.polishGuard } : {}),
     // 6.92.0: set only by the prompt-edit caller.
     ...(entry.promptEditOutcome ? { prompt_edit_outcome: entry.promptEditOutcome } : {}),
+    // 6.97.0: last, and only when set, so a row without them is byte-identical to 6.96.4. Numbers and
+    // ids only. COS Control reads these names. All four counts are always written. input_tokens never
+    // includes cache reads; it excludes cache writes only on Claude, the one provider that reports
+    // them, so on Codex and direct cache_write_tokens is 0 and any write stays in input_tokens.
+    // resolved_model is the CLI's word on Claude, and what COS asked for elsewhere. provider-usage.ts
+    // says exactly what each means. cache_write_1h_tokens is part of cache_write_tokens; it and cost_usd
+    // appear only when stated.
+    ...(typeof entry.promptChars === 'number' ? { prompt_chars: entry.promptChars } : {}),
+    ...(cliSessionId ? { cli_session_id: cliSessionId } : {}),
+    ...(real ? {
+      input_tokens: real.inputTokens,
+      output_tokens: real.outputTokens,
+      cache_read_tokens: real.cacheReadTokens ?? 0,
+      cache_write_tokens: real.cacheWriteTokens ?? 0,
+      ...(real.cacheWrite1hTokens !== undefined ? { cache_write_1h_tokens: real.cacheWrite1hTokens } : {}),
+      ...(real.costUsd !== undefined ? { cost_usd: real.costUsd } : {}),
+      ...(real.resolvedModel ? { resolved_model: real.resolvedModel } : {}),
+    } : {}),
   }
 }
 
 export function logTokenAudit(entry: TokenAuditEntry): void {
-  const record = buildTokenAuditRecord(entry)
   try {
+    const record = buildTokenAuditRecord(entry)
     appendFileSync(AUDIT_FILE, JSON.stringify(record) + '\n', { encoding: 'utf8', mode: 0o600 })
     chmodSync(AUDIT_FILE, 0o600)
   } catch {

package/server/lib/transcript-cleanup.ts

@@ -169,8 +169,9 @@ const notesSearchDefault: CleanupDeps['searchNotes'] = async (queries, sessionId
 
 const filesDefault: CleanupDeps['files'] = async sessionId => {
   try {
-    const { MeetingAskStore } = await import('./meeting-ask-store.js')
-    return new MeetingAskStore().files(sessionId).filter(f => f.status === 'ready' && typeof f.text === 'string' && f.text.trim()).map(f => ({ name: f.name, text: f.text }))
+    const { MeetingAskStore, isPastedFileId } = await import('./meeting-ask-store.js')
+    // Pasted text and read pages (paste_, web_) are article words, not the room's vocabulary: they must not rewrite the saved transcript.
+    return new MeetingAskStore().files(sessionId).filter(f => !isPastedFileId(f.id) && f.status === 'ready' && typeof f.text === 'string' && f.text.trim()).map(f => ({ name: f.name, text: f.text }))
   } catch { return [] }
 }
 

package/server/lib/voice-directory.ts

@@ -14,6 +14,7 @@ import { lstat, readFile, readdir, realpath } from 'node:fs/promises'
 import { basename, dirname, join } from 'node:path'
 import { setImmediate as yieldToEventLoop } from 'node:timers/promises'
 import { readMacSpeakerMachineEvidence } from './mac-speaker-machine-evidence.js'
+import { readMacSpeakerCallView } from './mac-speaker-call-view.js'
 import { dataPath } from './data-dir.js'
 import { confirmedLabels, confirmedChunks } from './meeting-corrections.js'
 import { resolveCosOperationsDir, resolveMeetingLibrary } from './cos-operations-meetings.js'
@@ -26,6 +27,7 @@ import {
 } from './meeting-speaker-review.js'
 import { getOwnerSpeakerLabel } from './profile.js'
 import { readVoiceProfiles, type VoiceProfile } from './speaker-embeddings.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 const MONTH = /^\d{4}-(0[1-9]|1[0-2])$/
 const SIDECAR = /\.g2-chunks\.json$/
@@ -277,7 +279,8 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
         continue
       }
       totalBytes += link.size
-      const raw = JSON.parse(await readFile(real, 'utf8')) as Record<string, unknown> | ReviewChunk[]
+      const baseJSON = await readFile(real, 'utf8')
+      const raw = JSON.parse(baseJSON) as Record<string, unknown> | ReviewChunk[]
       const chunks = Array.isArray(raw) ? raw : raw.chunks
       const sessionId = Array.isArray(raw) ? '' : String(raw.sessionId ?? '')
       if (!Array.isArray(chunks) || !SESSION.test(sessionId) || seenSessions.has(sessionId)) {
@@ -296,7 +299,9 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
       )
 
       const machineEvidence = readMacSpeakerMachineEvidence(record)
-      const review = reviewMeetingSpeakers(chunks as ReviewChunk[], {
+      const callView = readMacSpeakerCallView(real, baseJSON, candidate.markdownPath)
+      const review = reviewMeetingSpeakers((callView.doc.chunks ?? chunks) as ReviewChunk[], {
+        callViewAnonymousLabels: callView.metadata.groups.map(g => g.label),
         owner,
         phrasesPerVoice: 1,
         confirmed: confirmedLabels(sessionId),
@@ -304,8 +309,8 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
         machineQualifiedPositions: machineEvidence.positions,
         machineEvidenceStatus: machineEvidence.status,
         durationMs: typeof record.durationMs === 'number' ? record.durationMs : undefined,
-        batchSegments: Array.isArray(record.batchSegments)
-          ? record.batchSegments as SpeakerWordSegment[]
+        batchSegments: Array.isArray(callView.doc.batchSegments)
+          ? callView.doc.batchSegments as SpeakerWordSegment[]
           : undefined,
       })
       meetingsScanned++
@@ -363,7 +368,7 @@ export async function buildVoiceDirectorySnapshot(): Promise<VoiceDirectorySnaps
       .slice(0, MAX_APPEARANCES_PER_VOICE)
     return {
       name: profile.name,
-      isOwner: profile.name === owner,
+      isOwner: sameSpeakerName(profile.name, owner),
       embeddings: profile.embeddings.length,
       sources: sourceCounts(profile),
       sourcesAligned: (profile.sources?.length ?? 0) === profile.embeddings.length,

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

@@ -16,6 +16,7 @@ import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:f
 import { basename, dirname, join, resolve } from 'node:path'
 import { durableAtomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
 import { EVICTION_ORDER, isMacAssign, macAssignCapFor, provenanceTier } from './embedding-eviction.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 export interface VoiceProfile {
   name: string
@@ -512,6 +513,11 @@ export interface MergeOutcome {
  * removable later, and overwriting it to record a bookkeeping event would trade
  * a useful fact for a useless one.
  */
+/** The profile stored under `name`: the exact spelling first, else the one that is the same name in NFC. */
+export function findStoredProfile(store: ProfileStore, name: string): VoiceProfile | undefined {
+  return store.profiles.find(p => p.name === name) ?? store.profiles.find(p => sameSpeakerName(p.name, name))
+}
+
 export function mergeProfilesInStore(
   store: ProfileStore,
   into: string,
@@ -519,7 +525,7 @@ export function mergeProfilesInStore(
   options: { cap?: number } = {},
 ): MergeOutcome {
   const cap = options.cap ?? 40
-  const target = store.profiles.find(p => p.name === into)
+  const target = findStoredProfile(store, into)
   const outcome: MergeOutcome = {
     similarity: {},
     samplesBefore: target?.embeddings.length ?? 0,
@@ -537,18 +543,23 @@ export function mergeProfilesInStore(
   const sources = [...(target.sources ?? [])]
   while (sources.length < embeddings.length) sources.push(UNKNOWN_SOURCE)
 
+  // Sources are the stored profiles themselves, never the spelling asked for: a name stored decomposed and its composed twin are two
+  // profiles (the twin is merged into the one that was asked for), and the target is never its own source.
+  const absorbed = new Set<VoiceProfile>()
   for (const name of from) {
-    if (name === into) continue
-    const source = store.profiles.find(p => p.name === name)
-    if (!source) { outcome.missing.push(name); continue }
-    outcome.similarity[name] = profileSimilarity(target, source)
-    const sourceSources = [...(source.sources ?? [])]
-    while (sourceSources.length < source.embeddings.length) sourceSources.push(UNKNOWN_SOURCE)
-    for (let i = 0; i < source.embeddings.length; i++) {
-      embeddings.push(source.embeddings[i])
-      sources.push(sourceSources[i] ?? UNKNOWN_SOURCE)
+    const found = store.profiles.filter(p => p !== target && !absorbed.has(p) && sameSpeakerName(p.name, name))
+    if (found.length === 0) { if (!store.profiles.some(p => sameSpeakerName(p.name, name) && p !== target)) outcome.missing.push(name); continue }
+    for (const source of found) {
+      outcome.similarity[name] = profileSimilarity(target, source)
+      const sourceSources = [...(source.sources ?? [])]
+      while (sourceSources.length < source.embeddings.length) sourceSources.push(UNKNOWN_SOURCE)
+      for (let i = 0; i < source.embeddings.length; i++) {
+        embeddings.push(source.embeddings[i])
+        sources.push(sourceSources[i] ?? UNKNOWN_SOURCE)
+      }
+      outcome.mergedFrom.push(source.name)
+      absorbed.add(source)
     }
-    outcome.mergedFrom.push(name)
   }
 
   if (outcome.mergedFrom.length === 0) return outcome
@@ -569,8 +580,7 @@ export function mergeProfilesInStore(
   target.sources = keep.map(i => sources[i])
   outcome.samplesAfter = target.embeddings.length
 
-  const removed = new Set(outcome.mergedFrom)
-  store.profiles = store.profiles.filter(p => !removed.has(p.name))
+  store.profiles = store.profiles.filter(p => !absorbed.has(p))
   return outcome
 }
 
@@ -583,7 +593,7 @@ export function deleteProfileFromStore(
   let removedProfiles = 0
   let removedEmbeddings = 0
   store.profiles = store.profiles.filter(profile => {
-    if (profile.name !== name) return true
+    if (!sameSpeakerName(profile.name, name)) return true
     removedProfiles++
     removedEmbeddings += profile.embeddings.length
     return false