@gotcos/glasses-server 6.94.1 → 6.94.3

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 6.94.3 - Search sessions by meaning, and accented speaker names
+
+2026-11-01. Pairs with COS Control 0.5.363. Control 0.5.361 and older keep working and never call the new route.
+
+**New, and off until you say yes in Control.**
+
+- `POST /api/agent-sessions/find` asks your decision model (Jev by default, SubQ if chosen) which recent sessions a few typed words refer to, and returns up to 5 rows in order of likelihood. It answers only for the provider you consented to in Control, and refuses before reading any session otherwise.
+- Each search sends the typed words, plus the title and first 150 characters of the first prompt from up to 254 recent sessions, then up to 508 if the first pass finds nothing strong. Emails, URLs, links to an IP address or localhost, home-folder paths (not every file path) and key-shaped text are removed first. Names and other details are not. SubQ keeps what it is sent. Archived, keyed and scheduled sessions are left out.
+- Its own daily caps (3M tokens per provider), breaker and `COS_SESSION_FIND=0` switch. `GET /api/decision-provider` adds `capabilities.sessionFind`.
+
+**Default-on, no setting.**
+
+- Accented speaker names now match in either Unicode form. "Yes, this is Brigitta Pólya" failed with "No chunk in this meeting is labelled" because Control's helper hands names over decomposed. Meeting and voice routes read names as NFC, compare both sides, and store new names as NFC. Merge, delete-person, calibration, the rename fan-out and the embeddings manager match a stored name in either form, and a meeting record id matches in either form too (a decomposed id from Control's helper opens the same record). Merge refuses if any stored copy of a name is below the similarity floor. Names already saved are not rewritten.
+
+No other route changes. The session list and search are unchanged.
+
+## 6.94.2 - Scoped profile matches for saved Mac recordings
+
+2026-10-28. Compatible with COS Control 0.5.352; no Control or glasses package change required.
+
+- Saved Mac recordings can match existing profiles using two independent, coherent long audio windows. Names apply only to supported spans at the unchanged .88 identity floor and .05 separation margin. This does not enroll or train profiles.
+- Durable repair evidence distinguishes machine matches from human confirmations and protects words, timestamps, existing corrections, retained audio and interrupted-save recovery. The review no longer treats one scored occurrence as proof for every repaired occurrence.
+- Existing named spans no longer prevent anonymous refinement of the remainder of a strict Mac recording. Historical recordings require explicit validated repair; upgrading does not silently rewrite them.
+- Known limitation: live numbering still loses continuity across long gaps, and some anonymous groups contain mixed voices. This release does not claim full-call deduplication, an attendee count, or recognition of every speaker.
+- Qualification: 9,704 tests passed, 14 skipped, zero failed; typecheck passed. Isolated natural-recording runs preserved all speech and timestamps, accepted exact supported spans, and withheld incoherent or insufficient matches.
+
 ## 6.94.1 - Mac filing waits for a pipeline that can title a Mac recording
 
 2026-10-27. Pairs with COS operations `sync_meetings.py` on branch `claude/mac-library-cos` (the `mac_title: 1` capability). Works with COS Control 0.5.351; Control needs no change.

package/README.md

@@ -699,6 +699,33 @@ flag a Mac rename is text only. `GET /api/health` reports `capabilities.macLiveV
 The saved meeting is relabeled by the whole-meeting pass. Live numbers are kept;
 voices the live path did not prove are numbered above them at save.
 
+### Session find by meaning (6.94.3)
+
+`POST /api/agent-sessions/find` backs ⌘K in COS Control 0.5.363. It is off until the person says yes for one provider in Control. See `docs/decision-providers.md` for what leaves the Mac, the caps and `COS_SESSION_FIND=0`.
+
+### Saved Mac profile reconciliation (6.94.2)
+
+After transcription and diarization, eligible Mac recordings receive a bounded
+local voice-profile pass. It checks up to twelve 28–30 second windows across the
+call against the existing profile cohort. Two independent windows must agree;
+each needs profile similarity of at least .88, a .05 margin over alternatives,
+and coherent full/half-window voice evidence. Only the supported audio spans
+receive a name. Other occurrences of the same live Voice number remain unchanged.
+
+This pass does not train profiles, infer identities from attendees, or change the
+transcript words and timestamps. Existing human corrections are protected. A
+durable journal preserves recovery across interrupted writes; retained audio is
+not released over an unfinished repair. Unsupported or ambiguous evidence leaves
+the existing labels in place. The pass uses one bounded CPU worker and can skip
+when its budget or prerequisites are unavailable.
+
+The speaker review distinguishes qualified machine matches from human
+confirmations. A pre-existing named span no longer prevents anonymous refinement
+of the rest of a strict Mac recording. Live voice numbering still has the window
+limits above: this release does not promise meeting-wide speaker deduplication
+or an attendee count. Older recordings require an explicit, validated repair;
+they are not silently rewritten on upgrade.
+
 ### iPhone microphone meetings (6.93.0, off by default)
 
 With `COS_IPHONE_MICROPHONE_MEETINGS=1`, HQ set to Parakeet Ultra and Parakeet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.94.1",
+  "version": "6.94.3",
   "description": "COS Glasses: self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {
@@ -52,6 +52,7 @@
     "!server/scripts/work-intake-mutation-gate.mjs",
     "!server/scripts/work-progress-mutation-gate.mjs",
     "!server/scripts/work-search-mutation-gate.mjs",
+    "!server/scripts/session-find-redact-mutation-gate.mjs",
     "!server/scripts/fact-check-mutation-gate.mjs",
     "!server/scripts/stale-session-mutation-gate.mjs",
     "!server/scripts/autonomous-save-mutation-gate.mjs",

package/server/index.ts

@@ -159,6 +159,8 @@ import { createWorkHandoffRequestsRouter } from './routes/work-handoff-requests.
 import { createSubqKeyRouter } from './routes/subq-key.js'
 import { createDecisionProviderRouter } from './routes/decision-provider.js'
 import { createJevRouter } from './routes/jev.js'
+import { createSessionFindRouter } from './routes/session-find.js'
+import { isSessionFindPost } from './lib/session-find.js'
 import { createWorkChatRouter } from './routes/work-chat.js'
 import { createWorkOrchestratorRouter } from './routes/work-orchestrator.js'
 import { createWorkLensRoundsRouter } from './routes/work-lens-rounds.js'
@@ -394,6 +396,8 @@ app.use('/api', (req, res, next) => {
   // 6.65.0: a POST that only reads (Work search: a board read and one Jev question) is not a mutation. See
   // lib/work-search.ts isReadOnlyApiPost for why holding the lease would hurt and why skipping it is safe.
   if (isReadOnlyApiPost(req.method, req.path)) return next()
+  // Session find (Control 0.5.363) reads the session store and asks a model; it writes only its own token ledger. See lib/session-find.ts.
+  if (isSessionFindPost(req.method, req.path)) return next()
   // V2 video original chunks are bounded to the advertised session size (1 MiB
   // on new sessions, 256 KiB on leftover drafts) and commit through the upload
   // registry's own generation lock. Holding the global mutation lease while
@@ -856,6 +860,8 @@ app.use('/api', createJevRouter(workReviewRuntime ? { review: async id => workRe
 app.use('/api', createDecisionProviderRouter())
 app.use('/api', createSubqKeyRouter())
 app.use('/api', createWorkSearchRouter())
+// Find a session by meaning (Control 0.5.363): consent per provider, its own ledgers and breakers (lib/session-find.ts).
+app.use('/api', createSessionFindRouter())
 app.use('/api', createWorkChatRouter())
 // 6.83.0 Work orchestrator: Control's Work snapshot, the planner input and plan usage (docs/work-orchestrator.md).
 app.use('/api', createWorkOrchestratorRouter())

package/server/lib/decision-provider.ts

@@ -154,11 +154,13 @@ export function resetSubqDecisionClients(): void { configuredSubqClients.forEach
 /** A SubQ client built outside createDecisionClient (live cues, 6.76.2) still starts clean when a new key is saved. */
 export function trackSubqDecisionClient(client: SubqDecisionClient): SubqDecisionClient { configuredSubqClients.add(client); return client }
 /** Snapshot selection per workflow request. Separate clients and cache identities prevent stale cross-provider answers. */
-export function createDecisionClient(useCase: DecisionUseCase, jev: Pick<JevClient, 'ask'> = new JevClient(), env: NodeJS.ProcessEnv = process.env): DecisionClient {
+export function createDecisionClient(useCase: DecisionUseCase, jev: Pick<JevClient, 'ask'> = new JevClient(), env: NodeJS.ProcessEnv = process.env,
+  /** Optional: a SubQ ledger file and daily cap of this feature's own. Without it SubQ uses `subq-<useCase>-usage.json` and COS_SUBQ_DAILY_TOKENS. */
+  subq: { usageFile?: string; cap?: () => number } = {}): DecisionClient {
   const clients: Partial<Record<DecisionProvider, DecisionClient>> = {}
   const snapshot = (): DecisionClient => {
     const selected = selectedDecisionProvider(useCase, env)
-    if (!clients[selected]) clients[selected] = selected === 'subq' ? new SubqDecisionClient(fetch, () => new Date(), dataPath(`subq-${useCase}-usage.json`)) : {
+    if (!clients[selected]) clients[selected] = selected === 'subq' ? new SubqDecisionClient(fetch, () => new Date(), subq.usageFile ?? dataPath(`subq-${useCase}-usage.json`), undefined, subq.cap) : {
       provider: 'jev', async ask(state, questions, estimate, options) {
         if (options?.images?.length) throw new DecisionProviderError('decision_images_unsupported')
         return { ...await jev.ask(state, questions, estimate, options), provider: 'jev' }

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'
@@ -27,12 +28,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'):''})))
@@ -472,7 +473,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 +487,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/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/mac-speaker-machine-evidence.ts

@@ -0,0 +1,111 @@
+/** Read-only bridge from a labels-only repair receipt to scoped machine claims.
+ * Capture similarities, human confirmations and profile training are untouched.
+ * Persisted bytes are trusted only after current speech/raw-map/receipt checks.
+ */
+import {
+  hashMacSpeakerDocument, hashMacSpeakerMachineBinding, validateMacSpeakerTargetEvidence,
+  type MacSpeakerMachineEvidence, type MacSpeakerRepairPlan,
+} from './mac-speaker-repair-projection.js'
+import { checkSpeakerName } from './speaker-name.js'
+type Doc = Record<string, any>
+const SHA = /^[a-f0-9]{64}$/
+const uint = (v: unknown): v is number => Number.isSafeInteger(v) && Number(v) >= 0
+const equal = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)
+function refuse(reason: string): never { throw new Error(reason) }
+export interface QualifiedMachinePosition {
+  label: string
+  rawChunkIndex: number
+  evidenceId: string
+  receiptHash: string
+  modelSHA256: string
+  profileSHA256: string
+  algorithmVersion: string
+  independentWindows: number
+  minimumSimilarity: number
+  minimumMargin: number
+}
+export interface MacMachineEvidenceRead {
+  status: 'absent' | 'qualified' | 'invalid'
+  reason?: string
+  /** Compacted positions, obtained by the strict raw join below. Never guess
+   * positions from raw indexes, text similarity or repeated phrases. */
+  positions: Map<number, QualifiedMachinePosition>
+}
+export function readMacSpeakerMachineEvidence(value: unknown): MacMachineEvidenceRead {
+  const positions = new Map<number, QualifiedMachinePosition>()
+  const doc = value as Doc | null
+  const evidence = doc?.speakerRepair?.machineEvidence as MacSpeakerMachineEvidence | undefined
+  if (!evidence) return { status: 'absent', positions }
+  try {
+    if (!doc || doc.sourceType !== 'mac_system_audio' || typeof doc.sessionId !== 'string' || !doc.sessionId.startsWith('mac_')
+      || doc.finalizationState !== 'complete' || doc.claimPending === true || doc.active === true || doc.isActive === true || doc.isMerged || doc.mergedFrom || doc.sourceSessionIds) refuse('source_not_closed_original')
+    // Deliberately global: any later human revision invalidates all machine
+    // claims until requalification. Real ledger confirmations still prevail.
+    if (evidence.version !== 1 || !uint(evidence.correctionRevision) || evidence.correctionRevision < 1 || doc.correctionRevision !== evidence.correctionRevision) refuse('revision_drift')
+    if (!SHA.test(evidence.documentBinding) || hashMacSpeakerMachineBinding(doc) !== evidence.documentBinding) refuse('speech_binding_mismatch')
+    const receipt = evidence.receipt
+    if (!receipt || receipt.version !== 1 || !SHA.test(receipt.receiptHash) || receipt.id !== doc.speakerRepair.id || receipt.evidenceHash !== doc.speakerRepair.evidenceHash
+      || !SHA.test(receipt.evidenceHash) || !Array.isArray(receipt.assignments) || !receipt.assignments.length || receipt.assignments.length > 65536
+      || !Array.isArray(receipt.patches) || receipt.patches.length > 1_000_000) refuse('receipt_invalid')
+    const { receiptHash, ...unsigned } = receipt
+    if (hashMacSpeakerDocument(unsigned) !== receiptHash) refuse('receipt_invalid')
+    if (!Array.isArray(doc.chunks) || !Array.isArray(doc.chunkEntries) || doc.chunks.length > 65536 || doc.chunkEntries.length > 65536) refuse('raw_map_ambiguous')
+    const byRaw = new Map<number, { position: number; chunk: Doc }>()
+    let position = 0, previous = -1
+    for (const entry of doc.chunkEntries) {
+      if (!entry || !uint(entry.chunkIndex) || entry.chunkIndex <= previous) refuse('raw_map_ambiguous')
+      previous = entry.chunkIndex
+      if (typeof entry.chunk?.text !== 'string' || !entry.chunk.text.trim()) continue
+      const chunk = doc.chunks[position]
+      if (!chunk || ['text', 'speaker', 'elapsed', 'audioDurationMs', 'audioSha256', 'segments', 'finalSegments', 'words'].some(key => !equal(chunk[key], entry.chunk[key]))) refuse('raw_map_ambiguous')
+      byRaw.set(entry.chunkIndex, { position, chunk }); position++
+    }
+    if (position !== doc.chunks.length) refuse('raw_map_ambiguous')
+    const source = structuredClone(doc)
+    // Reconstruct only the original label surfaces from the validated receipt.
+    // Lifecycle/prose/profile metadata are never inverse-applied by this reader.
+    const paths = new Set<string>()
+    for (const patch of [...receipt.patches].reverse()) {
+      if (!Array.isArray(patch.path) || !patch.path.length || patch.path.length > 8 || patch.path.some(k => !['string', 'number'].includes(typeof k) || ['__proto__', 'prototype', 'constructor'].includes(String(k)))) refuse('receipt_invalid')
+      const rootSpeakers = patch.path.length === 1 && patch.path[0] === 'speakers'
+      if (!rootSpeakers && (!['chunks', 'chunkEntries', 'batchSegments'].includes(String(patch.path[0])) || patch.path.at(-1) !== 'speaker')) refuse('receipt_invalid')
+      const key = JSON.stringify(patch.path)
+      if (paths.has(key)) refuse('receipt_invalid')
+      paths.add(key)
+      let row = source
+      for (const part of patch.path.slice(0, -1)) {
+        if (!row || typeof row !== 'object' || !Object.hasOwn(row, part)) refuse('receipt_invalid')
+        row = row[part]
+      }
+      const last = patch.path.at(-1)!
+      if (!row || !equal(row[last], patch.after)) refuse('receipt_label_drift')
+      if (patch.before === undefined) delete row[last]
+      else row[last] = structuredClone(patch.before)
+    }
+    if (!evidence.rawAudioSampleCounts || typeof evidence.rawAudioSampleCounts !== 'object') refuse('receipt_invalid')
+    const plan: MacSpeakerRepairPlan = { id: receipt.id, evidenceHash: receipt.evidenceHash, expectedDocumentHash: receipt.beforeHash,
+      protectedRawChunkIndices: [], rawAudioSampleCounts: evidence.rawAudioSampleCounts, assignments: receipt.assignments, withheldBatchWords: receipt.withheldBatchWords }
+    const seen = new Set<number>()
+    for (const assignment of receipt.assignments) {
+      if (!uint(assignment.rawChunkIndex) || seen.has(assignment.rawChunkIndex)) refuse('receipt_invalid')
+      seen.add(assignment.rawChunkIndex)
+      const proof = assignment.targetEvidence
+      if (!proof) continue // Anonymous recurrence cannot authorize a name.
+      if (!checkSpeakerName(assignment.to).ok || !proof.windows?.length || proof.windows.length > 128) refuse('proof_rejected')
+      try { validateMacSpeakerTargetEvidence(source, plan, assignment) } catch { refuse('proof_rejected') }
+      const current = byRaw.get(assignment.rawChunkIndex)
+      if (!current || current.chunk.speaker !== assignment.to || !SHA.test(current.chunk.audioSha256)) refuse('receipt_label_drift')
+      const restored = source.chunkEntries.find((entry: Doc) => entry.chunkIndex === assignment.rawChunkIndex)?.chunk
+      if (restored?.speaker !== assignment.from) refuse('receipt_label_drift')
+      positions.set(current.position, {
+        label: assignment.to, rawChunkIndex: assignment.rawChunkIndex, evidenceId: assignment.evidenceId, receiptHash,
+        modelSHA256: proof.modelSha256, profileSHA256: proof.profileSha256, algorithmVersion: proof.algorithmVersion,
+        independentWindows: proof.windows.length, minimumSimilarity: Math.min(...proof.windows.map(w => w.similarity)),
+        minimumMargin: Math.min(...proof.windows.map(w => w.similarity - w.runnerUpSimilarity)),
+      })
+    }
+    return { status: 'qualified', positions }
+  } catch (error) {
+    return { status: 'invalid', positions: new Map(), reason: error instanceof Error ? error.message : 'proof_rejected' }
+  }
+}

package/server/lib/mac-speaker-profile-extractor.ts

@@ -0,0 +1,41 @@
+/** Isolated, killable read-only extraction. Native model work never runs on the
+ * server event loop and never reaches recognition/enrollment/calibration APIs. */
+import { spawn } from 'node:child_process'
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const worker = `
+const fs = require('node:fs');
+const sherpa = require(process.argv[1]);
+const model = process.argv[2];
+const extractor = new sherpa.SpeakerEmbeddingExtractor({model, numThreads:1, provider:'cpu'});
+let size=0, parts=[];
+process.stdin.on('data', b=>{size+=b.length;if(size>960000)process.exit(2);parts.push(b)});
+process.stdin.on('end',()=>{
+ const pcm=Buffer.concat(parts); if(pcm.length<896000||pcm.length%2)process.exit(3);
+ const embed=(b)=>{const samples=new Float32Array(b.length/2);for(let i=0;i<samples.length;i++)samples[i]=b.readInt16LE(i*2)/32768;
+ const stream=extractor.createStream();stream.acceptWaveform({samples,sampleRate:16000});stream.inputFinished();
+ if(!extractor.isReady(stream))throw Error('not ready');return Array.from(extractor.compute(stream));};
+ const half=Math.floor(pcm.length/4)*2; process.stdout.write(JSON.stringify([embed(pcm),embed(pcm.subarray(0,half)),embed(pcm.subarray(half))]));
+});`
+export async function extractQualifiedMacWindow(pcm: Buffer, modelPath: string, timeoutMs: number, deps: { spawn?: typeof spawn; modulePath?: string } = {}): Promise<readonly number[][] | null> {
+  if (pcm.length < 896000 || pcm.length > 960000 || pcm.length % 2 || timeoutMs <= 0) return null
+  let modulePath: string
+  try { modulePath = deps.modulePath ?? require.resolve('sherpa-onnx-node') } catch { return null }
+  return new Promise(resolve => {
+    const child = (deps.spawn ?? spawn)(process.execPath, ['-e', worker, modulePath, modelPath], { stdio: ['pipe', 'pipe', 'pipe'] })
+    const output: Buffer[] = []; let size = 0, settled = false, aborted = false
+    const finish = (result: readonly number[][] | null) => { if (settled) return; settled = true; clearTimeout(timer); resolve(result) }
+    const abort = () => { aborted = true; child.kill('SIGKILL') }
+    // Keep ownership until close confirms native termination. Releasing on
+    // kill() alone permits a second native job while the first still exits.
+    const timer = setTimeout(abort, timeoutMs)
+    child.stdout.on('data', b => { size += b.length; if (size > 131072) abort(); else if (!aborted) output.push(Buffer.from(b)) })
+    // Drain diagnostics without retaining native stderr or logging private input.
+    child.stderr.on('data', () => {})
+    child.on('error', () => { aborted = true; if (!child.pid) finish(null); else child.kill('SIGKILL') }); child.stdin.on('error', () => {})
+    child.on('close', code => {
+      try { const rows = JSON.parse(Buffer.concat(output).toString()); finish(!aborted && code === 0 && Array.isArray(rows) && rows.length === 3 ? rows : null) } catch { finish(null) }
+    })
+    child.stdin.end(pcm)
+  })
+}