Phases 2-6: detection, visual timeline, backend hand-off, voiceprints

Phase 2 (call detection): CallDetector using CoreAudio per-process mic
attribution (anarlog technique) — robust start+stop for Zoom/Teams/Signal/Meet,
ignoring our own recording; auto-record toggle. Built; pending live multi-app
confirmation by the user.

Phase 3 (visual timeline foundation): AppAdapter protocol + SpeakerObservation,
TimelineBuilder (hysteresis/overlap/self-merge/aliases), VisualTimeline (schema
1.1), TextRecognizer (Vision OCR), FrameSampler + GridCallAnalyzer (name OCR +
saturated-highlight active-speaker attribution), SignalAdapter, VisualObserver
(window capture; frames released, never saved; minimized->visual_gap, idle != gap).
Synthetic-frame tested; adapter geometry pending real Signal fixtures + live
VisualObserver validation.

Phase 5 (backend hand-off): SparkControlClient (multipart label-merge, sequential,
TLS-skip, 503 Retry-After/413), SessionPackager (chunk plan + WAV slice + timeline
slice/rebase), TranscriptAssembler + SpeakersFile, TranscriptPipeline. Validated
END-TO-END against the live backend (chunk -> label-merge -> speakers.json).

Phase 6 (voiceprints): VoiceprintStore (known_voiceprints, persist named
fingerprints, skip Unknown). Wired: 'Send to backend' button + transcript status,
auto-send toggle (default off) + self-name setting.

All adversarial-review findings fixed. App + XCTest suite build; tests pass.

Ten31Transcripts/Backend/VoiceprintStore.swift

@@ -0,0 +1,104 @@
+import Foundation
+
+/// Local persistence of named voiceprints — the compounding-identity layer.
+///
+/// File `~/Ten31Transcripts/voiceprints.json`:
+///   `{ "<name>": { "vector": [192 floats], "updated": <iso>, "calls": <int> } }`
+///
+/// On send → `knownVoiceprints()` feeds `label-merge`. On response → `update(with:)`
+/// stores/refreshes vectors for speakers resolved by **visual** (overlap ≥ ~0.8)
+/// or **voiceprint** match. Never stores `Unknown_N` / `Speaker_unknown`.
+///
+/// Thread-safe (lock-guarded); the sequential pipeline is the only writer.
+final class VoiceprintStore {
+    struct Entry: Codable, Equatable {
+        var vector: [Float]
+        var updated: String
+        var calls: Int
+    }
+
+    private let url: URL
+    private let minOverlapToStore: Double
+    private let lock = NSLock()
+    private var entriesStore: [String: Entry] = [:]
+
+    init(fileURL: URL, minOverlapToStore: Double = 0.8) {
+        self.url = fileURL
+        self.minOverlapToStore = minOverlapToStore
+        load()
+    }
+
+    var entries: [String: Entry] {
+        lock.lock(); defer { lock.unlock() }
+        return entriesStore
+    }
+
+    /// Vectors keyed by name, for the `known_voiceprints` field.
+    func knownVoiceprints() -> [String: [Float]] {
+        lock.lock(); defer { lock.unlock() }
+        return entriesStore.mapValues { $0.vector }
+    }
+
+    /// Persist fingerprints from a `label-merge` response for confidently-named
+    /// speakers only.
+    func update(with response: LabelMergeResponse) {
+        lock.lock(); defer { lock.unlock() }
+        let now = ISO8601DateFormatter().string(from: Date())
+        for sp in response.speakers {
+            guard !Self.isUnknown(sp.name) else { continue }
+            let acceptable: Bool
+            switch sp.source {
+            case "visual":     acceptable = (sp.overlapConfidence ?? 0) >= minOverlapToStore
+            case "voiceprint": acceptable = true            // already matched a known print
+            default:           acceptable = false           // unmatched
+            }
+            guard acceptable, let vector = sp.fingerprint ?? response.fingerprints[sp.name],
+                  !vector.isEmpty else { continue }
+            var entry = entriesStore[sp.name] ?? Entry(vector: vector, updated: now, calls: 0)
+            entry.vector = vector
+            entry.updated = now
+            entry.calls += 1
+            entriesStore[sp.name] = entry
+        }
+        save()
+    }
+
+    func rename(_ old: String, to new: String) {
+        lock.lock(); defer { lock.unlock() }
+        guard let e = entriesStore.removeValue(forKey: old) else { return }
+        entriesStore[new] = e
+        save()
+    }
+
+    func remove(_ name: String) {
+        lock.lock(); defer { lock.unlock() }
+        entriesStore.removeValue(forKey: name)
+        save()
+    }
+
+    func reset() {
+        lock.lock(); defer { lock.unlock() }
+        entriesStore = [:]
+        save()
+    }
+
+    // MARK: - Persistence (call with lock held)
+
+    private func load() {
+        guard let data = try? Data(contentsOf: url),
+              let decoded = try? JSONDecoder().decode([String: Entry].self, from: data) else { return }
+        entriesStore = decoded
+    }
+
+    private func save() {
+        let encoder = JSONEncoder()
+        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
+        try? FileManager.default.createDirectory(at: url.deletingLastPathComponent(),
+                                                 withIntermediateDirectories: true)
+        if let data = try? encoder.encode(entriesStore) { try? data.write(to: url) }
+    }
+
+    private static func isUnknown(_ name: String) -> Bool {
+        LabelMergeResponse.isUnknownName(name)
+    }
+}