@gotcos/glasses-server 6.94.1 → 6.95.0

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 6.95.0 - Speaker merge shadow mode (opt-in, log only)
+
+2026-10-28. Compatible with COS Control 0.5.352; no Control or glasses change required.
+
+- **Why:** Mac recordings split one person into many anonymous `Voice N` labels (45 on one 60-minute call). The research canary (`community-1-fluidaudio-v1`, rounds 1 to 3) found a hybrid that fixes this safely on the reference call: production labels stay the base, and FluidAudio's offline Community-1 diarizer only proposes merges behind four gates. On the Oct 27 reference call (11 human-confirmed people) it cut fragmentation from 27 to 18 with no mixed people and the error proxy from 33% to 3%. Before any write path exists, the proposals have to be scored against Miles's own corrections, so this release only computes and logs them.
+- **What:** with shadow mode on, every Mac recording whose finalization completes is queued. When no recording, save, finalization, one-shot transcription or dictation is live, a niced child process rebuilds the whole-call timeline from the retained chunk WAVs (each verified against the sidecar's `audioSha256`), runs the Parakeet install's `fluidaudiocli process --mode offline --overlapping-segments --export-embeddings` under `sandbox-exec` with network denied, applies the research gates (a port of `hybrid.decide()`), and appends one record per meeting to `<data>/speaker-shadow/proposals.jsonl`: accepted and rejected proposals with reasons, gate values, the post-hoc anchor ratio (reported, never decisive), co-occurring named labels as hints, and listen pointers by chunk and time (no transcript text). A readable report per finished meeting lands in `<data>/speaker-shadow/reports/<YYYY-MM-DD>/<title>__<session>.md`: "N voices would become M", each merge with its gate values and listen pointers (chunk file, time and words), rejections with reasons, and name hints ("this group also holds 65 s labelled ..."). `GET /api/speaker-shadow/proposals` and `/status` read them (token required); while it is on, `/api/health` reports `speaker_shadow` (absent when off, so the health shape is unchanged by default).
+- **Log only:** nothing writes a meeting file, label, name, profile, embedding cache or correction ledger. Pinned by a data-home snapshot test (every file byte-identical after a run), an import allowlist and pinned write-call counts for every shadow module, and mutation-tested.
+- **Exact port:** the TypeScript gates reproduce the Python tool's Driving decisions exactly (45 voices to 27, 29 proposed, 18 accepted, 11 rejected, every reason string and unrounded outlier distance bit for bit), and a real-CLI run of the TypeScript pipeline on the research copies reproduces the timeline PCM and WAV SHA-256 and the full round-3 report with zero differences. Python's half-to-even rounding and %-formatting, CPython 3.12+ compensated `sum()`, dict order and code-point string order are replicated and tested against CPython 3.15 vectors.
+- **Switch, per Mac:** `POST /api/speaker-shadow/settings {"enabled":true}` (token required, no restart) saves it in `<data>/speaker-shadow/settings.json`; `COS_SPEAKER_SHADOW=1|0` pins it instead (409 `env_forced`); otherwise it is off. The package default is off for everyone, so installing this version changes nothing until a Mac turns it on.
+- **How it stops:** the switch (default off; off creates nothing; off mid-run stops the run), a daily cap (12), a breaker (3 failures pause 1 hour), a 180 s wall clock and an RSS cap (3 GB) on the whole process group, and live work, which defers it or stops a run mid-way and requeues the meeting. No LLM; no network at run time.
+- **Models:** never downloaded by the server. The pinned `FluidInference/speaker-diarization-coreml@df2625ac` files must be present (`models_missing` is logged otherwise); every file is hashed before every run and linked read-only into the CLI's private HOME.
+- **Known limits:** a recording's first run with a cold CoreML cache leaves up to four empty `NSIRD_fluidaudiocli_*` folders in the per-user temp dir (counted in the record, not removed). Recovered (orphan) Mac captures are not queued. The gates were fixed on one truth-labeled call; scoring the logged proposals is the next step.
+- **Switches:** the per-Mac setting and `COS_SPEAKER_SHADOW` (default off), `COS_SPEAKER_SHADOW_DAILY_RUNS`, `COS_SPEAKER_SHADOW_TIMEOUT_MS` (may only lower 180 s), `COS_SPEAKER_SHADOW_RSS_MB`, `COS_SPEAKER_SHADOW_MODELS`. No default-on change.
+
+## 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,81 @@ 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.
+
+### Speaker merge shadow mode (6.95.0, off by default, log only)
+
+Mac recordings can split one person across many `Voice N` labels. Shadow mode asks
+FluidAudio's offline Community-1 diarizer which of those labels belong together and
+**logs** the answer for every finished Mac recording, with a readable report per meeting,
+so the proposals can be checked by ear and against later human corrections. It changes
+nothing: no meeting file, label, name, voice profile, embedding cache or correction ledger
+is written.
+
+- **On, for this Mac only** (no restart; the token is `COS_API_TOKEN` in `~/.cos-glasses/.env`):
+
+  ```sh
+  curl -s -X POST http://127.0.0.1:3141/api/speaker-shadow/settings \
+    -H "X-Cos-Token: $(sed -n 's/^COS_API_TOKEN=//p' ~/.cos-glasses/.env)" \
+    -H 'Content-Type: application/json' -d '{"enabled":true}'
+  ```
+
+  **Off:** the same with `{"enabled":false}`. The setting lives in
+  `~/.cos-glasses/data/speaker-shadow/settings.json`. `COS_SPEAKER_SHADOW=1` or `=0` in the
+  environment pins it instead (the POST then answers `409 env_forced`). With neither, it is
+  off, and off does nothing at all: no queue, no process, no file. Meetings already finished
+  when it is turned on are not queued; turning it off mid-run stops the run.
+- **Needs:** the Parakeet install's verified `fluidaudiocli` 0.17.4, `sandbox-exec`, and the
+  pinned models from `FluidInference/speaker-diarization-coreml` at revision `df2625ac` in
+  `~/.cos-glasses/data/speaker-shadow/models/speaker-diarization/` (or
+  `COS_SPEAKER_SHADOW_MODELS`). The server never downloads them: missing or mismatched
+  models are logged as `models_missing` or `models_mismatch`. `GET /api/speaker-shadow/status`
+  shows `readiness` (models present, CLI installed and how it is trusted, sandbox). The models
+  are CC-BY-4.0 (scoped); see the repo's NOTICE.md.
+- **When:** after a Mac recording's finalization is complete. A live recording, save,
+  batch finalization, one-shot transcription or dictation defers it, and one that starts
+  mid-run stops the run and puts the meeting back in the queue.
+- **How it stops:** the switch, a daily cap (`COS_SPEAKER_SHADOW_DAILY_RUNS`, default 12), a
+  breaker (3 failures in a row pause it for 1 hour), a 180 s hard wall clock
+  (`COS_SPEAKER_SHADOW_TIMEOUT_MS` may only lower it) and an RSS cap on the whole run
+  (`COS_SPEAKER_SHADOW_RSS_MB`, default 3072). It runs in a niced child process, never on the
+  server's event loop. No LLM, and the CLI runs under `sandbox-exec` with network denied.
+- **Gates** (the research tool's, unchanged): at least 0.8 of a voice's covered speech on one
+  cluster with at least half of it covered, at least 15 s of speech, and the voice's
+  embedding centroid inside the cluster's 95th-percentile spread (leave-fragment-out). Named
+  labels and `Ext` are never merged into or out of. The anchor ratio is reported for
+  scoring and decides nothing.
+- **Read:** one report per finished Mac meeting in
+  `~/.cos-glasses/data/speaker-shadow/reports/<YYYY-MM-DD>/<title>__<session>.md`: "N voices
+  would become M", each accepted merge with its seconds, gate values and listen pointers
+  (chunk file, time, the chunk's words), rejections with reasons, and named labels sharing a
+  group as a hint only ("this group also holds 65 s labelled ..."). A meeting with no
+  proposals gets a one-line page saying why. The records are in `proposals.jsonl` beside it
+  (rotated past 8 MB) and `GET /api/speaker-shadow/proposals?limit=10&sessionId=mac_<uuid>`
+  (token required). While it is on, `/api/health` carries `speaker_shadow` (codes and counts
+  only); when off the key is absent.
+
 ### 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.95.0",
   "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": {
@@ -58,6 +58,7 @@
     "!server/scripts/routines-mutation-gate.mjs",
     "!server/scripts/routines-canary.ts",
     "!server/scripts/stt-mutation-gate.mjs",
+    "!server/scripts/speaker-shadow-mutation-gate.mjs",
     "!server/scripts/dictation-stt-mutation-gate.mjs",
     "!server/scripts/pairing-mutation-gate.mjs",
     "!server/scripts/away-hold-mutation-gate.mjs",

package/server/index.ts

@@ -74,7 +74,7 @@ import { ForkJobLedger, fileForkJobPersistence } from './lib/fork-job-ledger.js'
 import { nativeHead, realNativeHeadDeps, registerClaudeTranscriptHint } from './lib/native-head.js'
 import { threadOccupancy, holderActivity } from './lib/thread-occupancy.js'
 import { displayRouter } from './routes/display.js'
-import { transcribeStreamRouter, getActiveTranscriptionSessionCount } from './routes/transcribe-stream.js'
+import { transcribeStreamRouter, getActiveTranscriptionSessionCount, getTranscriptionSessionLiveness } from './routes/transcribe-stream.js'
 import { meetingRouter, resumeAutonomousMeetingSaves, resumeMeetingFinalizationJobs, scheduleTranscriptCleanupSweep, transcriptCleanupRouteDeps } from './routes/meeting.js'
 import { createTranscriptCleanupRouter } from './routes/transcript-cleanup.js'
 import { meetingsRouter } from './routes/meetings.js'
@@ -110,6 +110,8 @@ import { voiceRouter } from './routes/voice.js'
 import { glossaryRouter } from './routes/glossary.js'
 import { homeAreaRouter } from './routes/home-area.js'
 import { createSttSettingsRouter } from './routes/stt-settings.js'
+import { createSpeakerShadowRouter } from './routes/speaker-shadow.js'
+import { configureSpeakerShadow, speakerShadowLeaseActive } from './lib/speaker-shadow.js'
 import { setRecordingLiveProbe, startPreviewWarmLoop, stopPreviewWarmLoop } from './lib/stt-runtime.js'
 import { findPinnedCli, killParakeetChildren, sweepParakeetStaging, sweepStaleParakeetTmp } from './lib/parakeet.js'
 import { handoffsRouter } from './routes/handoffs.js'
@@ -1229,6 +1231,8 @@ app.use('/api', voiceRouter)
 app.use('/api', glossaryRouter)
 app.use('/api', homeAreaRouter)
 app.use('/api', createSttSettingsRouter({ recordingLive: () => getActiveTranscriptionSessionCount() > 0 }))
+// 6.95.0: speaker merge shadow mode, read only (GET proposals and status).
+app.use('/api', createSpeakerShadowRouter())
 app.use('/api', handoffsRouter)
 app.use('/api', recoveryRouter)
 app.use('/api', promptEditRouter)
@@ -1541,6 +1545,14 @@ listenRequiredServers(listeners).then(() => {
     // defer while a capture is live or admissions are closed.
     startMeetingMergeScheduler()
 
+    // 6.95.0: speaker merge shadow mode (off unless COS_SPEAKER_SHADOW=1; log only). Live
+    // work is a recording that is still live, or any capture or dictation lease; a drain
+    // or shutdown also holds it. Until this runs, the runner never starts a diarization.
+    configureSpeakerShadow({
+      captureActive: () => getTranscriptionSessionLiveness().live > 0 || speakerShadowLeaseActive(),
+      admissionsOpen: () => !gracefulShutdownStarted && maintenanceAdmissionsOpen(),
+    })
+
     // AFTER the imports sweep, not before: the sweep removes a killed write's
     // debris, and re-driving a pending apply into a half-written decision is
     // exactly what the sweep exists to prevent. A pending action is one a

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