Reduce verified single-chunk latency

README.md

@@ -64,12 +64,12 @@ Mamba2 所需的 Triton runtime 以
 | Pace / speaker eligibility duration | union of active 25 ms RMS frames at 10 ms hop; internal pauses excluded |
 | Semantic verification | orthographic whole CER + tone-aware acoustic first/last 6 exact + no lexical tail; range-proven URL/email locals and every exact whole output require turbo/full-large-v3 hard intersection; fail closed |
 | Local endpoint verification | internal chunk first/last 6 may contain at most one substitution and zero deletion; absolute request onset/ending remain exact |
-| Acoustic quality gate | pinned CPU SQUIM objective SHA-256 `2c54586fea83fb5eb5394d710038ee89f55cab7011a5bf730bebed4c8777e828`; hard STOI ≥ 0.60 / PESQ ≥ 1.12; at ≥1.50 s, single-chunk early return additionally requires preferred STOI ≥ 0.72 / PESQ ≥ 1.20 and speaker 0.25 / 0.05; SI-SDR is bounded soft evidence only |
+| Acoustic quality gate | pinned CPU SQUIM objective SHA-256 `2c54586fea83fb5eb5394d710038ee89f55cab7011a5bf730bebed4c8777e828`; hard STOI ≥ 0.60 / PESQ ≥ 1.12; at ≥1.50 s, strict preferred return requires STOI ≥ 0.72 / PESQ ≥ 1.20 and speaker 0.25 / 0.05. A single-chunk exact joined waveform may also stop at the latency tier speaker 0.23 / 0.08, but only after both ASRs, preferred SQUIM, hard release speaker, pace, endpoint, and echo/smearing gates pass; local proxies cannot use this tier. SI-SDR is bounded soft evidence only |
 | Local speaker verification | frozen request centroid + bounded window begin/end directional drift |
 | Local hard speaker gate | similarity ≥ 0.10 and directional drop ≤ 0.10 |
 | Joined/final release-parity speaker guard | full-audio similarity ≥ 0.105; disjoint first/last-third drop ≤ 0.095 |
 | Local long speaker evidence | one ECAPA batch over up to four 3-second windows + begin/end |
-| Candidate cascade | exactly one same-seed whole trajectory, then deterministic single-chunk refills for zero/low-coverage rows only |
+| Candidate cascade | exactly one same-seed whole trajectory, then deterministic single-chunk refills for zero/low-coverage rows only; a fully verified single-chunk exact waveform returns immediately instead of filling the preferred candidate pool |
 | Whole-trajectory qualification | assemble with production RMS/fade/pause/crossfade/speed, then whole-output gate |
 | Sequence fallback | ragged DP with up to 3 culprit-diverse paths; boundary-only local rejects may enter through a frozen 0.15 cap, then every exact assembly must pass turbo + full large-v3 and the stricter 0.105/0.095 whole gate |
 | Final output gate | re-verify joined/faded/RMS-matched/speed-adjusted whole waveform; fail closed |

app.py

@@ -279,6 +279,11 @@ QUALITY_PREFERRED_MIN_SQUIM_PESQ = 1.20
 QUALITY_PREFERRED_SQUIM_MIN_DURATION_SECONDS = 1.50
 QUALITY_PREFERRED_MIN_SPEAKER_SIMILARITY = 0.25
 QUALITY_PREFERRED_MAX_BOUNDARY_SPEAKER_DROP = 0.05
+# A single-chunk waveform that has already passed both ASR checks and every
+# hard release gate may stop the cascade at this exact-only tier. Local chunk
+# proxies and multi-chunk eager paths remain on the stricter preferred tier.
+QUALITY_FAST_EXACT_MIN_SPEAKER_SIMILARITY = 0.23
+QUALITY_FAST_EXACT_MAX_BOUNDARY_SPEAKER_DROP = 0.08
 QUALITY_MAX_SEQUENCE_PATHS = 3
 SHORT_AUDIO_SPEAKER_GATE_SECONDS = 1.50
 GLYPH_ASSET_MANIFEST_RELATIVE_PATH = "glyph_assets_v1/manifest.json"
@@ -2717,6 +2722,12 @@ def _synthesize(
                 preferred_min_squim_audio_duration_seconds=(
                     QUALITY_PREFERRED_SQUIM_MIN_DURATION_SECONDS
                 ),
+                single_exact_min_speaker_similarity=(
+                    QUALITY_FAST_EXACT_MIN_SPEAKER_SIMILARITY
+                ),
+                single_exact_max_boundary_speaker_drop=(
+                    QUALITY_FAST_EXACT_MAX_BOUNDARY_SPEAKER_DROP
+                ),
                 require_endpoint_evidence=True,
             )
     except NoQualifiedCandidateError as error:
@@ -3628,7 +3639,9 @@ HEADER = f"""
 目標語速。另補齊句末提示、套用尾端 weak-stop 保護、
 一般 32 speech units 內維持單一 chunk，較長內容才依自然標點與 80-unit 上限切段。每個 request 只生成一次
 same-seed 完整 trajectory；失敗後只補低覆蓋 chunks，再以 speaker/RMS/F0 ragged DP 選出最多三條
-culprit-diverse exact paths；所有 chunk 首次具備 coverage 時先驗證 rank-1 exact path。NFE 固定為已驗證的 10，且每個 request 最多生成 32 個 TTS chunks
+culprit-diverse exact paths；所有 chunk 首次具備 coverage 時先驗證 rank-1 exact path。單一 chunk 若 exact joined
+波形已通過雙 ASR、preferred SQUIM、release speaker、語速與 echo/smearing gate，會立即返回而不再填滿候選池。
+NFE 固定為已驗證的 10，且每個 request 最多生成 32 個 TTS chunks
 與 800 speech units。語速校正使用 deterministic WSOLA，總 rate 不低於 0.90；不少於 1 秒的
 候選與最終波形另須通過 echo/smearing gate。
 """

quality_runtime.py

@@ -4274,6 +4274,54 @@ def _preferred_release_evidence(
     return True
 
 
+def _single_exact_fast_release_evidence(
+    release_evidence: TrajectoryGateEvidence | None,
+    independent_evidence: TrajectoryGateEvidence | None,
+    *,
+    min_speaker_similarity: float,
+    max_boundary_speaker_drop: float,
+    min_squim_stoi: float,
+    min_squim_pesq: float,
+    min_audio_duration_seconds: float,
+) -> bool:
+    """Accept only a fully measured exact waveform at the fast quality tier.
+
+    Unlike the general preferred helper, this latency shortcut never treats a
+    skipped short-audio speaker or SQUIM gate as success. It is deliberately
+    limited to exact joined-waveform evidence; local chunk proxies cannot
+    trigger it.
+    """
+
+    if (
+        not isinstance(release_evidence, TrajectoryGateEvidence)
+        or release_evidence.result is None
+        or release_evidence.result.speaker_gate_applied is not True
+        or release_evidence.result.squim_gate_applied is not True
+        or not _preferred_release_evidence(
+            independent_evidence,
+            min_speaker_similarity=None,
+            max_boundary_speaker_drop=None,
+            min_squim_stoi=None,
+            min_squim_pesq=None,
+        )
+    ):
+        return False
+    duration = _finite_float(
+        release_evidence.result.audio_duration_seconds,
+        minimum=0.0,
+    )
+    if duration is None or duration < min_audio_duration_seconds:
+        return False
+    return _preferred_release_evidence(
+        release_evidence,
+        min_speaker_similarity=min_speaker_similarity,
+        max_boundary_speaker_drop=max_boundary_speaker_drop,
+        min_squim_stoi=min_squim_stoi,
+        min_squim_pesq=min_squim_pesq,
+        min_squim_audio_duration_seconds=min_audio_duration_seconds,
+    )
+
+
 def _coverage_trajectory_tuple(trajectory: Any, expected_chunks: int) -> tuple[Any, ...]:
     """Return one generator result as an exact, non-string trajectory."""
 
@@ -4704,6 +4752,8 @@ def run_coverage_adaptive_cascade(
     preferred_min_squim_stoi: float | None = None,
     preferred_min_squim_pesq: float | None = None,
     preferred_min_squim_audio_duration_seconds: float = 0.0,
+    single_exact_min_speaker_similarity: float | None = None,
+    single_exact_max_boundary_speaker_drop: float | None = None,
     require_endpoint_evidence: bool = False,
 ) -> CascadeResult:
     """Run one whole trajectory, then deterministic low-coverage refills.
@@ -4922,6 +4972,32 @@ def run_coverage_adaptive_cascade(
         preferred_stoi = None
         preferred_pesq = None
         preferred_squim_duration = 0.0
+    single_exact_fast_enabled = (
+        single_exact_min_speaker_similarity is not None
+        or single_exact_max_boundary_speaker_drop is not None
+    )
+    if single_exact_fast_enabled:
+        single_exact_similarity = _finite_float(
+            single_exact_min_speaker_similarity,
+            minimum=-1.0,
+            maximum=1.0,
+        )
+        single_exact_boundary = _finite_float(
+            single_exact_max_boundary_speaker_drop,
+            minimum=0.0,
+            maximum=1.0,
+        )
+        if single_exact_similarity is None or single_exact_boundary is None:
+            raise ValueError(
+                "single exact speaker thresholds must be supplied together and finite"
+            )
+        if not preferred_squim_enabled:
+            raise ValueError(
+                "single exact fast tier requires preferred SQUIM thresholds"
+            )
+    else:
+        single_exact_similarity = None
+        single_exact_boundary = None
     preferred_single_search = bool(
         preferred_speaker_enabled or preferred_squim_enabled
     )
@@ -5076,8 +5152,24 @@ def run_coverage_adaptive_cascade(
             min_squim_audio_duration_seconds=preferred_squim_duration,
         )
     )
+    initial_fast_exact = bool(
+        chunk_count == 1
+        and single_exact_fast_enabled
+        and _single_exact_fast_release_evidence(
+            initial_joined_output,
+            initial_independent_output,
+            min_speaker_similarity=single_exact_similarity,
+            max_boundary_speaker_drop=single_exact_boundary,
+            min_squim_stoi=preferred_stoi,
+            min_squim_pesq=preferred_pesq,
+            min_audio_duration_seconds=preferred_squim_duration,
+        )
+    )
     if initial_verification.passed is True and (
-        chunk_count > 1 or not preferred_single_search or initial_preferred
+        chunk_count > 1
+        or not preferred_single_search
+        or initial_preferred
+        or initial_fast_exact
     ):
         return CascadeResult(
             trajectory=initial_trajectory,
@@ -5499,17 +5591,33 @@ def run_coverage_adaptive_cascade(
                 min_squim_audio_duration_seconds=preferred_squim_duration,
             )
         )
+        refill_fast_exact = bool(
+            chunk_count == 1
+            and single_exact_fast_enabled
+            and _single_exact_fast_release_evidence(
+                refill_joined_output,
+                refill_independent_output,
+                min_speaker_similarity=single_exact_similarity,
+                max_boundary_speaker_drop=single_exact_boundary,
+                min_squim_stoi=preferred_stoi,
+                min_squim_pesq=preferred_pesq,
+                min_audio_duration_seconds=preferred_squim_duration,
+            )
+        )
         if (
             chunk_count == 1
             and preferred_single_search
             and refill_verification.passed is True
-            and refill_preferred
+            and (refill_preferred or refill_fast_exact)
         ):
             preferred_candidate = diagnostic_candidates[-1]
             preferred_artifact = preferred_candidate.verification.chunk_artifacts[0]
             preferred_reached_hard_cap = (
                 _endpoint_artifact_reached_hard_cap(preferred_artifact)
             )
+            allow_natural_endpoint_waiver = bool(
+                refill_preferred and preferred_reached_hard_cap
+            )
             selectable = [
                 candidate
                 for candidate in diagnostic_candidates
@@ -5538,7 +5646,21 @@ def run_coverage_adaptive_cascade(
                         ),
                     )
                     or (
-                        preferred_reached_hard_cap
+                        single_exact_fast_enabled
+                        and _single_exact_fast_release_evidence(
+                            candidate.joined_output,
+                            candidate.independent_output,
+                            min_speaker_similarity=single_exact_similarity,
+                            max_boundary_speaker_drop=single_exact_boundary,
+                            min_squim_stoi=preferred_stoi,
+                            min_squim_pesq=preferred_pesq,
+                            min_audio_duration_seconds=(
+                                preferred_squim_duration
+                            ),
+                        )
+                    )
+                    or (
+                        allow_natural_endpoint_waiver
                         and _preferred_natural_endpoint_waiver(
                             candidate.verification,
                             candidate.verification.chunk_artifacts[0],

tests/test_coverage_adaptive.py

@@ -90,6 +90,7 @@ def _squim_verification(
     speaker_similarity=0.30,
     boundary_drop=0.01,
     audio_duration_seconds=2.0,
+    hard_max_boundary_speaker_drop=0.03,
 ):
     observations = []
     artifacts = []
@@ -118,6 +119,7 @@ def _squim_verification(
         observations,
         chunk_artifacts=artifacts,
         max_pace_cps=4.3,
+        max_boundary_speaker_drop=hard_max_boundary_speaker_drop,
         squim_gate_enabled=True,
         min_squim_stoi=0.60,
         min_squim_pesq=1.12,
@@ -478,6 +480,210 @@ def test_single_chunk_uses_exact_joined_preferred_evidence_for_early_return():
     assert selected.joined_output.result.speaker_similarity == pytest.approx(0.30)
 
 
+def test_single_chunk_initial_exact_fast_tier_returns_without_refill():
+    chunk = ("完整內容",)
+    generated = []
+
+    def whole_verifier(trajectory, candidate_chunks, seed):
+        exact = _squim_verification(
+            candidate_chunks,
+            stoi=0.75,
+            pesq=1.25,
+            speaker_similarity=0.24,
+            boundary_drop=0.075,
+            hard_max_boundary_speaker_drop=0.10,
+        )
+        return CandidateVerification(
+            exact,
+            joined_output=trajectory_gate_evidence(exact),
+            independent_output=trajectory_gate_evidence(
+                _exact_final(candidate_chunks)
+            ),
+        )
+
+    result = run_coverage_adaptive_cascade(
+        chunk,
+        80,
+        lambda candidate_chunks, seed: (
+            generated.append(seed) or (f"audio-{seed}",)
+        ),
+        whole_verifier,
+        lambda *args: pytest.fail("exact fast initial must not refill"),
+        sequence_final_verifier=lambda *args: pytest.fail(
+            "exact fast initial must not enter sequence search"
+        ),
+        preferred_min_speaker_similarity=0.25,
+        preferred_max_boundary_speaker_drop=0.05,
+        preferred_min_squim_stoi=0.72,
+        preferred_min_squim_pesq=1.20,
+        preferred_min_squim_audio_duration_seconds=1.5,
+        single_exact_min_speaker_similarity=0.23,
+        single_exact_max_boundary_speaker_drop=0.08,
+    )
+
+    assert generated == [80]
+    assert result.candidate_index == 0
+    assert result.generated_chunk_count == 1
+
+
+def test_single_chunk_refill_exact_fast_tier_returns_before_more_candidates():
+    chunk = ("完整內容",)
+    generated = []
+
+    def refill_verifier(trajectory, candidate_chunks, seed):
+        local = _squim_verification(
+            candidate_chunks,
+            stoi=0.75,
+            pesq=1.25,
+            speaker_similarity=0.20,
+        )
+        exact = _squim_verification(
+            candidate_chunks,
+            stoi=0.75,
+            pesq=1.25,
+            speaker_similarity=0.24,
+            boundary_drop=0.075,
+            hard_max_boundary_speaker_drop=0.10,
+        )
+        return CandidateVerification(
+            local,
+            joined_output=trajectory_gate_evidence(exact),
+            independent_output=trajectory_gate_evidence(
+                _exact_final(candidate_chunks)
+            ),
+        )
+
+    result = run_coverage_adaptive_cascade(
+        chunk,
+        10,
+        lambda candidate_chunks, seed: (
+            generated.append(seed) or (f"audio-{seed}",)
+        ),
+        lambda trajectory, candidate_chunks, seed: _joined_rejected_local(
+            candidate_chunks,
+            passing=(False,),
+        ),
+        refill_verifier,
+        sequence_final_verifier=lambda *args: pytest.fail(
+            "exact fast refill must return before sequence search"
+        ),
+        max_generated_chunks=5,
+        max_generated_text_units=100,
+        preferred_min_speaker_similarity=0.25,
+        preferred_max_boundary_speaker_drop=0.05,
+        preferred_min_squim_stoi=0.72,
+        preferred_min_squim_pesq=1.20,
+        preferred_min_squim_audio_duration_seconds=1.5,
+        single_exact_min_speaker_similarity=0.23,
+        single_exact_max_boundary_speaker_drop=0.08,
+    )
+
+    assert generated == [10, 11]
+    assert result.seed == 11
+    assert result.candidate_index == 1
+    assert result.generated_chunk_count == 2
+
+
+def test_single_exact_fast_tier_never_uses_local_proxy():
+    chunk = ("完整內容",)
+    generated = []
+
+    def verifier(trajectory, candidate_chunks, seed):
+        if seed == 10:
+            return _squim_verification(
+                candidate_chunks,
+                stoi=0.75,
+                pesq=1.25,
+                speaker_similarity=0.24,
+                boundary_drop=0.075,
+                hard_max_boundary_speaker_drop=0.10,
+            )
+        return _squim_verification(
+            candidate_chunks,
+            stoi=0.75,
+            pesq=1.25,
+            speaker_similarity=0.30,
+            boundary_drop=0.02,
+        )
+
+    result = run_coverage_adaptive_cascade(
+        chunk,
+        10,
+        lambda candidate_chunks, seed: (
+            generated.append(seed) or (f"audio-{seed}",)
+        ),
+        verifier,
+        verifier,
+        sequence_final_verifier=lambda *args: pytest.fail(
+            "strict preferred refill must return before sequence search"
+        ),
+        max_generated_chunks=5,
+        max_generated_text_units=100,
+        preferred_min_speaker_similarity=0.25,
+        preferred_max_boundary_speaker_drop=0.05,
+        preferred_min_squim_stoi=0.72,
+        preferred_min_squim_pesq=1.20,
+        preferred_min_squim_audio_duration_seconds=1.5,
+        single_exact_min_speaker_similarity=0.23,
+        single_exact_max_boundary_speaker_drop=0.08,
+    )
+
+    assert generated == [10, 11]
+    assert result.seed == 11
+
+
+def test_single_exact_fast_tier_requires_independent_whole_asr_evidence():
+    chunk = ("完整內容",)
+    generated = []
+
+    def verifier(trajectory, candidate_chunks, seed):
+        if seed == 10:
+            exact = _squim_verification(
+                candidate_chunks,
+                stoi=0.75,
+                pesq=1.25,
+                speaker_similarity=0.24,
+                boundary_drop=0.075,
+                hard_max_boundary_speaker_drop=0.10,
+            )
+            return CandidateVerification(
+                exact,
+                joined_output=trajectory_gate_evidence(exact),
+            )
+        return _squim_verification(
+            candidate_chunks,
+            stoi=0.75,
+            pesq=1.25,
+            speaker_similarity=0.30,
+            boundary_drop=0.02,
+        )
+
+    result = run_coverage_adaptive_cascade(
+        chunk,
+        10,
+        lambda candidate_chunks, seed: (
+            generated.append(seed) or (f"audio-{seed}",)
+        ),
+        verifier,
+        verifier,
+        sequence_final_verifier=lambda *args: pytest.fail(
+            "strict preferred refill must return before sequence search"
+        ),
+        max_generated_chunks=5,
+        max_generated_text_units=100,
+        preferred_min_speaker_similarity=0.25,
+        preferred_max_boundary_speaker_drop=0.05,
+        preferred_min_squim_stoi=0.72,
+        preferred_min_squim_pesq=1.20,
+        preferred_min_squim_audio_duration_seconds=1.5,
+        single_exact_min_speaker_similarity=0.23,
+        single_exact_max_boundary_speaker_drop=0.08,
+    )
+
+    assert generated == [10, 11]
+    assert result.seed == 11
+
+
 def test_preferred_refill_selects_prior_natural_endpoint_over_forced_candidate():
     chunk = ("完整內容",)
     generated = []
@@ -555,6 +761,90 @@ def test_preferred_refill_selects_prior_natural_endpoint_over_forced_candidate()
     ]
 
 
+def test_fast_exact_refill_cannot_select_relaxed_endpoint_waiver_candidate():
+    chunk = ("完整內容",)
+    generated = []
+
+    def verifier(trajectory, candidate_chunks, seed):
+        if seed == 10:
+            return _squim_verification(
+                candidate_chunks,
+                stoi=0.65,
+                pesq=1.15,
+                speaker_similarity=0.30,
+            )
+        if seed == 11:
+            return _squim_verification(
+                candidate_chunks,
+                stoi=0.71,
+                pesq=1.19,
+                speaker_similarity=0.30,
+            )
+        exact = _squim_verification(
+            candidate_chunks,
+            stoi=0.75,
+            pesq=1.25,
+            speaker_similarity=0.24,
+            boundary_drop=0.075,
+            hard_max_boundary_speaker_drop=0.10,
+        )
+        return CandidateVerification(
+            exact,
+            joined_output=trajectory_gate_evidence(exact),
+            independent_output=trajectory_gate_evidence(
+                _exact_final(candidate_chunks)
+            ),
+        )
+
+    def generation_evidence(candidate_index, seed, chunk_indices, candidate_chunks):
+        threshold_stop = candidate_index == 1
+        return CandidateGenerationEvidence(
+            chunk_indices=chunk_indices,
+            chunk_text_units=(4,),
+            scheduled_cfg=generation_cfg_for_candidate_offset(candidate_index),
+            effective_cfgs=(
+                generation_cfg_for_candidate_offset(candidate_index),
+            ),
+            floor_reasons=((),),
+            chunk_stop_reasons=(
+                ("stop_threshold",) if threshold_stop else ("hard_stop",)
+            ),
+            chunk_endpoint_energy_ratios=(
+                (0.10,) if threshold_stop else (0.90,)
+            ),
+            chunk_generated_steps=((4,) if threshold_stop else (5,)),
+            chunk_hard_stop_steps=(5,),
+        )
+
+    result = run_coverage_adaptive_cascade(
+        chunk,
+        10,
+        lambda candidate_chunks, seed: (
+            generated.append(seed) or (f"audio-{seed}",)
+        ),
+        verifier,
+        verifier,
+        sequence_final_verifier=lambda *args: pytest.fail(
+            "fast exact refill must return before sequence search"
+        ),
+        generation_evidence_factory=generation_evidence,
+        max_generated_chunks=5,
+        max_generated_text_units=100,
+        preferred_min_speaker_similarity=0.25,
+        preferred_max_boundary_speaker_drop=0.05,
+        preferred_min_squim_stoi=0.72,
+        preferred_min_squim_pesq=1.20,
+        preferred_min_squim_audio_duration_seconds=1.5,
+        single_exact_min_speaker_similarity=0.23,
+        single_exact_max_boundary_speaker_drop=0.08,
+        require_endpoint_evidence=True,
+    )
+
+    assert generated == [10, 11, 12]
+    assert result.candidate_index == 2
+    assert result.seed == 12
+
+
 @pytest.mark.parametrize(
     ("field", "value"),
     [
@@ -960,6 +1250,36 @@ def test_coverage_preferred_thresholds_must_be_explicit_finite_pairs(preferred):
         )
 
 
+@pytest.mark.parametrize(
+    "single_exact",
+    [
+        {"single_exact_min_speaker_similarity": 0.23},
+        {"single_exact_max_boundary_speaker_drop": 0.08},
+        {
+            "single_exact_min_speaker_similarity": float("nan"),
+            "single_exact_max_boundary_speaker_drop": 0.08,
+        },
+        {
+            "single_exact_min_speaker_similarity": 0.23,
+            "single_exact_max_boundary_speaker_drop": 0.08,
+        },
+    ],
+)
+def test_single_exact_fast_thresholds_require_pair_and_preferred_squim(
+    single_exact,
+):
+    with pytest.raises(ValueError, match="single exact"):
+        run_coverage_adaptive_cascade(
+            ("完整內容",),
+            10,
+            lambda chunks, seed: tuple(chunks),
+            lambda trajectory, chunks, seed: _local_verification(chunks),
+            lambda trajectory, chunks, seed: _local_verification(chunks),
+            sequence_final_verifier=lambda result, chunks: _exact_final(chunks),
+            **single_exact,
+        )
+
+
 def test_refill_budget_accounts_exact_generated_chunks_and_text_units():
     chunks = ("甲乙", "丙丁")
     generated = []

tests/test_release_pins.py

@@ -1102,6 +1102,8 @@ def test_space_applies_pinned_squim_to_local_joined_and_final_audio():
     assert 'QUALITY_PREFERRED_MIN_SQUIM_PESQ = 1.20' in app_source
     assert 'QUALITY_PREFERRED_MIN_SPEAKER_SIMILARITY = 0.25' in app_source
     assert 'QUALITY_PREFERRED_MAX_BOUNDARY_SPEAKER_DROP = 0.05' in app_source
+    assert 'QUALITY_FAST_EXACT_MIN_SPEAKER_SIMILARITY = 0.23' in app_source
+    assert 'QUALITY_FAST_EXACT_MAX_BOUNDARY_SPEAKER_DROP = 0.08' in app_source
     assert "if not semantic_only and transcript:" in verify_source
     score_index = verify_source.index("squim_objective_evidence_from_audio(")
     observation_index = verify_source.index("CandidateObservation(", score_index)
@@ -1138,6 +1140,8 @@ def test_space_applies_pinned_squim_to_local_joined_and_final_audio():
         "preferred_min_squim_stoi=QUALITY_PREFERRED_MIN_SQUIM_STOI",
         "preferred_min_squim_pesq=QUALITY_PREFERRED_MIN_SQUIM_PESQ",
         "QUALITY_PREFERRED_SQUIM_MIN_DURATION_SECONDS",
+        "single_exact_min_speaker_similarity=",
+        "single_exact_max_boundary_speaker_drop=",
     ):
         assert argument in synthesize_source
     assert "QUALITY_PREFERRED_SQUIM_MIN_DURATION_SECONDS = 1.50" in app_source