@gotcos/glasses-server 6.95.0 → 6.98.0

package/server/lib/dictation-clean-models.ts

@@ -2,6 +2,8 @@
 export const DICTATION_CLEAN_MODELS = ['haiku', 'sonnet', 'luna-5.6-fast'] as const
 export type DictationCleanModel = typeof DICTATION_CLEAN_MODELS[number]
 export const LUNA_DICTATION_CLI_MODEL = 'gpt-5.6-luna-none-fast'
+/** The polish choice that runs through Cursor, whose path has no system prompt. */
+export const LUNA_DICTATION_MODEL = 'luna-5.6-fast'
 export function isDictationCleanModel(value: unknown): value is DictationCleanModel {
   return value === 'sonnet' || value === 'luna-5.6-fast' || value === 'haiku'
 }

package/server/lib/dictation-clean.ts

@@ -4,7 +4,7 @@ import { homedir, tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { resolveProviderBinary } from './provider-binary.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
-import { isDictationCleanModel, LUNA_DICTATION_CLI_MODEL } from './dictation-clean-models.js'
+import { isDictationCleanModel, LUNA_DICTATION_CLI_MODEL, LUNA_DICTATION_MODEL } from './dictation-clean-models.js'
 import { sanitizeCustomInstructions } from './dictation-polish-instructions.js'
 import { LEARNED_STYLE_MAX_CHARS } from './dictation-learned-style.js'
 import type { DictationRegister } from './dictation-register.js'
@@ -311,7 +311,7 @@ export async function autoCleanDictation(
   if (opts.signal?.aborted) throw new Error('Auto-clean aborted')
   const model = (opts.model || process.env.COS_DICTATION_AUTOCLEAN_MODEL || 'haiku').toLowerCase()
   if (!isDictationCleanModel(model)) throw new Error('Unsupported dictation cleanup model')
-  const cursor = model === 'luna-5.6-fast'
+  const cursor = model === LUNA_DICTATION_MODEL
   const binary = resolveProviderBinary(cursor ? 'cursor' : 'claude')
   if (!binary.ok) throw new Error(`Dictation cleanup ${cursor ? 'Cursor' : 'Claude'} CLI unavailable`)
   const configuredTimeout = Number.parseInt(process.env.COS_DICTATION_AUTOCLEAN_TIMEOUT_MS || '20000', 10)

package/server/lib/dictation-polish-pipeline.ts

@@ -1,9 +1,9 @@
-import type { DictationCleanModel } from './dictation-clean-models.js'
+import { LUNA_DICTATION_MODEL, type DictationCleanModel } from './dictation-clean-models.js'
 import { applyNegativeRules } from './hallucination-filter.js'
 import { applyCorrections } from './whisper-local.js'
 import { applyFuzzyCorrections } from './fuzzy-correct.js'
 import { getAllSpeakerNames } from './speaker-embeddings.js'
-import { autoCleanDictation, AUTOCLEAN_MAX_CHARS } from './dictation-clean.js'
+import { autoCleanDictation, AUTOCLEAN_MAX_CHARS, buildDictationPolishPrompt, DICTATION_POLISH_SYSTEM_PROMPTS, type DictationPromptExtras } from './dictation-clean.js'
 import { dictationPolishPromptVersion, styleAndRegisterApply, type DictationPolishPromptVersion } from './dictation-polish-options.js'
 import { fillerPassEnabled, stripFillersIfEnglish } from './dictation-fillers.js'
 import { polishBudgetExhausted, recordPolishCall, type PolishBucket } from './dictation-polish-budget.js'
@@ -265,6 +265,21 @@ export function guardPolishAnswer(
   return { text: answer, outcome: answer !== cleaned ? 'polished' : 'unchanged' }
 }
 
+/**
+ * 6.97.0, for the audit row only: what the model is sent, on its own field, because `input_chars` stays
+ * the words dictated so old and new rows still compare. Absent if it cannot be worked out. Never throws.
+ */
+function polishPromptChars(
+  cleaned: string, model: string, version: DictationPolishPromptVersion, customInstructions: string, extras: DictationPromptExtras,
+): { promptChars?: number } {
+  try {
+    const system = model === LUNA_DICTATION_MODEL ? 0 : DICTATION_POLISH_SYSTEM_PROMPTS[version].length
+    return { promptChars: system + buildDictationPolishPrompt(cleaned, getVocabulary(), version, customInstructions, extras).length }
+  } catch {
+    return {}
+  }
+}
+
 export async function polishOutboundDictation(
   text: string,
   opts: OutboundOptions,
@@ -334,6 +349,9 @@ export async function polishOutboundDictation(
       ...(canaried ? { polishRegister: register } : {}),
       ...(used.polishPrompt ? { polishPrompt: used.polishPrompt } : {}),
       polishOutcome: guarded.outcome, ...(guarded.guard ? { polishGuard: guarded.guard } : {}),
+      // Real numbers from a warm result. The cold path prints plain text, so its row stays estimated.
+      ...polishPromptChars(cleaned, model, promptVersion, customInstructions, { learnedStyle: style.lines, register }),
+      ...warmEntry?.usage,
     })
     return {
       text: guarded.text, ...(prewarm ? { prewarm } : {}),
@@ -357,6 +375,8 @@ export async function polishOutboundDictation(
         ...(canaried ? { polishRegister: register } : {}),
         ...(used.polishPrompt ? { polishPrompt: used.polishPrompt } : {}),
         polishOutcome: 'aborted',
+        ...polishPromptChars(cleaned, model, promptVersion, customInstructions, { learnedStyle: style.lines, register }),
+        ...warmEntry?.usage,
       })
       console.warn('[prompt-draft] auto-clean aborted by the client (glossary-only)')
     } else {

package/server/lib/dictation-prewarm.ts

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { resolveProviderBinary } from './provider-binary.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
+import { ClaudeRunUsage, type EngineUsage } from './provider-usage.js'
 import {
   buildDictationPolishPrompt, claudePolishArgs, DICTATION_POLISH_SYSTEM_PROMPTS, dictationChildEnv, dictationPolishPromptVersion,
   type DictationPolishPromptVersion, type DictationPromptExtras,
@@ -42,6 +43,8 @@ interface WarmPolish {
   timer: NodeJS.Timeout
   onResult: ((event: any) => void) | null
   onExit: (() => void) | null
+  /** 6.97.0: what the one message used, for the audit row. Read by the caller after the call. */
+  usage?: EngineUsage
 }
 
 /** Unclaimed warm processes, by token. */
@@ -178,6 +181,8 @@ export async function runWarmPolish(
     const abort = () => finish(new Error('Auto-clean aborted'))
     const timer = setTimeout(() => finish(new Error(`Auto-clean timed out (${timeoutMs}ms)`)), timeoutMs)
     entry.onResult = (event) => {
+      // Before the answer is judged, and unable to affect it: the audit reads its own copy.
+      noteWarmUsage(entry, event)
       if (event.subtype !== 'success' || event.is_error || typeof event.result !== 'string') {
         return finish(new Error('Warm polish returned an unsuccessful result'))
       }
@@ -203,6 +208,17 @@ export async function runWarmPolish(
   })
 }
 
+function noteWarmUsage(entry: WarmPolish, event: unknown): void {
+  try {
+    const run = new ClaudeRunUsage(false)
+    run.observe(event)
+    const realUsage = run.take()
+    entry.usage = { ...(realUsage ? { realUsage } : {}), ...(run.cliSessionId ? { cliSessionId: run.cliSessionId } : {}) }
+  } catch {
+    /* the audit row stays estimated */
+  }
+}
+
 /** The server is going away: a detached warm process would outlive it. */
 export function killAllPrewarmsSync(): void {
   for (const entry of alive) {

package/server/lib/direct-bridge.ts

@@ -551,7 +551,8 @@ export async function callDirectStreaming(
 
   let fullText = ''
   let finalized = false
-  const usageTotals = { input: 0, output: 0, usd: 0, measured: false }
+  // statedUsd and allStated: what the provider itself said it cost. `usd` may be priced by COS instead.
+  const usageTotals = { input: 0, output: 0, usd: 0, measured: false, statedUsd: 0, allStated: true, cached: 0 }
   const trail = (draft: JobTrailDraft) => {
     if (!callbacks.onTrail) return
     try { callbacks.onTrail(draft) } catch { /* observation only */ }
@@ -569,11 +570,19 @@ export async function callDirectStreaming(
       runId: run.runId,
       sessionId: sid,
       ...(options?.clientJobId ? { clientJobId: options.clientJobId } : {}),
-      usageKind: usageTotals.measured ? 'provider_final' : 'estimated',
       profile: profile.id,
       lane: 'direct',
       credentialKind: key.kind,
       usd: Math.round(usageTotals.usd * 1e6) / 1e6,
+      // 6.97.0: the tokens the provider reported, with its cost only when every call stated one.
+      ...(usageTotals.measured ? { realUsage: {
+        // prompt_tokens includes cached ones; the row keeps them apart.
+        inputTokens: usageTotals.input - usageTotals.cached,
+        outputTokens: usageTotals.output,
+        cacheReadTokens: usageTotals.cached,
+        ...(usageTotals.allStated ? { costUsd: usageTotals.statedUsd } : {}),
+        resolvedModel: profile.model,
+      } } : {}),
     })
   }
 
@@ -745,6 +754,9 @@ export async function callDirectStreaming(
       usageTotals.output += parser.usage.output
       usageTotals.usd += usd
       usageTotals.measured = true
+      if (parser.usage.costUsd === undefined) usageTotals.allStated = false
+      else usageTotals.statedUsd += parser.usage.costUsd
+      usageTotals.cached += parser.usage.cachedInput ?? 0
       settle({
         input: parser.usage.input,
         output: parser.usage.output,

package/server/lib/direct-sse.ts

@@ -35,6 +35,8 @@ export interface DirectSseUsage {
   output: number
   /** Provider-reported cost in USD (OpenRouter `usage.cost`), when present. */
   costUsd?: number
+  /** 6.97.0: the part of `input` read from cache, when the provider says. Only the audit reads it. */
+  cachedInput?: number
 }
 
 export type DirectSseEvent =
@@ -213,10 +215,13 @@ export class DirectSseParser {
     const usage = chunk.usage as Record<string, unknown> | undefined
     if (usage && typeof usage === 'object') {
       const cost = usage.cost
+      const input = nonNegative(usage.prompt_tokens)
+      const cached = (usage.prompt_tokens_details as { cached_tokens?: unknown } | null | undefined)?.cached_tokens
       this.usage = {
-        input: nonNegative(usage.prompt_tokens),
+        input,
         output: nonNegative(usage.completion_tokens),
         ...(typeof cost === 'number' && Number.isFinite(cost) && cost >= 0 ? { costUsd: cost } : {}),
+        ...(typeof cached === 'number' && Number.isSafeInteger(cached) && cached > 0 && cached <= input ? { cachedInput: cached } : {}),
       }
     }
     const choices = Array.isArray(chunk.choices) ? chunk.choices : []

package/server/lib/display-bus.ts

@@ -10,7 +10,7 @@ bus.setMaxListeners(20) // Multiple glasses clients
 export interface DisplayEvent {
   type: 'chunk' | 'done' | 'error' | 'tool_status' | 'start' | 'session_restore' | 'transcript_chunk' | 'prompt_transcript' | 'recording_start' | 'recording_stop' | 'coaching_nudge' | 'coaching_nudge_v2'
     // Control asked the glasses to stop a G2 meeting (routes/meeting.ts stop-request).
-    | 'meeting_stop_requested'
+    | 'meeting_stop_requested' | 'mac_speaker_live_revision'
   data: Record<string, unknown>
 }
 

package/server/lib/fork-thread.ts

@@ -89,6 +89,8 @@ import { PROVIDER_AUTH_RE, PROVIDER_OVERFLOW_RE, PROVIDER_QUOTA_RE } from './pro
 import { cursorIsolationUnavailableError, cursorSpawnEnv, isCursorIsolationUnavailable, releaseCursorSpawnOnExit } from './cursor-spawn-env.js'
 import { anyKeyedSessions, isKeyedSession } from './keyed-sessions.js'
 import { claudeKeySecretsGuardArgs } from './key-secrets-guard.js'
+import { SideRunTap } from './provider-usage.js'
+import { logTokenAudit, type TokenAuditEntry } from './token-audit.js'
 
 /**
  * Providers that can be forked.
@@ -496,6 +498,8 @@ export interface ForkDeps {
    * always supply it.
    */
   sourceWatermark?: (provider: ForkProvider, nativeThreadId: string) => string | null
+  /** 6.97.0: where the run's audit row goes. Only production wiring sets it, so no test writes a real ledger. */
+  auditRun?: (entry: TokenAuditEntry) => void
   /**
    * Argv builder. Optional, defaults to the real one.
    *
@@ -793,8 +797,13 @@ async function run(request: ForkRequest, deps: ForkDeps, startedAt: number): Pro
   }
 
   let outcome: ForkResult
+  // 6.97.0: a passive reader, wired after the run's own listeners, for one audit row at the end.
+  const usageTap = deps.auditRun ? new SideRunTap(provider) : null
   try {
-    outcome = await driveChild({ child, deps, provider, sourceNativeThreadId, prompt, timeoutMs, startedAt })
+    const running = driveChild({ child, deps, provider, sourceNativeThreadId, prompt, timeoutMs, startedAt })
+    usageTap?.attach(child.stdout as any)
+    outcome = await running
+    auditForkRun(deps, usageTap, outcome, provider, prompt)
   } finally {
     // EVERY path: success, mismatch, non-zero exit, timeout, throw. A leaked entry
     // outlives the process and lets a RECYCLED pid inherit our self-ownership
@@ -1058,6 +1067,27 @@ function driveChild(input: DriveInput): Promise<ForkResult> {
 // Production wiring
 // ---------------------------------------------------------------------------
 
+/** One row for a fork that reached an end and names its new thread. Never changes the fork's outcome. */
+function auditForkRun(deps: ForkDeps, tap: SideRunTap | null, outcome: ForkResult, provider: ForkProvider, prompt: string): void {
+  try {
+    if (!tap || !deps.auditRun) return
+    const realUsage = tap.finish()
+    if (!outcome.newNativeThreadId || (!outcome.ok && !tap.sawEnd)) return
+    deps.auditRun({
+      source: 'g2-fork',
+      caller: outcome.ok ? 'fork_thread' : `fork_thread:${outcome.reason}`,
+      model: provider,
+      inputChars: prompt.length,
+      outputChars: tap.outputChars,
+      durationMs: outcome.durationMs,
+      cliSessionId: outcome.newNativeThreadId,
+      ...(realUsage ? { realUsage } : {}),
+    })
+  } catch {
+    // The audit never changes a fork's outcome.
+  }
+}
+
 /**
  * The real dependency set.
  *
@@ -1071,6 +1101,7 @@ export function realForkDeps(
 ): ForkDeps {
   return {
     now: () => Date.now(),
+    auditRun: entry => logTokenAudit(entry),
     resolveBinary: provider => resolveProviderBinary(provider),
     spawn: request => {
       // 6.62.0 (plan 3.4): the Cursor fork's `--model` must not rewrite the CLI default.

package/server/lib/held-naming-batches.ts

@@ -1,4 +1,5 @@
 /** Durable held naming: server-stored preview, per-copy receipts, explicit recovery. */
+import { nfc, sameSpeakerName } from './speaker-name-nfc.js'
 import { createHash, randomUUID } from 'node:crypto'
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
@@ -14,6 +15,7 @@ import { MeetingStore } from './meeting-store.js'
 import { appendCorrection, closeInterruptedCorrections, pendingCorrections, readCorrections, appliedCorrections, type CorrectionRow } from './meeting-corrections.js'
 import { patchValue, relabelSpeakerPositions, undoSpeakerMarkdown, strippedTranscript, validatedRawMap, type SpeakerPatch } from './meeting-speaker-labels.js'
 import { acquireMeetingSyncLock } from './meeting-sync-lock.js'
+import { inspectOriginalViewTransaction } from './mac-speaker-call-original-view.js'
 
 export const NAMING_CAPABILITIES = {preview:true,apply:true,undo:true,version:1} as const
 const PREVIEW_TTL = 15 * 60 * 1000
@@ -27,12 +29,12 @@ export function resolveStoredName(name: string): {name:string;owner:boolean} {
   if (stored.length > 1) throw new HeldGroupError(400,'ambiguous_name','Multiple stored voices have that spelling. Rename the duplicate profiles first.',{names:stored.map(p=>p.name)})
   const owner = getOwnerSpeakerLabel()
   const isOwner = foldName(owner) === foldName(name.trim()) || (stored[0] && foldName(stored[0].name) === foldName(owner))
-  return {name:isOwner ? owner : stored[0]?.name ?? name.trim(),owner:!!isOwner}
+  return {name:isOwner ? owner : stored[0]?.name ?? nfc(name.trim()),owner:!!isOwner}
 }
 function voiceVersion(name: string) {
   const path = dataPath('voice-profiles.json')
   const profiles = readVoiceProfiles().profiles
-  return {storeMtime:existsSync(path)?statSync(path).mtimeMs:0,profileCount:profiles.length,targetSamples:profiles.find(p=>p.name===name)?.embeddings.length ?? 0}
+  return {storeMtime:existsSync(path)?statSync(path).mtimeMs:0,profileCount:profiles.length,targetSamples:profiles.find(p=>sameSpeakerName(p.name,name))?.embeddings.length ?? 0}
 }
 function evidenceVersion(refs:HeldSampleRef[]) {
   return hash([...new Set(refs.map(r=>r.sessionId))].sort().map(sessionId=>({sessionId,rows:readChunkEmbeddings(sessionId).rows.map(r=>({i:r.i,embedding:Array.from(r.embedding)})),cache:existsSync(dataPath('held-voice-embeddings',`${sessionId}.json`))?readFileSync(dataPath('held-voice-embeddings',`${sessionId}.json`),'utf8'):''})))
@@ -179,6 +181,23 @@ function checkedRevision(value:unknown):number {
   if(typeof value!=='number'||!Number.isSafeInteger(value)||value<0)throw new Error('Invalid meeting revision')
   return value
 }
+/** A call-wide view is bound to the original BASE and correction ledger. Legacy
+ * physical renames (including Undo and profile fan-out) must not silently make
+ * that view, or a later human annotation, disappear. Presence is deliberately
+ * enough: a malformed or interrupted artifact is not permission to overwrite. */
+const CALL_OVERLAY_REFUSAL='Call-wide speaker review is active or needs recovery. Use the exact reviewed segment naming flow; legacy naming cannot change this meeting.'
+function assertNoCallSpeakerOverlay(sidecarPath:string,sessionId:string):void {
+  const stem=sidecarPath.replace(/\.g2-chunks\.json$/,'')
+  if(/^mac_[A-Za-z0-9_-]{1,100}$/.test(sessionId)){
+    const original=inspectOriginalViewTransaction({sidecarPath,meetingPath:stem+'.md'},sessionId)
+    if(original.status==='prepared'||original.status==='recovery-invalid')throw new Error(CALL_OVERLAY_REFUSAL)
+  }
+  const artifacts=[...['.speaker-call.json','.speaker-call-state.json','.speaker-call-human.json','.speaker-call-human-transaction.json','.speaker-call-interval-human.json','.speaker-call-interval-human-transaction.json'].map(suffix=>stem+suffix),join(dirname(sidecarPath),`.${sessionId}.speaker-call.lock`)]
+  for(const artifact of artifacts){
+    try{lstatSync(artifact)}catch(e){if((e as NodeJS.ErrnoException).code==='ENOENT')continue;throw e}
+    throw new Error(CALL_OVERLAY_REFUSAL)
+  }
+}
 function resolveCopies(sessionId:string):ResolvedCopy[] {
   if(sessionBusy(sessionId)||existsSync(dataPath('meeting-finalization-jobs',`${sessionId}.json`)))throw new Error('Meeting is recording or finalizing; retry after it finishes')
   const local = new MeetingStore().findBySessionId(sessionId)
@@ -197,6 +216,7 @@ function resolveCopies(sessionId:string):ResolvedCopy[] {
     throw new Error('Configured operations folder is unavailable; retry after sync')
   }
   return paths.map(p=>{
+    assertNoCallSpeakerOverlay(p.sidecarPath,sessionId)
     assertFile(p.sidecarPath)
     const raw=readFileSync(p.sidecarPath,'utf8'),doc=JSON.parse(raw)
     if(doc.sessionId!==sessionId) throw new Error('Meeting identity changed')
@@ -428,8 +448,22 @@ export async function undoHeldNaming(batchId:string,confirm:boolean){
   let lock:Awaited<ReturnType<typeof acquireMeetingSyncLock>>|undefined
   try{
     try{lock=await acquireMeetingSyncLock()}catch(e){throw new HeldGroupError(409,'sync_running',errorText(e))}
+    // One meeting that cannot be undone must not stop the others: Undo restores
+    // what it can and reports the rest as partial. Each meeting is still checked
+    // before its intent row, because that row changes the ledger its copies share,
+    // and a ledger change would invalidate a human overlay in a sibling copy.
+    const refused:string[]=[]
+    let attempted=false
     for(const meeting of batch.meetings){
       if(!meeting.receipts.length)continue
+      if(meeting.receipts.some(r=>r.status!=='reverted')){
+        try{resolveCopies(meeting.sessionId)}catch(e){
+          // Kept in memory until the outcome is known: a full refusal below leaves the batch record untouched.
+          meeting.error=errorText(e);refused.push(meeting.error)
+          continue
+        }
+      }
+      attempted=true
       const undoId=randomUUID(),row:CorrectionRow={id:undoId,phase:'intent',at:new Date().toISOString(),from:batch.speaker,to:'prior labels',chunks:[...meeting.namedChunks,...meeting.widerChunks],scope:'meeting',batchId:batch.batchId,source:'undo'}
       try{
         const later=appliedCorrections(meeting.sessionId).filter(r=>r.batchId!==batchId&&r.at>=batch.at)
@@ -462,6 +496,9 @@ export async function undoHeldNaming(batchId:string,confirm:boolean){
       }catch(e){meeting.error=errorText(e);appendCorrection(meeting.sessionId,{...row,phase:'failed',error:meeting.error})}
       writeRecord('batch',batch.batchId,batch)
     }
+    // Nothing could be attempted and a call-wide review is why: that is a refusal
+    // with a next step, not a partial Undo.
+    if(!attempted&&refused.includes(CALL_OVERLAY_REFUSAL))throw new HeldGroupError(409,'call_review_active',CALL_OVERLAY_REFUSAL)
     batch.status=batch.meetings.filter(m=>m.receipts.length).every(m=>m.status==='reverted')?'reverted':'partial'
     writeRecord('batch',batch.batchId,batch)
     return{...batchView(batch),kind:'undone',samplesKept:true,audioRestored:false}
@@ -472,7 +509,7 @@ export async function undoHeldNaming(batchId:string,confirm:boolean){
  * enrolment/audio deletion off. Dry run neither records a preview nor writes a ledger. */
 export async function renameMeetingSpeaker(sessionId:string,from:string,to:string,options:{apply?:boolean;operationsDir?:string;expectedSidecarPath?:string}={}) : Promise<{copies:Array<{sidecarPath:string;meetingPath:string;labels:number;transcript:number;attendees:number;unresolvedTurns:number}>;batchId?:string;error?:string}> {
   if(options.operationsDir && resolveCosOperationsDir()!==realpathSync(options.operationsDir)) throw new Error('Operations root differs from the requested fan-out root')
-  if(from===to||!from.trim()||!to.trim())return{copies:[]}
+  if(sameSpeakerName(from,to)||!from.trim()||!to.trim())return{copies:[]}
   if(options.apply&&mutationBusy)throw new Error('Another naming is running; retry')
   let lock:Awaited<ReturnType<typeof acquireMeetingSyncLock>>|undefined
   let batch:BatchRecord|undefined
@@ -486,22 +523,22 @@ export async function renameMeetingSpeaker(sessionId:string,from:string,to:strin
     if(options.expectedSidecarPath && (!operations || realpathSync(operations.sidecarPath)!==realpathSync(options.expectedSidecarPath)))throw new Error('Session resolves to a different sidecar; duplicate or archived copy')
     const maps=copies.map(c=>validatedRawMap(c.doc))
     if(maps.some(map=>hash(map)!==hash(maps[0])))throw new Error('Meeting copies disagree on raw mapping')
-    const positions:number[]=copies[0].doc.chunks.flatMap((c:any,i:number)=>c.speaker===from?[i]:[])
+    const positions:number[]=copies[0].doc.chunks.flatMap((c:any,i:number)=>sameSpeakerName(c.speaker,from)?[i]:[])
     // Repair historical chunks-only renames too: HQ words still carry `from`
     // even when the compacted chunk already says `to` (the 6.27.10 trap).
     for(const c of copies)for(const segment of c.doc.batchSegments??[])for(const word of segment.speakerWords??[]){
-      if(word.speaker!==from)continue
+      if(!sameSpeakerName(word.speaker,from))continue
       const absolute=Number(segment.startElapsed??0)+Number(word.start)*1000
       let position=-1,distance=Infinity
       const raw=validatedRawMap(c.doc)
       raw.forEach((index,i)=>{if(index<segment.startChunkIdx||index>segment.endChunkIdx)return;const d=Math.abs(Number(c.doc.chunks[i].elapsed)-absolute);if(d<distance){distance=d;position=i}})
       if(distance>3500||position<0)throw new Error('Old HQ speaker has no safe raw chunk mapping')
-      if(![from,to].includes(c.doc.chunks[position].speaker))throw new Error('HQ speaker conflicts with an unrelated named chunk')
+      if(![from,to].some(n=>sameSpeakerName(n,c.doc.chunks[position].speaker)))throw new Error('HQ speaker conflicts with an unrelated named chunk')
       if(!positions.includes(position))positions.push(position)
     }
     positions.sort((a,b)=>a-b)
     if(!positions.length)return{copies:[]}
-    if(copies.some(c=>positions.some((i:number)=>![from,to].includes(c.doc.chunks[i]?.speaker))))throw new Error('Meeting copies disagree on prior speaker labels')
+    if(copies.some(c=>positions.some((i:number)=>![from,to].some(n=>sameSpeakerName(n,c.doc.chunks[i]?.speaker)))))throw new Error('Meeting copies disagree on prior speaker labels')
     const batchId=randomUUID()
     const edits=copies.map(c=>relabelSpeakerPositions(c.doc,c.blended?'':c.markdown,positions,to,batchId))
     const results=copies.map((c,i)=>({sidecarPath:c.sidecarPath,meetingPath:c.meetingPath,labels:positions.length,transcript:edits[i].transcript,attendees:edits[i].attendees,unresolvedTurns:edits[i].unresolvedTurns}))

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

@@ -62,6 +62,7 @@ import {
   greedyDiversitySelect,
   pairwiseSimilarityMatrix,
 } from './voice-enrolment-selection.js'
+import { sameSpeakerName } from './speaker-name-nfc.js'
 
 /** Where decoded-on-demand vectors are kept. One JSON file per held session. */
 export const HELD_EMBEDDING_CACHE_DIR = 'held-voice-embeddings'
@@ -432,12 +433,12 @@ export function suggestProfile(embedding: Float32Array, profiles: VoiceProfile[]
     if (!best || candidate.score > best.score) best = candidate
   }
   if (!best || best.anchor === null) return null
-  const winner = profiles.find(p => p.name === best!.name)!
+  const winner = profiles.find(p => sameSpeakerName(p.name, best!.name))!
   // Near-duplicate profile pairs represent an existing identity ambiguity, not
   // independent competing acoustic evidence. Do not let that pair erase the
   // margin against genuinely different voices. Never merge or rename here.
   const runnerUp = candidates.filter(c => c.name !== best!.name).filter(c => {
-    const other = profiles.find(p => p.name === c.name)!
+    const other = profiles.find(p => sameSpeakerName(p.name, c.name))!
     return profileSimilarity(winner, other) < HELD_NEAR_PROFILE_SIMILARITY
   }).reduce((score, c) => Math.max(score, c.score), 0)
   const margin = best.score - runnerUp
@@ -754,7 +755,7 @@ export function enrollHeldGroup(name: string, refs: HeldSampleRef[], opts: { dry
   const core = expand(coreReps)
   const leftBehind = expand(reps.filter(i => !coreSet.has(i))).map(s => ({ sessionId: s.sessionId, chunkIndex: s.chunkIndex })).sort(compareRefs)
 
-  const existing = readVoiceProfiles().profiles.find(p => p.name === name)
+  const existing = readVoiceProfiles().profiles.find(p => sameSpeakerName(p.name, name))
   // A primitive snapshot, taken BEFORE the loop: the store hands back its live
   // `embeddings` array by reference, and enrolment appends to that same array
   // until the first write invalidates the cache. Reading `.length` afterwards
@@ -826,7 +827,7 @@ export function projectHeldEnrollment(name: string, refs: HeldSampleRef[]): {
   const profiles = readVoiceProfiles().profiles.map(profile => ({
     ...profile, embeddings: profile.embeddings.map(row => [...row]), sources: [...(profile.sources ?? [])],
   }))
-  let target = profiles.find(profile => profile.name === name)
+  let target = profiles.find(profile => sameSpeakerName(profile.name, name))
   if (!target) { target = { name, embeddings: [], sources: [] }; profiles.push(target) }
   const selectedMembers: HeldSampleRef[] = []
   for (const embedding of selected) {

package/server/lib/job-audit-caller.ts

@@ -0,0 +1,20 @@
+// 6.97.0: the token-audit caller of a dispatched task or a meeting review, which read as `full_query`
+// before. Routines have their own (routines-config.ts). Import-free, so the review runtime can mark a
+// job without loading the job runtime.
+
+/** Review jobs in this process. A review resumed after a restart reads as an ordinary query again. */
+const workReviewJobs = new Set<string>()
+const WORK_REVIEW_JOBS_MAX = 256
+
+/** Reviews carry no origin (a new kind would reach the phone and COS Control), so they are marked here. */
+export function noteWorkReviewJob(clientJobId: string): void {
+  workReviewJobs.delete(clientJobId)
+  workReviewJobs.add(clientJobId)
+  if (workReviewJobs.size > WORK_REVIEW_JOBS_MAX) workReviewJobs.delete(workReviewJobs.values().next().value!)
+}
+
+/** '' for every other job, whose caller stays what the bridge picks. */
+export function jobAuditCaller(request: { clientJobId?: string; origin?: { kind: string } }): string {
+  if (request.origin?.kind === 'task') return 'dispatch_task'
+  return request.clientJobId && workReviewJobs.has(request.clientJobId) ? 'work_review' : ''
+}

package/server/lib/keyed-sessions.ts

@@ -10,7 +10,7 @@
 // every check below is one failed stat. Reading never creates. Remove all keys (plan 12) keeps
 // this file on purpose: a keyed transcript stays refused after the keys are gone. A manual
 // `claude --resume` in a terminal is documented, not blocked.
-import { statSync } from 'node:fs'
+import { existsSync, lstatSync, readFileSync, statSync } from 'node:fs'
 import { dataPath } from './data-dir.js'
 import { readPrivateJsonFile, writePrivateJsonFile } from './key-store.js'
 import { registerKeyLanesStatusProvider } from './key-lanes.js'
@@ -83,6 +83,26 @@ export function listKeyedSessions(): KeyedSessionRecord[] {
   return [...byId.values()]
 }
 
+/**
+ * The same records, read so that a damaged file cannot pass for an empty one. listKeyedSessions reads a corrupt or unreadable
+ * file as "none", which is right for the places that refuse a keyed session (they fail open on a file nobody can read) and wrong for
+ * a place that must NOT send keyed text anywhere: a corrupt file sent keyed session text to a model in a probe. A missing file is
+ * none; a file that exists and is not the store's shape throws. Session find uses this; nothing else does.
+ */
+export function listKeyedSessionsStrict(): KeyedSessionRecord[] {
+  const byId = new Map<string, KeyedSessionRecord>()
+  const file = keyedSessionsPath()
+  if (existsSync(file)) {
+    const st = lstatSync(file)
+    if (st.isSymbolicLink() || !st.isFile()) throw new Error('keyed sessions file is not a plain file')
+    const parsed = JSON.parse(readFileSync(file, 'utf8')) as Partial<KeyedSessionsFile> | null
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.sessions) || !parsed.sessions.every(isRecord)) throw new Error('keyed sessions file is not readable')
+    for (const r of parsed.sessions) byId.set(r.id, r)
+  }
+  for (const r of memory.values()) if (!byId.has(r.id)) byId.set(r.id, r)
+  return [...byId.values()]
+}
+
 /** True once anything was ever recorded. The cheap short-circuit every refusing site starts with. */
 export function anyKeyedSessions(): boolean {
   return memory.size > 0 || fileRecords().length > 0

package/server/lib/lens-gist-engines.ts

@@ -27,6 +27,7 @@ import { resolveProviderBinary } from './provider-binary.js'
 import { getOllamaCatalog, ollamaFetch, resolveOllamaOrigin } from './ollama-catalog.js'
 import { PROVIDER_QUOTA_RE } from './provider-proof.js'
 import { logTokenAudit } from './token-audit.js'
+import { normalizeRealUsage, readOneShotUsage, type EngineUsage } from './provider-usage.js'
 
 /**
  * The provider itself said its plan, session, rate or capacity limit is spent. Raised only
@@ -341,10 +342,14 @@ async function runCli(
   prompt: string,
   opts: LensGistRunOptions,
   parse: (stdout: string) => LensGistEngineRun,
+  onStdout?: (provider: 'claude' | 'codex' | 'cursor', stdout: string) => void,
 ): Promise<LensGistEngineRun> {
   const binary = binaryFor(provider)
   const result = await withScratchWorkspace(workspace =>
     runProcess(binary, args(workspace), { stdin: prompt, cwd: workspace, timeoutMs: opts.timeoutMs, label: provider, cursorIsolation: provider === 'cursor', maxOutputTokens: opts.maxOutputTokens, signal: opts.signal }))
+  // 6.97.0: its own read of the output for the audit, before the answer's parser and independent of
+  // it, so a call that failed after using tokens still reports them.
+  onStdout?.(provider, result.stdout)
   const providerText = `${result.stdout}\n${result.stderr}`
   if (result.code !== 0) {
     // Codex reports its failure as a JSON event AND a non-zero exit; the event says why.
@@ -400,14 +405,14 @@ async function runOllama(model: string, prompt: string, opts: LensGistRunOptions
   }
 }
 
-function dispatch(engine: LensGistEngineName, model: string, prompt: string, opts: LensGistRunOptions): Promise<LensGistEngineRun> {
+function dispatch(engine: LensGistEngineName, model: string, prompt: string, opts: LensGistRunOptions, onStdout: (provider: 'claude' | 'codex' | 'cursor', stdout: string) => void): Promise<LensGistEngineRun> {
   switch (engine) {
     case 'claude':
-      return runCli('claude', () => buildClaudeGistArgs(model, opts.system), prompt, opts, parseClaudeGistOutput)
+      return runCli('claude', () => buildClaudeGistArgs(model, opts.system), prompt, opts, parseClaudeGistOutput, onStdout)
     case 'codex':
-      return runCli('codex', workspace => buildCodexGistArgs(model, workspace), prompt, opts, parseCodexGistOutput)
+      return runCli('codex', workspace => buildCodexGistArgs(model, workspace), prompt, opts, parseCodexGistOutput, onStdout)
     case 'cursor':
-      return runCli('cursor', workspace => buildCursorGistArgs(model, workspace), prompt, opts, parseCursorGistOutput)
+      return runCli('cursor', workspace => buildCursorGistArgs(model, workspace), prompt, opts, parseCursorGistOutput, onStdout)
     case 'ollama':
       return runOllama(model, prompt, opts)
   }
@@ -423,10 +428,16 @@ export async function runLensGistEngine(
   const started = Date.now()
   let outputChars = 0
   let resolvedModel = model
+  let usage: EngineUsage = {}
   try {
-    const run = await dispatch(engine, model, prompt, opts)
+    const run = await dispatch(engine, model, prompt, opts, (provider, stdout) => { usage = readOneShotUsage(provider, stdout, model) })
     outputChars = run.text.length
     resolvedModel = run.model || model
+    // Ollama answers over HTTP, so it has no stdout to read; its reply already carries the counts.
+    if (engine === 'ollama') {
+      const realUsage = normalizeRealUsage({ inputTokens: run.usage?.inputTokens as number, outputTokens: run.usage?.outputTokens as number, resolvedModel: run.model })
+      if (realUsage) usage = { realUsage }
+    }
     return run
   } finally {
     logTokenAudit({
@@ -436,6 +447,7 @@ export async function runLensGistEngine(
       inputChars: prompt.length + opts.system.length,
       outputChars,
       durationMs: Date.now() - started,
+      ...usage,
     })
   }
 }