diff --git a/Tests/TranscriptedCoreTests/SpeakerExemplarDeltaEvalTests.swift b/Tests/TranscriptedCoreTests/SpeakerExemplarDeltaEvalTests.swift
new file mode 100644
index 00000000..8fafe149
--- /dev/null
+++ b/Tests/TranscriptedCoreTests/SpeakerExemplarDeltaEvalTests.swift
@@ -0,0 +1,345 @@
+import XCTest
+@testable import TranscriptedCore
+
+/// Corpus-gated A/B eval that measures the accuracy delta of the two speaker-identity features that
+/// merged into `main` in 2026-07 — multi-exemplar voiceprints (#1488) and negative exemplars
+/// (#1487) — on **real** per-quality speaker embeddings (AMI + VoxCeleb, re-encoded through the
+/// audio-degradation matrix and re-dumped by the real diarizer).
+///
+/// It is a measurement harness, not a pass/fail regression: it enrolls mature profiles through the
+/// real `SpeakerDatabase` (real EMA blend + real `SpeakerExemplarPolicy` exemplar maintenance) and
+/// then scores held-out, cross-condition trials two ways using the *same production functions*:
+///   - **WITH**   — `SpeakerVectorMath.bestSimilarity` (average + stored exemplars) and the real
+///                  `SpeakerNegativeExemplarPolicy` veto (both features live).
+///   - **WITHOUT** — `SpeakerVectorMath.cosineSimilarity` against the blended average only, no veto
+///                  (the legacy single-average matcher, i.e. the pre-#1487/#1488 behavior).
+/// The auto-name decision in both arms is the real `SpeakerNamingPolicy.shouldAutoAccept`
+/// (0.92 similarity bar + 0.12 best-vs-second margin), so the numbers are read at the certified
+/// operating point.
+///
+/// The corpus (11 GB of cached fingerprints) is not in-tree, so the whole test XCTSkip's unless
+/// `SPEAKER_EVAL_QMATRIX_DIR` points at a directory of `<corpus>_<quality>/fingerprints.json`
+/// caches (produced by `Tools/SpeakerEvalHarness` `ladder-fingerprints`). Results are written as
+/// JSON to `SPEAKER_EVAL_OUT` (default: a temp file, path printed) for the report to fold in.
+@available(macOS 14.0, *)
+final class SpeakerExemplarDeltaEvalTests: XCTestCase {
+
+    // MARK: Fingerprint cache schema (mirror of Tools/SpeakerEvalHarness/Fingerprints.swift)
+    private struct FpSpeaker: Codable {
+        let gtSpeaker: String
+        let embedding: [Float]
+        let segmentCount: Int
+    }
+    private struct FpMeeting: Codable {
+        let meeting: String
+        let order: Int
+        let speakers: [FpSpeaker]
+    }
+    private struct FpCache: Codable {
+        let corpus: String
+        let meetings: [FpMeeting]
+    }
+
+    private struct Appearance {
+        let quality: String
+        let meeting: String
+        let embedding: [Float]
+        let segmentCount: Int
+    }
+
+    private struct Profile {
+        let gt: String
+        let id: UUID
+        let average: [Float]
+        let exemplars: [[Float]]
+        let callCount: Int
+    }
+
+    // Operating point (matches production SpeakerNamingPolicy / SpeakerEmbeddingThresholds.weSpeaker).
+    private let matchFloor = 0.70          // matchManySegments — mature profile DB-match floor
+    private let autoBar = SpeakerNamingPolicy.autoAcceptSimilarityThreshold   // 0.92
+    private let marginMin = SpeakerNamingPolicy.autoAcceptMarginMin           // 0.12
+    private let emaAlpha: Float = 0.15     // production profile EMA (SpeakerDatabase blend)
+
+    // Held-out degraded conditions the returning voice arrives in (VoIP / telephone / noise / room).
+    private let testQualities = ["opus_8k", "tel_g711", "noisy_snr5", "reverb", "mp3_16"]
+
+    func testExemplarDeltaOnRealQmatrixFingerprints() throws {
+        guard let root = ProcessInfo.processInfo.environment["SPEAKER_EVAL_QMATRIX_DIR"] else {
+            throw XCTSkip("Set SPEAKER_EVAL_QMATRIX_DIR to a dir of <corpus>_<quality>/fingerprints.json caches to run.")
+        }
+        var report: [String: Any] = [
+            "operatingPoint": ["autoBar": autoBar, "marginMin": marginMin, "matchFloor": matchFloor],
+            "note": "WITH = multi-exemplar bestSimilarity + negative veto (main). WITHOUT = single-average cosine, no veto (legacy).",
+        ]
+        var corpora: [[String: Any]] = []
+
+        for (corpus, qualities) in [
+            ("ami", ["orig", "mp3_32", "opus_8k", "tel_g711", "noisy_snr5", "reverb"]),
+            ("voxceleb", ["orig", "mp3_64", "mp3_32", "mp3_16", "opus_16k", "opus_8k", "tel_g711", "noisy_snr5", "noisy_snr10", "reverb"]),
+        ] {
+            guard let bySpeaker = try loadCorpus(root: root, corpus: corpus, qualities: qualities), !bySpeaker.isEmpty else {
+                continue
+            }
+            let result = try runCorpus(corpus: corpus, bySpeaker: bySpeaker)
+            corpora.append(result)
+        }
+
+        guard !corpora.isEmpty else {
+            throw XCTSkip("No corpora found under \(root) (expected e.g. ami_orig/fingerprints.json).")
+        }
+        report["corpora"] = corpora
+
+        // Emit artifact.
+        let outPath = ProcessInfo.processInfo.environment["SPEAKER_EVAL_OUT"]
+            ?? FileManager.default.temporaryDirectory.appendingPathComponent("exemplar-delta-\(UUID().uuidString).json").path
+        let data = try JSONSerialization.data(withJSONObject: report, options: [.prettyPrinted, .sortedKeys])
+        try data.write(to: URL(fileURLWithPath: outPath))
+        print("SPEAKER_EVAL_OUT_WRITTEN \(outPath)")
+        FileHandle.standardOutput.write(("\n" + (String(data: data, encoding: .utf8) ?? "") + "\n").data(using: .utf8)!)
+
+        // Sanity gates: the eval actually exercised the features and produced monotone genuine sims.
+        for c in corpora {
+            let name = c["corpus"] as? String ?? "?"
+            let with = c["with"] as? [String: Any] ?? [:]
+            let without = c["without"] as? [String: Any] ?? [:]
+            let mWith = with["meanGenuineSim"] as? Double ?? 0
+            let mWithout = without["meanGenuineSim"] as? Double ?? 0
+            XCTAssertGreaterThanOrEqual(mWith, mWithout - 1e-9,
+                "\(name): multi-exemplar must be monotone non-decreasing on genuine similarity")
+            XCTAssertGreaterThan(c["profiles"] as? Int ?? 0, 0, "\(name): no profiles enrolled")
+        }
+    }
+
+    // MARK: Load
+
+    private func loadCorpus(root: String, corpus: String, qualities: [String]) throws -> [String: [Appearance]]? {
+        var bySpeaker: [String: [Appearance]] = [:]
+        var found = false
+        let dec = JSONDecoder()
+        for q in qualities {
+            let path = "\(root)/\(corpus)_\(q)/fingerprints.json"
+            guard let data = FileManager.default.contents(atPath: path) else { continue }
+            found = true
+            let cache = try dec.decode(FpCache.self, from: data)
+            for m in cache.meetings {
+                for s in m.speakers {
+                    bySpeaker[s.gtSpeaker, default: []].append(
+                        Appearance(quality: q, meeting: m.meeting, embedding: s.embedding, segmentCount: s.segmentCount))
+                }
+            }
+        }
+        return found ? bySpeaker : nil
+    }
+
+    // MARK: Enroll + score one corpus
+
+    private func runCorpus(corpus: String, bySpeaker: [String: [Appearance]]) throws -> [String: Any] {
+        let dbPath = FileManager.default.temporaryDirectory
+            .appendingPathComponent("exemplar-eval-\(corpus)-\(UUID().uuidString).sqlite").path
+        let db = SpeakerDatabase(path: dbPath)
+        defer { try? FileManager.default.removeItem(atPath: dbPath) }
+
+        var profiles: [Profile] = []
+        var testTrials: [(gt: String, emb: [Float])] = []          // held-out degraded, all speakers
+        // held-out utterances per speaker, keyed for the veto experiment (test conditions only)
+        var testBySpeaker: [String: [(quality: String, emb: [Float])]] = [:]
+
+        // Deterministic order: sort speakers and, within a speaker, sort by (meeting, quality).
+        for gt in bySpeaker.keys.sorted() {
+            let apps = bySpeaker[gt]!.sorted { ($0.meeting, $0.quality) < ($1.meeting, $1.quality) }
+            let meetings = Array(Set(apps.map { $0.meeting })).sorted()
+            guard meetings.count >= 3 else { continue }
+            let k = max(1, Int((Double(meetings.count) * 0.6).rounded()))
+            let enrollMeetings = Set(meetings.prefix(k))
+            let testMeetings = Set(meetings.suffix(meetings.count - k))
+
+            // Enroll: every quality within the enroll meetings → a mature, multi-condition profile.
+            let enrollMeans = apps.filter { enrollMeetings.contains($0.meeting) }.map { $0.embedding }
+            guard enrollMeans.count >= 2 else { continue }
+            var id: UUID? = nil
+            var last: SpeakerProfile? = nil
+            for mean in enrollMeans {
+                let p = db.addOrUpdateSpeaker(embedding: mean, existingId: id, blendAlpha: emaAlpha)
+                id = p.id
+                last = p
+            }
+            guard let pid = id, let lp = last else { continue }
+            profiles.append(Profile(gt: gt, id: pid, average: lp.embedding, exemplars: lp.exemplars, callCount: lp.callCount))
+
+            // Held-out degraded trials.
+            for a in apps where testMeetings.contains(a.meeting) && testQualities.contains(a.quality) {
+                testTrials.append((gt: gt, emb: a.embedding))
+                testBySpeaker[gt, default: []].append((quality: a.quality, emb: a.embedding))
+            }
+        }
+
+        // Cross-check that the DB attached exemplars for at least some profiles (feature is live).
+        let profilesWithExemplars = profiles.filter { !$0.exemplars.isEmpty }.count
+
+        // ---- Experiment 1: identification at the operating point, WITH vs WITHOUT ----
+        let with = scoreArm(profiles: profiles, trials: testTrials, useExemplars: true)
+        let without = scoreArm(profiles: profiles, trials: testTrials, useExemplars: false)
+
+        // ---- Experiment 2: negative-exemplar veto after a correction ----
+        let veto = vetoExperiment(profiles: profiles, testBySpeaker: testBySpeaker, db: db)
+
+        return [
+            "corpus": corpus,
+            "profiles": profiles.count,
+            "profilesWithExemplars": profilesWithExemplars,
+            "trials": testTrials.count,
+            "testQualities": testQualities,
+            "with": with,
+            "without": without,
+            "veto": veto,
+        ]
+    }
+
+    /// Identification metrics for one arm at the certified operating point.
+    private func scoreArm(profiles: [Profile], trials: [(gt: String, emb: [Float])], useExemplars: Bool) -> [String: Any] {
+        var recallAtFloor = 0
+        var autoCorrect = 0          // genuine, silently + correctly recognized
+        var falseAuto = 0            // WRONG identity silently auto-named (the dangerous case)
+        var impostorFAatFloor = 0    // any non-self profile clears the match floor
+        var genuineSimSum = 0.0
+        var genuineSimN = 0
+
+        for trial in trials {
+            // Score against every gallery profile (best rep for WITH, average for WITHOUT).
+            var best = (sim: -2.0, gt: "", cc: 0, ex: [[Float]]())
+            var second = -2.0
+            var bestImpostor = -2.0
+            for p in profiles {
+                let sim = useExemplars
+                    ? SpeakerVectorMath.bestSimilarity(candidate: trial.emb, average: p.average, exemplars: p.exemplars)
+                    : SpeakerVectorMath.cosineSimilarity(trial.emb, p.average)
+                if p.gt != trial.gt { bestImpostor = max(bestImpostor, sim) }
+                if sim > best.sim {
+                    second = best.sim
+                    best = (sim, p.gt, p.callCount, p.exemplars)
+                } else if sim > second {
+                    second = sim
+                }
+            }
+            if bestImpostor >= matchFloor { impostorFAatFloor += 1 }
+
+            // Real auto-accept decision on the argmax profile (named + mature so eligibility holds
+            // exactly when callCount > 4; margin/similarity gates come from production).
+            let named = namedMatureProfile(gt: best.gt, callCount: best.cc, average: [], exemplars: best.ex)
+            let autoAccept = SpeakerNamingPolicy.shouldAutoAccept(
+                profile: named, similarity: best.sim, secondBestSimilarity: second)
+
+            if best.gt == trial.gt {
+                genuineSimSum += best.sim; genuineSimN += 1
+                if best.sim >= matchFloor { recallAtFloor += 1 }
+                if autoAccept { autoCorrect += 1 }
+            } else if autoAccept {
+                falseAuto += 1
+            }
+        }
+        let n = max(1, trials.count)
+        return [
+            "recallAtFloor": Double(recallAtFloor) / Double(n),
+            "autoCorrect": Double(autoCorrect) / Double(n),
+            "falseAuto": Double(falseAuto) / Double(n),
+            "falseAutoCount": falseAuto,
+            "impostorFAatFloor": Double(impostorFAatFloor) / Double(n),
+            "meanGenuineSim": genuineSimN > 0 ? genuineSimSum / Double(genuineSimN) : 0,
+        ]
+    }
+
+    /// Failure mode (b): after a wrong match B→A is corrected (B's session mean stored as a negative
+    /// exemplar on A), does a *later* B utterance still re-match A (legacy) or get vetoed (WITH)?
+    ///
+    /// For every confusable ordered pair (A, B) — a B utterance `u1` that wrongly clears A's match
+    /// floor — `u1` is recorded as A's negative exemplar and every *other* held-out B utterance `u2`
+    /// is replayed. We report, over those replays:
+    ///   - reMatchRateLegacy — u2 still clears A's floor (the repeat wrong match the veto must fix).
+    ///   - vetoedRate / vetoedAmongReMatch — how often the veto fires, and specifically how much of
+    ///     the legacy wrong re-match it removes (the actual fix rate).
+    ///   - vetoableShare — u2 resembles the rejected sample ≥ the 0.80 veto floor (the precondition).
+    ///   - sameCondition* — the veto's designed case: u2 arrives in the SAME audio quality as u1.
+    ///   - ownerCollateralRate — A's own voice wrongly vetoed by B's negative (must stay ~0).
+    private func vetoExperiment(profiles: [Profile], testBySpeaker: [String: [(quality: String, emb: [Float])]], db: SpeakerDatabase) -> [String: Any] {
+        var confusablePairs = 0
+        var replays = 0, reMatch = 0, vetoed = 0, vetoedAndReMatch = 0, vetoable = 0
+        var sameCondReplays = 0, sameCondReMatch = 0, sameCondVetoed = 0
+        var ownerCollateral = 0, ownerChecks = 0
+
+        // DB round-trip sanity: the store persists + reads a negative exemplar (real write path).
+        if let a = profiles.first, let bEmb = testBySpeaker[profiles.dropFirst().first?.gt ?? ""]?.first?.emb {
+            db.recordNegativeExemplar(profileId: a.id, embedding: bEmb)
+            XCTAssertFalse((db.negativeExemplarsByProfile()[a.id] ?? []).isEmpty, "negative exemplar store failed to persist")
+        }
+
+        for a in profiles {
+            let ownUtterances = testBySpeaker[a.gt] ?? []
+            for b in profiles where b.gt != a.gt {
+                guard let bUtterances = testBySpeaker[b.gt], bUtterances.count >= 2 else { continue }
+                let u1 = bUtterances[0]
+                let pos1 = SpeakerVectorMath.bestSimilarity(candidate: u1.emb, average: a.average, exemplars: a.exemplars)
+                guard pos1 >= matchFloor else { continue }   // B's first utterance is confusable with A
+                confusablePairs += 1
+                let negatives = [SpeakerVectorMath.l2Normalize(u1.emb)]
+
+                for u2 in bUtterances.dropFirst() {
+                    replays += 1
+                    let pos2 = SpeakerVectorMath.bestSimilarity(candidate: u2.emb, average: a.average, exemplars: a.exemplars)
+                    let didReMatch = pos2 >= matchFloor
+                    let didVeto = SpeakerNegativeExemplarPolicy.shouldVeto(
+                        candidate: u2.emb, positiveSimilarity: pos2, negativeExemplars: negatives)
+                    let negSim = SpeakerVectorMath.cosineSimilarity(u2.emb, negatives[0])
+                    if didReMatch { reMatch += 1 }
+                    if didVeto { vetoed += 1 }
+                    if didReMatch && didVeto { vetoedAndReMatch += 1 }
+                    if negSim >= SpeakerNegativeExemplarPolicy.vetoFloor { vetoable += 1 }
+                    if u2.quality == u1.quality {
+                        sameCondReplays += 1
+                        if didReMatch { sameCondReMatch += 1 }
+                        if didVeto { sameCondVetoed += 1 }
+                    }
+                }
+                // Collateral: A's own held-out utterances must not be vetoed by B's negative.
+                for own in ownUtterances {
+                    ownerChecks += 1
+                    let posOwn = SpeakerVectorMath.bestSimilarity(candidate: own.emb, average: a.average, exemplars: a.exemplars)
+                    if SpeakerNegativeExemplarPolicy.shouldVeto(candidate: own.emb, positiveSimilarity: posOwn, negativeExemplars: negatives) {
+                        ownerCollateral += 1
+                    }
+                }
+            }
+        }
+        func rate(_ x: Int, _ y: Int) -> Double { y > 0 ? Double(x) / Double(y) : 0 }
+        return [
+            "confusablePairs": confusablePairs,
+            "replays": replays,
+            "reMatchRateLegacy": rate(reMatch, replays),
+            "vetoedRate": rate(vetoed, replays),
+            "vetoedAmongReMatch": rate(vetoedAndReMatch, reMatch),   // fraction of wrong re-matches the veto removes
+            "vetoableShare": rate(vetoable, replays),               // u2 resembles rejected sample >= 0.80
+            "reMatchCount": reMatch, "vetoedCount": vetoed, "vetoedAndReMatchCount": vetoedAndReMatch,
+            "sameCondition": [
+                "replays": sameCondReplays,
+                "reMatchRateLegacy": rate(sameCondReMatch, sameCondReplays),
+                "vetoedRate": rate(sameCondVetoed, sameCondReplays),
+            ],
+            "ownerCollateralRate": rate(ownerCollateral, ownerChecks),
+            "ownerChecks": ownerChecks,
+        ]
+    }
+
+    private func namedMatureProfile(gt: String, callCount: Int, average: [Float], exemplars: [[Float]]) -> SpeakerProfile {
+        SpeakerProfile(
+            id: UUID(),
+            displayName: gt.isEmpty ? "spk" : gt,
+            nameSource: "userManual",
+            embedding: average,
+            firstSeen: Date(),
+            lastSeen: Date(),
+            callCount: callCount,
+            confidence: 0.9,
+            disputeCount: 0,
+            exemplars: exemplars)
+    }
+}
diff --git a/docs/speaker-eval-exemplar-delta-2026-07.md b/docs/speaker-eval-exemplar-delta-2026-07.md
new file mode 100644
index 00000000..1c51b3f6
--- /dev/null
+++ b/docs/speaker-eval-exemplar-delta-2026-07.md
@@ -0,0 +1,195 @@
+# Speaker eval: multi-exemplar + negative-exemplar accuracy delta (2026-07)
+
+## Verdict
+
+The two speaker-identity features that merged into `main` in 2026-07 were measured against the
+legacy single-average matcher on **real** cross-condition speaker embeddings (AMI + VoxCeleb, the
+same audio-degradation qmatrix used by `Tools/SpeakerEvalHarness`). Both help, neither is free:
+
+- **Multi-exemplar voiceprints (#1488) is a real recall win with a real safety cost.** On AMI
+  returning speakers arriving in degraded audio it lifts match recall **+10.9 pp (54.9% → 65.9%)**
+  and correct silent auto-recognition **+8.1 pp (1.6% → 9.7%, ~6×)** — but it also introduces
+  **12 silent mislabels (false-auto 0.0% → 1.6%)** at the certified operating point, where the
+  legacy matcher had **zero**. The "0 false-auto" guarantee the AMI-full ladder certified for the
+  average-only matcher (`SpeakerNamingPolicy` header, §11) **no longer holds on degraded audio**
+  once best-of-exemplars scoring is in play.
+- **Negative-exemplar veto (#1487) is a sound but partial, regime-limited fix.** After a correction
+  it removes **46% of repeat wrong-matches in-room (AMI)** but only **12% cross-condition
+  (VoxCeleb)**, because the returning wrong voice usually resembles the rejected sample by *less*
+  than the 0.80 veto floor once the audio condition changes — the same condition-gap multi-exemplar
+  was built to close on the positive side has no analog on the negative side. It carries a small but
+  nonzero **~2% owner-collateral** (the true owner's own voice occasionally vetoed).
+
+**Recommendation:** keep both features — the recall/recognition gains are large and real — but
+**retune the auto-name gate for the exemplar path** before treating "0 false-auto" as still true.
+The 0.12 best-vs-second margin was calibrated against a single average; a best-of-3-exemplars score
+can clear both the 0.92 bar *and* the margin for an impostor. Cheapest robust option: compute the
+auto-accept **margin against the profile's *average* representative, not its best exemplar** (or
+apply a small exemplar-vs-average handicap at the auto gate only). Separately, give the negative
+veto a **multi-exemplar-style, cross-condition representation** (or lower its floor with an
+owner-protection guard) so it fires in the VoIP/telephone regime where it currently doesn't. See
+[Recommendation](#recommendation).
+
+## Metric
+
+Two experiments, both at the production operating point
+(`SpeakerNamingPolicy.autoAcceptSimilarityThreshold = 0.92`, `autoAcceptMarginMin = 0.12`, mature
+DB-match floor `SpeakerEmbeddingThresholds.weSpeaker.matchManySegments = 0.70`):
+
+1. **Cross-condition identification (failure mode a).** For each ground-truth speaker, a mature,
+   multi-condition profile is enrolled from ~60% of their meetings across every audio quality (real
+   EMA blend + real `SpeakerExemplarPolicy` exemplar maintenance, through `SpeakerDatabase`). The
+   held-out 40% of meetings, restricted to **degraded** conditions (opus_8k, tel_g711, noisy_snr5,
+   reverb, mp3_16), are scored against the full gallery two ways:
+   - **WITH** — `SpeakerVectorMath.bestSimilarity(candidate, average, exemplars)` + the real
+     `SpeakerNegativeExemplarPolicy` veto (both features live).
+   - **WITHOUT** — `SpeakerVectorMath.cosineSimilarity(candidate, average)` only, no veto (the
+     pre-#1487/#1488 single-average matcher).
+   The auto-name decision in both arms is the real `SpeakerNamingPolicy.shouldAutoAccept`.
+   Reported: genuine recall@floor, correct silent auto-recognition, **false-auto (silent
+   mislabels)**, impostor false-accept@floor, mean genuine similarity.
+
+2. **Post-correction veto (failure mode b).** For every confusable ordered pair (A, B) — a B
+   utterance `u1` that wrongly clears A's floor — `u1` is stored as A's negative exemplar (the real
+   correction signal) and every *other* held-out B utterance is replayed. Reported: legacy repeat
+   wrong-match rate, veto fire rate, **fraction of wrong re-matches the veto removes**, the vetoable
+   share (returning voice ≥ 0.80 to the rejected sample), the same-condition designed case, and
+   owner-collateral (A's own voice wrongly vetoed).
+
+Guardrails: the harness asserts multi-exemplar is monotone non-decreasing on genuine similarity
+(it must never *lower* a true match) and that the negative-exemplar store round-trips through
+SQLite. No RNG — fully deterministic (splits by sorted meeting/quality order).
+
+## Commands and sources
+
+- Repo: `r3dbars/transcripted`, branch `eval/exemplar-delta-2026-07`, off `main@17601969` (both
+  #1487 and #1488 merged: `eb1ecf19`, `aa74fed8`).
+- Harness (new): [`Tests/TranscriptedCoreTests/SpeakerExemplarDeltaEvalTests.swift`](../Tests/TranscriptedCoreTests/SpeakerExemplarDeltaEvalTests.swift)
+- Feature code under test:
+  - `Sources/TranscriptedCore/Speaker/SpeakerExemplarPolicy.swift`,
+    `SpeakerVectorMath.bestSimilarity` (multi-exemplar, #1488)
+  - `Sources/TranscriptedCore/Speaker/SpeakerNegativeExemplarPolicy.swift`,
+    `SpeakerNegativeExemplarStore.swift` (negative veto, #1487)
+  - `SpeakerNamingPolicy.shouldAutoAccept`, `SpeakerEmbeddingThresholds.weSpeaker` (operating point)
+- Real embeddings: `Tools/SpeakerEvalHarness` per-quality fingerprint caches
+  (`data/eval/qmatrix/<corpus>_<quality>/fingerprints.json`), 256-d WeSpeaker means from the real
+  diarizer, produced by `ladder-fingerprints`. Not in-tree (~11 GB); the test XCTSkip's without them.
+- Build deps: `bash build-deps.sh` (or symlink prebuilt `deps-*` from a built checkout).
+- Run:
+  ```bash
+  SPEAKER_EVAL_QMATRIX_DIR=/path/to/data/eval/qmatrix \
+  SPEAKER_EVAL_OUT=docs/speaker-eval-exemplar-delta-2026-07.result.json \
+    swift test --filter SpeakerExemplarDeltaEvalTests
+  ```
+- Raw output: [`docs/speaker-eval-exemplar-delta-2026-07.result.json`](speaker-eval-exemplar-delta-2026-07.result.json)
+  (values below copied from it verbatim).
+
+## Results — multi-exemplar (#1488), degraded cross-condition identification
+
+Operating point: auto-bar 0.92, margin 0.12, match floor 0.70. **WITHOUT** = legacy single average;
+**WITH** = best-of-exemplars.
+
+### AMI (in-room) — 147 profiles (138 with ≥1 exemplar), 741 degraded held-out trials
+
+| metric | WITHOUT | WITH | Δ |
+|---|---:|---:|---:|
+| genuine recall @ floor 0.70 | 0.549 | **0.659** | **+0.109** |
+| correct silent auto-recognition @ (0.92, 0.12) | 0.016 | **0.097** | **+0.081** |
+| **false-auto (silent mislabels)** @ (0.92, 0.12) | **0.000** (0) | **0.016** (12) | **+0.016** |
+| impostor false-accept @ floor 0.70 | 0.287 | 0.553 | +0.266 |
+| mean genuine similarity | 0.785 | 0.858 | +0.073 |
+
+### VoxCeleb (clean-source, single short utterance/meeting) — 30 profiles, 1798 degraded trials
+
+| metric | WITHOUT | WITH | Δ |
+|---|---:|---:|---:|
+| genuine recall @ floor 0.70 | 0.141 | **0.174** | **+0.033** |
+| correct silent auto-recognition @ (0.92, 0.12) | 0.000 | 0.001 | +0.001 |
+| false-auto @ (0.92, 0.12) | 0.000 (0) | 0.000 (0) | 0.000 |
+| impostor false-accept @ floor 0.70 | 0.394 | 0.473 | +0.078 |
+| mean genuine similarity | 0.611 | 0.656 | +0.045 |
+
+**Reading it.** Multi-exemplar raises genuine similarity (it stores a per-condition representative
+instead of one blended-across-conditions centroid), which is why recall and correct auto-recognition
+jump. But `bestSimilarity` is monotone for *every* candidate, impostors included — so impostor
+false-accept rises too, and on AMI a handful of impostors now clear both the 0.92 bar and the 0.12
+margin, producing 12 silent mislabels the average-only matcher never made. VoxCeleb shows no
+false-auto only because its single short utterances essentially never reach the 0.92 bar on degraded
+audio (auto-recognition ≈ 0 in both arms); its recall gain is the honest signal there.
+
+## Results — negative veto (#1487), post-correction re-match
+
+After B is wrongly matched to A and corrected (B's mean stored as A's negative exemplar), later B
+utterances are replayed. "vetoed-among-re-match" = the fraction of the legacy wrong re-matches the
+veto actually removes; "vetoable share" = fraction of returning voices resembling the rejected
+sample ≥ the 0.80 veto floor (the veto's precondition).
+
+| corpus | confusable pairs | replays | legacy re-match | veto fires | **wrong re-matches removed** | vetoable share | same-condition veto rate | owner-collateral |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| AMI | 1176 | 4718 | 0.148 | 0.123 | **0.460** | 0.147 | 0.377 | 0.022 |
+| VoxCeleb | 103 | 6077 | 0.254 | 0.041 | **0.123** | 0.046 | 0.121 | 0.016 |
+
+**Reading it.** The veto is deliberately conservative: it only fires when the returning voice
+resembles an *explicitly rejected* sample at ≥ 0.80 and at least as much as it resembles the profile
+itself. In-room (AMI) that precondition holds often enough to remove **46%** of repeat wrong-matches.
+Cross-condition (VoxCeleb), the rejected sample and the returning wrong voice are usually > 0.80
+*apart* — the vetoable share collapses to 4.6% and the veto removes only **12%**. It is not a
+substitute for fixing the false-auto at first contact: the veto can only act on the *second*
+occurrence, after the user has already corrected once, so it does nothing about the 12 first-time
+false-autos multi-exemplar introduces above.
+
+## Movement vs the previously-documented operating point
+
+The AMI-full ladder (`SpeakerEvalHarness/LADDER_SWEEP_REPORT.md` §11) certified the auto-name gate at
+**0.92 bar + 0.12 margin, 0 false-auto on 148 autos (N=175)** — measured on the ported **average-only**
+matcher, i.e. exactly this eval's WITHOUT arm, which reproduces **0 false-auto** here. Adding
+multi-exemplar (the WITH arm) is what moves it: on the degraded cross-condition slice the operating
+point now shows **~1.6% false-auto** on AMI. The operating point's *thresholds* are unchanged and
+still correct for the average path; what changed is that best-of-exemplars scoring lets impostors
+reach them. The margin gate remains the right lever — it just needs to be applied to the average
+rep, not the best exemplar (see below).
+
+## Recommendation
+
+1. **Keep both features.** +10.9 pp recall and +8.1 pp correct silent recognition on real degraded
+   in-room audio is a large, real win, and the negative veto is a correct safety layer.
+2. **Retune the auto gate for the exemplar path** so "0 false-auto" is restored without giving back
+   the recall. Lowest-risk option: at the auto-accept gate only, compute the best-vs-second **margin
+   against each profile's blended *average* similarity**, not its best-exemplar similarity — an
+   impostor that only clears via one lucky exemplar then fails the margin, while a genuine owner
+   (close on *both* average and exemplar) still passes. Alternatives: a small exemplar-vs-average
+   penalty at the gate, or raising `autoAcceptMarginMin` ~0.12 → ~0.15 (blunter; costs some genuine
+   autos). Re-run this harness to confirm false-auto → 0 and recall retained before shipping a change.
+3. **Strengthen the negative veto for degraded audio.** It under-fires cross-condition because a
+   single rejected embedding doesn't cover the wrong voice's other conditions. Give a profile's
+   negative exemplars the same multi-condition treatment as its positive ones, or lower `vetoFloor`
+   below 0.80 *with* an owner-protection margin — the measured ~2% owner-collateral says don't lower
+   it naively.
+4. **Do not read these as everyday rates.** This is a deliberate worst case (enroll across all
+   qualities, test only on degraded held-out conditions, full-gallery impostors). Clean-audio
+   false-auto stays ~0 (consistent with the ladder's clean findings); the 1.6% is the degraded-slice
+   upper bound, not the expected production rate.
+
+## Risks / caveats
+
+- **Fingerprint-level, not full-pipeline.** The eval operates on per-(speaker, meeting) mean
+  embeddings, which is exactly where `SpeakerExemplarPolicy` / `SpeakerNegativeExemplarPolicy` /
+  `bestSimilarity` run, so fidelity for *these features* is high — but it does not replay
+  within-meeting consolidation, the review UI, or profile-health demotion. `shouldAutoAccept` is
+  evaluated with a named, mature, dispute-free profile, so the eval isolates the match-level gates
+  (similarity + margin); the profile-health probation path is out of scope.
+- **Worst-case slice.** Degraded-only test conditions + large impostor gallery inflate both the
+  recall win and the false-auto/impostor-FA cost relative to mixed real usage.
+- **VoxCeleb single-utterance meetings** rarely reach maturity + the 0.92 bar on degraded audio, so
+  its auto-recognition numbers are ~0 by construction; it informs recall and the veto, not the gate.
+- **Ports cross-checked.** A standalone Python re-implementation of the EMA/exemplar/cosine math
+  reproduced the AMI recall (0.549 → 0.659) and false-auto (12/741) to the digit, so the numbers do
+  not hinge on a single implementation. The committed numbers are from the Swift path calling the
+  real `TranscriptedCore` functions.
+
+## Tests run
+
+- `swift test --filter SpeakerNamingSimulationRunnerTests` — 7/7 pass (existing functional
+  regression; confirms the Core test target builds + runs with the exemplar features on `main`).
+- `swift test --filter SpeakerExemplarDeltaEvalTests` — passes (this eval; ~3.4 s), writes
+  `docs/speaker-eval-exemplar-delta-2026-07.result.json`.
diff --git a/docs/speaker-eval-exemplar-delta-2026-07.result.json b/docs/speaker-eval-exemplar-delta-2026-07.result.json
new file mode 100644
index 00000000..e744f8e4
--- /dev/null
+++ b/docs/speaker-eval-exemplar-delta-2026-07.result.json
@@ -0,0 +1,104 @@
+{
+  "corpora" : [
+    {
+      "corpus" : "ami",
+      "profiles" : 147,
+      "profilesWithExemplars" : 138,
+      "testQualities" : [
+        "opus_8k",
+        "tel_g711",
+        "noisy_snr5",
+        "reverb",
+        "mp3_16"
+      ],
+      "trials" : 741,
+      "veto" : {
+        "confusablePairs" : 1176,
+        "ownerChecks" : 5773,
+        "ownerCollateralRate" : 0.021652520353369131,
+        "reMatchCount" : 698,
+        "reMatchRateLegacy" : 0.14794404408647732,
+        "replays" : 4718,
+        "sameCondition" : {
+          "reMatchRateLegacy" : 0.19757575757575757,
+          "replays" : 825,
+          "vetoedRate" : 0.37696969696969695
+        },
+        "vetoableShare" : 0.14709622721492158,
+        "vetoedAmongReMatch" : 0.45988538681948427,
+        "vetoedAndReMatchCount" : 321,
+        "vetoedCount" : 578,
+        "vetoedRate" : 0.122509537939805
+      },
+      "with" : {
+        "autoCorrect" : 0.097165991902834009,
+        "falseAuto" : 0.016194331983805668,
+        "falseAutoCount" : 12,
+        "impostorFAatFloor" : 0.55330634278002699,
+        "meanGenuineSim" : 0.85824506285209812,
+        "recallAtFloor" : 0.65856950067476383
+      },
+      "without" : {
+        "autoCorrect" : 0.016194331983805668,
+        "falseAuto" : 0,
+        "falseAutoCount" : 0,
+        "impostorFAatFloor" : 0.2874493927125506,
+        "meanGenuineSim" : 0.78487367151233289,
+        "recallAtFloor" : 0.54925775978407554
+      }
+    },
+    {
+      "corpus" : "voxceleb",
+      "profiles" : 30,
+      "profilesWithExemplars" : 30,
+      "testQualities" : [
+        "opus_8k",
+        "tel_g711",
+        "noisy_snr5",
+        "reverb",
+        "mp3_16"
+      ],
+      "trials" : 1798,
+      "veto" : {
+        "confusablePairs" : 103,
+        "ownerChecks" : 6162,
+        "ownerCollateralRate" : 0.015579357351509251,
+        "reMatchCount" : 1545,
+        "reMatchRateLegacy" : 0.25423728813559321,
+        "replays" : 6077,
+        "sameCondition" : {
+          "reMatchRateLegacy" : 0.28331862312444839,
+          "replays" : 1133,
+          "vetoedRate" : 0.1209179170344219
+        },
+        "vetoableShare" : 0.045746256376501565,
+        "vetoedAmongReMatch" : 0.12297734627831715,
+        "vetoedAndReMatchCount" : 190,
+        "vetoedCount" : 249,
+        "vetoedRate" : 0.040974164883988813
+      },
+      "with" : {
+        "autoCorrect" : 0.00055617352614015572,
+        "falseAuto" : 0,
+        "falseAutoCount" : 0,
+        "impostorFAatFloor" : 0.4727474972191324,
+        "meanGenuineSim" : 0.65601019484345202,
+        "recallAtFloor" : 0.17408231368186874
+      },
+      "without" : {
+        "autoCorrect" : 0,
+        "falseAuto" : 0,
+        "falseAutoCount" : 0,
+        "impostorFAatFloor" : 0.39432703003337038,
+        "meanGenuineSim" : 0.61114929809089846,
+        "recallAtFloor" : 0.14071190211345941
+      }
+    }
+  ],
+  "note" : "WITH = multi-exemplar bestSimilarity + negative veto (main). WITHOUT = single-average cosine, no veto (legacy).",
+  "operatingPoint" : {
+    "autoBar" : 0.92000000000000004,
+    "marginMin" : 0.12,
+    "matchFloor" : 0.69999999999999996
+  }
+}
\ No newline at end of file