@gotcos/glasses-server 6.94.1 → 6.94.2

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 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,29 @@ 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.
 
+### 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.2",
   "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": {

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)
+  })
+}

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

@@ -0,0 +1,257 @@
+/** Qualified, named, exact-window finalization only. No anonymous merging,
+ * enrollment, guessed participant count, model-channel naming or lower floor.
+ * A durable attempt and two-file before/after journal make retries fail closed. */
+import { createHash } from 'node:crypto'
+import { existsSync, lstatSync, readFileSync } from 'node:fs'
+import { readFile, stat } from 'node:fs/promises'
+import { join, resolve } from 'node:path'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { MAC_CAPTURE_ID } from './mac-recording.js'
+import { dataPath } from './data-dir.js'
+import { readPcm16Mono, wavHeader } from './nemotron-segments.js'
+import { planMacSpeakerWindows, qualifyMacSpeakerWindows, type VerifiedMacRawChunk, type MacWindowEmbeddingReceipt } from './mac-speaker-windows.js'
+import { normalizedSpeakerCosine, type MacSpeakerProfile } from './mac-speaker-reconcile.js'
+import { hashMacSpeakerDocument, hashMacSpeakerMachineBinding, projectMacSpeakerRepair, type MacProfileMatchEvidence, type MacSpeakerRepairAssignment, type MacSpeakerWordBinding } from './mac-speaker-repair-projection.js'
+import { boundWords, renderBoundSpeakerLabels, renderMarkdown } from './mac-speaker-repair-render.js'
+import { readMacSpeakerMachineEvidence } from './mac-speaker-machine-evidence.js'
+import { extractQualifiedMacWindow } from './mac-speaker-profile-extractor.js'
+type Doc = Record<string, any>
+const sha = (v: string | Buffer) => createHash('sha256').update(v).digest('hex')
+const yieldLoop = () => new Promise<void>(r => setImmediate(r))
+const MAX_WINDOWS = 12, MAX_RAW = 2048, MAX_MS = 90_000
+export const MAX_PROFILE_BYTES = 32 * 1024 * 1024
+function fail(reason: string): never { throw new Error(`qualified Mac profile pass: ${reason}`) }
+export interface QualifiedMacProfileInput { sidecarPath: string; meetingPath: string; audioDir: string; resumeOnly?: boolean }
+export interface QualifiedMacProfileDeps {
+  /** Test seams never invoke native inference. Production freezes the complete cohort. */
+  runtime?: () => Promise<{ modelPath: string; profilesPath: string } | null>
+  extract?: (pcm: Buffer, modelPath: string, timeoutMs: number) => Promise<readonly number[][] | null>
+  ledgerPath?: (sessionId: string) => string
+  now?: () => number
+  beforeCommit?: () => void
+  afterWrite?: (index: number) => void
+}
+export interface QualifiedMacProfileOutcome { status: 'applied' | 'skipped'; reason: string; assignments?: number }
+interface Image { path: string; before: string; after: string }
+interface Journal { version: 1; status: 'attempted' | 'prepared' | 'complete'; sessionId: string; sourceSidecarHash: string; imageBinding?: string; rawBindings?: Array<{ name: string; sha256: string }>; reason?: string; images?: Image[]; ledgerPath: string; ledgerHash: string | null; profilePath: string; profileHash: string; modelPath: string; modelHash: string }
+const active = new Set<string>()
+let extractionBusy = false
+function regularRead(path: string, max = 12 * 1024 * 1024): string {
+  const s = lstatSync(path)
+  if (!s.isFile() || s.isSymbolicLink() || s.size > max) fail('unsafe or oversized file')
+  return readFileSync(path, 'utf8')
+}
+function ledgerHash(path: string): string | null {
+  try { return sha(regularRead(path, 4 * 1024 * 1024)) } catch (e) { if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null; throw e }
+}
+function ledgerClear(path: string): boolean {
+  const digest = ledgerHash(path)
+  if (digest === null) return true
+  // Every historical human action (including intent/revert) protects the capture.
+  return regularRead(path).trim() === ''
+}
+
+function strictPcm(wav: Buffer) {
+  if (wav.length < 44 || wav.readUInt32LE(4) !== wav.length - 8 || wav.toString('ascii', 12, 16) !== 'fmt ' || wav.readUInt32LE(16) !== 16 || wav.readUInt16LE(20) !== 1 || wav.readUInt16LE(22) !== 1 || wav.readUInt32LE(24) !== 16000 || wav.readUInt32LE(28) !== 32000 || wav.readUInt16LE(32) !== 2 || wav.readUInt16LE(34) !== 16 || wav.toString('ascii', 36, 40) !== 'data' || wav.readUInt32LE(40) !== wav.length - 44 || (wav.length - 44) % 2) return null
+  return readPcm16Mono(wav)
+}
+async function runtimeDefault() {
+  const { speakerModelState } = await import('./speaker-embeddings.js')
+  const model = speakerModelState()
+  return model.state === 'active' && model.path ? { modelPath: model.path, profilesPath: dataPath('voice-profiles.json') } : null
+}
+function recover(journalPath: string, journal: Journal, input: QualifiedMacProfileInput, deps: QualifiedMacProfileDeps): QualifiedMacProfileOutcome {
+  if (journal.version !== 1 || !MAC_CAPTURE_ID.test(journal.sessionId) || journal.images?.length !== 2
+    || journal.images[0].path !== resolve(input.meetingPath) || journal.images[1].path !== resolve(input.sidecarPath)
+    || ledgerHash(journal.ledgerPath) !== journal.ledgerHash) fail('journal or human history drift')
+  if (journal.status !== 'complete' && (sha(regularRead(journal.profilePath, MAX_PROFILE_BYTES)) !== journal.profileHash || sha(readFileSync(journal.modelPath)) !== journal.modelHash)) fail('journal profile/model drift')
+  const images = journal.images
+  if (journal.imageBinding !== hashMacSpeakerDocument(images) || sha(images[1].before) !== journal.sourceSidecarHash) fail('journal image integrity drift')
+  const beforeDoc = JSON.parse(images[1].before), afterDoc = JSON.parse(images[1].after)
+  const proofRead = readMacSpeakerMachineEvidence({ ...afterDoc, finalizationState: 'complete' })
+  if (beforeDoc.sessionId !== journal.sessionId || afterDoc.sessionId !== journal.sessionId || proofRead.status !== 'qualified' || !proofRead.positions.size || !afterDoc.speakerRepair?.machineEvidence?.receipt) fail('journal proof rejected')
+  const expectedSequence = boundWords(beforeDoc, afterDoc)
+  if (renderBoundSpeakerLabels(beforeDoc.batchTranscript, expectedSequence) !== afterDoc.batchTranscript || renderMarkdown(images[0].before, expectedSequence) !== images[0].after) fail('journal word invariant drift')
+  if (journal.status !== 'complete') {
+    if (!Array.isArray(journal.rawBindings) || !journal.rawBindings.length || journal.rawBindings.length > MAX_RAW) fail('journal raw bindings invalid')
+    for (const raw of journal.rawBindings) { if (!/^chunk_\d{4,}\.wav$/.test(raw.name) || sha(readFileSync(join(input.audioDir, raw.name))) !== raw.sha256) fail('journal raw drift') }
+  }
+  const current = images.map(image => regularRead(image.path))
+  if (journal.status !== 'complete' && current.some((bytes, i) => bytes !== images[i].before && bytes !== images[i].after)) fail('journal precondition drift')
+  // Completed transactions never reapply over a later change; the exact speech
+  // binding/revision guard in readers separately invalidates later stale claims.
+  if (journal.status === 'complete') {
+    if (current.every((bytes, i) => bytes === images[i].after)) return { status: 'applied', reason: 'already_applied' }
+    const saved = JSON.parse(images[1].after), currentDoc = JSON.parse(current[1])
+    if (hashMacSpeakerMachineBinding(currentDoc) === hashMacSpeakerMachineBinding(saved) && currentDoc.correctionRevision === saved.correctionRevision && readMacSpeakerMachineEvidence(currentDoc).status === 'qualified') return { status: 'applied', reason: 'already_applied' }
+    fail('completed journal changed')
+  }
+  for (let i = 0; i < images.length; i++) {
+    if (ledgerHash(journal.ledgerPath) !== journal.ledgerHash) fail('human history changed')
+    for (let j = 0; j < images.length; j++) {
+      const bytes = regularRead(images[j].path)
+      if (bytes !== (j < i ? images[j].after : current[j])) fail('transaction changed during commit')
+    }
+    if (current[i] !== images[i].after) durableAtomicWriteFileSync(images[i].path, images[i].after)
+    deps.afterWrite?.(i)
+  }
+  if (images.some(image => regularRead(image.path) !== image.after)) fail('postimage changed')
+  journal.status = 'complete'; durableAtomicWriteFileSync(journalPath, JSON.stringify(journal))
+  return { status: 'applied', reason: 'qualified_profile' }
+}
+/** Six deterministic adjacent pairs spread across the entire call. Scheduling
+ * hints never add identity votes; each pair still needs acoustic qualification. */
+export function selectQualifiedProfileWindows<T>(windows: readonly T[]): T[] {
+  if (windows.length <= MAX_WINDOWS) return [...windows]
+  const indexes = new Set<number>()
+  for (let i = 0; i < MAX_WINDOWS / 2; i++) { const index = Math.floor(i * (windows.length - 2) / (MAX_WINDOWS / 2 - 1)); indexes.add(index); indexes.add(index + 1) }
+  return [...indexes].sort((a, b) => a - b).map(i => windows[i])
+}
+/** Called twice by the finalizer: resumeOnly BEFORE any ASR retry, and ordinary
+ * mode AFTER ASR+diarization, before raw deletion or downstream copies/sync. */
+export async function runQualifiedMacProfilePass(input: QualifiedMacProfileInput, deps: QualifiedMacProfileDeps = {}): Promise<QualifiedMacProfileOutcome> {
+  const key = resolve(input.sidecarPath), journalPath = `${key}.speaker-profile-pass.json`
+  if (active.has(key)) return { status: 'skipped', reason: 'active' }
+  active.add(key)
+  let ownsExtraction = false
+  try {
+    if (existsSync(journalPath)) {
+      const prior = JSON.parse(regularRead(journalPath, 64 * 1024 * 1024)) as Journal
+      if (prior.status === 'prepared' || prior.status === 'complete') return recover(journalPath, prior, input, deps)
+      if (prior.version !== 1 || prior.status !== 'attempted') fail('invalid attempt journal')
+      return { status: 'skipped', reason: prior.reason ?? 'previous_attempt' }
+    }
+    if (input.resumeOnly) return { status: 'skipped', reason: 'no_transaction' }
+    const now = deps.now ?? Date.now, deadline = now() + MAX_MS
+    const budget = () => { if (now() >= deadline) fail('budget_exhausted') }
+    const beforeSidecar = regularRead(key), source = JSON.parse(beforeSidecar) as Doc
+    if (source.sourceType !== 'mac_system_audio' || !MAC_CAPTURE_ID.test(source.sessionId) || !['batch_pending', 'ops_pending', 'complete'].includes(source.finalizationState)
+      || source.claimPending || source.active || source.isActive || source.status === 'recording' || source.isMerged || source.mergedFrom || source.sourceSessionIds || source.supersededBy || source.superseded || source.speakerRepair
+      || (source.correctionRevision ?? 0) !== 0 || source.batchApplied !== true || !Array.isArray(source.batchSegments) || !Array.isArray(source.chunkEntries) || source.chunkEntries.length > MAX_RAW) return { status: 'skipped', reason: 'source_ineligible' }
+    const ledgerPath = deps.ledgerPath?.(source.sessionId) ?? dataPath('meeting-corrections', `${source.sessionId}.jsonl`)
+    if (!ledgerClear(ledgerPath)) return { status: 'skipped', reason: 'human_corrected' }
+    const ledger = ledgerHash(ledgerPath), beforeMarkdown = regularRead(input.meetingPath, 4 * 1024 * 1024)
+    const runtime = await (deps.runtime ?? runtimeDefault)()
+    if (!runtime) return { status: 'skipped', reason: 'model_unavailable' }
+    const profileBytes = regularRead(runtime.profilesPath, MAX_PROFILE_BYTES), profileSHA256 = sha(profileBytes)
+    const cohort = JSON.parse(profileBytes).profiles
+    if (!Array.isArray(cohort) || !cohort.length || cohort.length > 1024) return { status: 'skipped', reason: 'profile_cohort_invalid' }
+    if ((await stat(runtime.modelPath)).size > 128 * 1024 * 1024) return { status: 'skipped', reason: 'model_oversized' }
+    const modelBytes = await readFile(runtime.modelPath); budget()
+    if (modelBytes.length > 128 * 1024 * 1024) return { status: 'skipped', reason: 'model_oversized' }
+    if (cohort.some(p => !p || typeof p.name !== 'string' || !Array.isArray(p.embeddings) || !p.embeddings.length || p.embeddings.length > 128 || p.embeddings.some((r: unknown) => !Array.isArray(r) || r.length !== 192 || r.some(v => !Number.isFinite(v)))) || cohort.reduce((n, p) => n + p.embeddings.length, 0) > 8192) return { status: 'skipped', reason: 'profile_cohort_invalid' }
+    const modelSHA256 = sha(modelBytes)
+    const profiles: MacSpeakerProfile[] = cohort.map(p => ({ name: p.name, embeddings: p.embeddings, profileSHA256 }))
+    // One bounded native profile job server-wide. A concurrent capture keeps
+    // its saved labels rather than multiplying native processes/CPU load.
+    if (extractionBusy) return { status: 'skipped', reason: 'profile_lane_busy' }
+    extractionBusy = true; ownsExtraction = true
+    const journal: Journal = { version: 1, status: 'attempted', sessionId: source.sessionId, sourceSidecarHash: sha(beforeSidecar), ledgerPath, ledgerHash: ledger, profilePath: resolve(runtime.profilesPath), profileHash: profileSHA256, modelPath: resolve(runtime.modelPath), modelHash: modelSHA256 }
+    durableAtomicWriteFileSync(journalPath, JSON.stringify(journal))
+    try {
+      const raw: VerifiedMacRawChunk[] = [], counts: Record<string, number> = {}
+      for (const entry of source.chunkEntries) {
+        budget()
+        if (!Number.isSafeInteger(entry.chunkIndex) || entry.chunkIndex < 0) fail('invalid raw index')
+        const path = join(input.audioDir, `chunk_${String(entry.chunkIndex).padStart(4, '0')}.wav`)
+        const info = await stat(path)
+        if (!info.isFile() || info.size > 960044) fail('invalid raw file')
+        const wav = await readFile(path), audioSHA256 = sha(wav), pcm = strictPcm(wav)
+        if (!pcm || pcm.sampleRate !== 16000 || wav.length > 960044 || (entry.chunk.audioSha256 !== undefined && audioSHA256 !== entry.chunk.audioSha256)) fail('raw hash/format drift')
+        const sampleCount = pcm.pcm.length / 2
+        counts[entry.chunkIndex] = sampleCount
+        raw.push({ chunkIndex: entry.chunkIndex, audioSHA256, pcmSHA256: sha(pcm.pcm), sampleRate: 16000, channels: 1, format: 'pcm_s16le', sampleCount, verified: true })
+        if (raw.length % 4 === 0) await yieldLoop()
+      }
+      const plan = planMacSpeakerWindows({ sidecar: source as any, rawChunks: raw, correctionHistory: 'verified-clear' })
+      plan.windows = selectQualifiedProfileWindows(plan.windows)
+      if (plan.windows.length < 2) fail('insufficient_long_windows')
+      const receipts: MacWindowEmbeddingReceipt[] = []
+      for (const window of plan.windows) {
+        budget(); await yieldLoop()
+        const buffers: Buffer[] = []
+        for (const s of window.sources) {
+          const wav = await readFile(join(input.audioDir, `chunk_${String(s.chunkIndex).padStart(4, '0')}.wav`)), pcm = strictPcm(wav)
+          if (sha(wav) !== s.audioSHA256 || !pcm || sha(pcm.pcm) !== s.pcmSHA256) fail('raw changed before extraction')
+          buffers.push(pcm.pcm)
+        }
+        const pcm = Buffer.concat(buffers), wav = Buffer.concat([wavHeader(pcm.length), pcm])
+        const vectors = await (deps.extract ?? extractQualifiedMacWindow)(pcm, runtime.modelPath, Math.min(15_000, deadline - now()))
+        budget()
+        if (!vectors || vectors.length !== 3) continue
+        receipts.push({ windowId: window.id, windowBindingSHA256: window.bindingSHA256, modelSHA256, audioSHA256: sha(wav), pcmSHA256: sha(pcm), sampleCount: pcm.length / 2, embedding: vectors[0], halfEmbeddings: [vectors[1], vectors[2]] })
+      }
+      const qualified = qualifyMacSpeakerWindows(plan, receipts, profiles, modelSHA256)
+      const byWindow = new Map(plan.windows.map(w => [w.id, w])), byReceipt = new Map(receipts.map(r => [r.windowId, r]))
+      const assignments: MacSpeakerRepairAssignment[] = []
+      const groups = new Map<string, typeof qualified>()
+      for (const c of qualified) if (c.status === 'qualified' && c.profileName) { const k = `${c.acousticIdentity}:${c.profileName}`; groups.set(k, [...(groups.get(k) ?? []), c]) }
+      for (const group of groups.values()) {
+        if (group.length < 2) continue
+        const profile = profiles.find(p => p.name === group[0].profileName)!
+        // Same raw-average centroid used by the production recognizer. The
+        // qualifier already rejected corrupt/mismatched rows and profile ties.
+        const rows = profile.embeddings, dimensions = rows[0].length
+        const centroid = Array.from({ length: dimensions }, (_, i) => rows.reduce((n, r) => n + r[i] / rows.length, 0))
+        const centroids = profiles.map(p => ({ name: p.name, vector: Array.from({ length: dimensions }, (_, i) => p.embeddings.reduce((n, r) => n + r[i] / p.embeddings.length, 0)) }))
+        const proof: MacProfileMatchEvidence = { kind: 'profile-match', profileName: profile.name, profileSha256: profileSHA256, modelSha256: modelSHA256, algorithmVersion: 'qualified-long-window-profile-v1',
+          crossWindowCosines: group.map(a => group.map(b => normalizedSpeakerCosine(byReceipt.get(a.windowId)!.embedding, byReceipt.get(b.windowId)!.embedding)!)),
+          windows: group.map(c => { const w = byWindow.get(c.windowId)!, r = byReceipt.get(c.windowId)!; return { id: w.id, captureStartSample: w.startSample, captureEndSample: w.endSample, pcmSha256: r.pcmSHA256,
+            similarity: normalizedSpeakerCosine(r.embedding, centroid)!, runnerUpSimilarity: Math.max(-1, ...centroids.filter(p => p.name !== profile.name).map(p => normalizedSpeakerCosine(r.embedding, p.vector)!)),
+            rawChunks: w.sources.map(s => ({ rawChunkIndex: s.chunkIndex, audioSha256: s.audioSHA256, sampleCount: s.sampleCount })) } }) }
+        for (const c of group) for (const s of byWindow.get(c.windowId)!.sources) assignments.push({ rawChunkIndex: s.chunkIndex, from: c.originalVoiceHint, to: profile.name, evidenceId: c.acousticIdentity!, targetEvidence: proof, batchWords: [] })
+      }
+      if (!assignments.length) fail('no_qualified_profile')
+      const selected = new Map(assignments.map(a => [a.rawChunkIndex, a])), withheldBatchWords: Array<MacSpeakerWordBinding & { reason: 'outside-qualified-span' }> = []
+      source.batchSegments.forEach((segment: Doc, segmentIndex: number) => {
+        const spans: { raw: number; start: number; end: number }[] = []; let end = 0
+        if (!Number.isSafeInteger(segment.startChunkIdx) || !Number.isSafeInteger(segment.endChunkIdx) || segment.endChunkIdx - segment.startChunkIdx > MAX_RAW) fail('invalid batch range')
+        for (let raw = segment.startChunkIdx; raw <= segment.endChunkIdx; raw++) { if (!counts[raw]) fail('missing batch raw clock'); spans.push({ raw, start: end, end: end + counts[raw] / 16000 }); end += counts[raw] / 16000 }
+        segment.speakerWords.forEach((word: Doc, wordIndex: number) => {
+          const overlaps = spans.filter(s => word.end === word.start ? word.start >= s.start && word.start < s.end : word.start < s.end && word.end > s.start)
+          if (!overlaps.some(s => selected.has(s.raw))) return
+          const binding = { segmentIndex, wordIndex, word: word.word, from: word.speaker, start: word.start, end: word.end }
+          if (overlaps.some(s => !selected.has(s.raw))) withheldBatchWords.push({ ...binding, reason: 'outside-qualified-span' })
+          else if (new Set(overlaps.map(s => selected.get(s.raw)!.to)).size === 1) selected.get(overlaps[0].raw)!.batchWords.push(binding)
+          else fail('crossed identities')
+        })
+      })
+      budget()
+      const staging = { ...source, finalizationState: 'complete' }, repairPlan = { id: `profile_${sha(beforeSidecar).slice(0, 24)}`, evidenceHash: hashMacSpeakerDocument(receipts), expectedDocumentHash: hashMacSpeakerDocument(staging), protectedRawChunkIndices: [], rawAudioSampleCounts: counts, assignments, withheldBatchWords }
+      const projected = projectMacSpeakerRepair(staging, repairPlan), after = projected.doc, sequence = boundWords(staging, after)
+      after.batchTranscript = renderBoundSpeakerLabels(source.batchTranscript, sequence)
+      const afterMarkdown = renderMarkdown(beforeMarkdown, sequence)
+      after.finalizationState = source.finalizationState
+      after.correctionRevision = 1; after.lifecycleRevision = (source.lifecycleRevision ?? 0) + 1
+      after.speakerRepair = { version: 1, id: repairPlan.id, evidenceHash: repairPlan.evidenceHash, machineEvidence: { version: 1, correctionRevision: 1, documentBinding: hashMacSpeakerMachineBinding(after), receipt: projected.receipt, rawAudioSampleCounts: counts } }
+      after.speakerProfilePass = { version: 1, status: 'applied', windows: receipts.length, assignments: assignments.length }
+      deps.beforeCommit?.(); budget()
+      for (const c of assignments) {
+        const rawBytes = await readFile(join(input.audioDir, `chunk_${String(c.rawChunkIndex).padStart(4, '0')}.wav`))
+        if (sha(rawBytes) !== raw.find(r => r.chunkIndex === c.rawChunkIndex)!.audioSHA256) fail('raw changed before commit')
+      }
+      const currentModelHash = sha(await readFile(runtime.modelPath))
+      if (regularRead(key) !== beforeSidecar || regularRead(input.meetingPath) !== beforeMarkdown || ledgerHash(ledgerPath) !== ledger || sha(regularRead(runtime.profilesPath, MAX_PROFILE_BYTES)) !== profileSHA256 || currentModelHash !== modelSHA256) fail('source/profile/model/history drift')
+      journal.images = [{ path: resolve(input.meetingPath), before: beforeMarkdown, after: afterMarkdown }, { path: key, before: beforeSidecar, after: JSON.stringify(after, null, 2) + '\n' }]
+      journal.imageBinding = hashMacSpeakerDocument(journal.images)
+      journal.rawBindings = assignments.map(a => ({ name: `chunk_${String(a.rawChunkIndex).padStart(4, '0')}.wav`, sha256: raw.find(r => r.chunkIndex === a.rawChunkIndex)!.audioSHA256 }))
+      journal.status = 'prepared'; durableAtomicWriteFileSync(journalPath, JSON.stringify(journal))
+      const outcome = recover(journalPath, journal, input, deps)
+      return { ...outcome, assignments: assignments.length }
+    } catch (error) {
+      // Prepared transactions must be retried before ASR, never reported as an
+      // ordinary no-match that permits downstream filing of mixed generations.
+      if (journal.status === 'prepared') throw error
+      journal.reason = error instanceof Error ? error.message : 'unqualified'; durableAtomicWriteFileSync(journalPath, JSON.stringify(journal))
+      return { status: 'skipped', reason: journal.reason }
+    }
+  } catch (error) {
+    // Recovery failures must block ASR/copying; ordinary unavailable resources
+    // leave the already saved recording alone.
+    if (existsSync(journalPath)) {
+      const saved = JSON.parse(regularRead(journalPath, 64 * 1024 * 1024)) as Journal
+      if (saved.status === 'prepared' || saved.status === 'complete') throw error
+    }
+    return { status: 'skipped', reason: error instanceof Error ? error.message : 'unavailable' }
+  } finally { if (ownsExtraction) extractionBusy = false; active.delete(key) }
+}

package/server/lib/mac-speaker-protection.ts

@@ -0,0 +1,22 @@
+/** One conservative predicate for automatic acoustic support and label writes.
+ * Human markers protect even still-anonymous labels and unlabeled ASR words. */
+export function isMacSpeakerHumanProtected(value: unknown): boolean {
+  if (!value || typeof value !== 'object') return false
+  const row = value as Record<string, unknown>
+  if (['speakerCorrectionBatchId', 'speakerCorrectionId', 'manualSpeaker', 'speakerManuallyAssigned', 'confirmedByHuman', 'manuallyAssigned', 'manuallyCorrected'].some(key => !!row[key])) return true
+  return ['speakerOrigin', 'speakerSource', 'speakerPolicy', 'speakerProvenance', 'source'].some(key =>
+    typeof row[key] === 'string' && /(?:manual|human|correction|confirmed)/i.test(row[key] as string))
+}
+/** Inspect every stored chunk representation before using any of its audio as
+ * positive evidence. Malformed declared surfaces also fail closed. */
+export function hasMacSpeakerProtectedRows(value: unknown): boolean {
+  if (!value || typeof value !== 'object') return true
+  const chunk = value as Record<string, unknown>
+  if (isMacSpeakerHumanProtected(chunk)) return true
+  for (const key of ['segments', 'finalSegments', 'words']) {
+    if (chunk[key] === undefined) continue
+    if (!Array.isArray(chunk[key])) return true
+    if ((chunk[key] as unknown[]).some(row => !row || typeof row !== 'object' || isMacSpeakerHumanProtected(row))) return true
+  }
+  return false
+}