Use Breeze25 for efficient semantic verification

README.md

@@ -11,6 +11,7 @@ license: apache-2.0
 short_description: 台灣華語與中英混合文字轉語音
 models:
   - OpenFormosa/BlueMagpie-TTS
+  - MediaTek-Research/Breeze-ASR-25
 ---
 
 # BlueMagpie-TTS Demo
@@ -41,10 +42,11 @@ Mamba2 所需的 Triton runtime 以
 `v2.3.2.post1` 的 Apache-2.0 上游原始碼隨 Space 保存（不綁定
 `selective_scan_cuda` 編譯產物），
 避免 Space 重啟後在沒有程式版本變更的情況下改變模型或 speaker embedding 空間。
-候選語意驗證固定使用 Whisper large-v3-turbo revision
-`41f01f3fe87f28c78e2fbf8b568835947dd65ed9`；exact-assembled whole-output
-語意驗證另固定使用 Whisper large-v3 revision
-`06f233fe06e710322aca913c1bc4249a0d71fce1`，兩者必須同時通過。
+所有內容驗證固定使用 `MediaTek-Research/Breeze-ASR-25` revision
+`cffe7ccb404d025296a00758d0a33468bec3a9d0`，model weight SHA-256 為
+`c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6`。
+普通、reference 與 long-form request 共用同一個固定中文、greedy、transcribe
+decoder profile；同一 request 的 exact waveform 只解碼一次。
 
 | 設定 | 值 |
 |---|---:|
@@ -62,16 +64,16 @@ Mamba2 所需的 Triton runtime 以
 | Hard stop | native-pace target steps, independent of playback pace; URL/email chunks use a separate conservative endpoint-duration counter (ASCII alnum run ÷ 2) |
 | Pace correction | derive total/active pace after completion; probe the corrected waveform and, when needed, re-render once from the untouched model waveform toward 3.95 active units/sec (ordinary `1536/384`; URL/email code-switch `2048/512`); no active-interval slicing |
 | 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 |
+| Semantic verification | one pinned Breeze-ASR-25 decode; orthographic whole CER + tone-aware acoustic first/last 6 exact + no lexical tail; range-proven URL/email locals and every exact whole output retain separate hard projections over the cached transcript; 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, 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 |
+| 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 Breeze25 semantics, 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; a complete rank-1 path is checked immediately, and a hard-pass/preferred-miss path gets one bounded incremental replacement check while one final-search slot remains reserved; 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 |
+| 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 cached Breeze25 semantic/release projections and the stricter 0.105/0.095 whole gate |
 | Final output gate | re-verify joined/faded/RMS-matched/speed-adjusted whole waveform; fail closed |
 | Runtime budget | ordinary non-network requests up to 48 speech units stop after at most 10 generated TTS chunks; other requests retain the 32-chunk hard cap. Every request is also capped at 800 generated speech units; NFE remains fixed at 10 |
 | Maximum chunk | ordinary request 80 speech units; every chunk in a URL/email request 36 units |
@@ -97,13 +99,14 @@ exact 32-entry grammar: `letter-a` through `letter-z` are spoken as
 `symbol-dot`, `symbol-hyphen`, `symbol-underscore`, `symbol-colon` and
 `symbol-slash` are respectively `網路符號小老鼠`, `網路符號點`,
 `這個符號叫做橫線`, `這個符號叫做底線`, `這個符號叫做冒號` and
-`網路符號斜線`.  Its recorded Whisper, ECAPA and SQUIM values are
+`網路符號斜線`.  Its recorded Breeze25, ECAPA and SQUIM values are
 **attestations only**: successfully loading the manifest never sets
 `runtime_quality_verified`, never runs those evaluators, and is not a release
-pass.  A release evaluator must independently load the pinned Whisper
-large-v3-turbo, Whisper large-v3 (and the frozen third ASR where required),
-ECAPA and SQUIM artifacts, recompute their evidence from the exact assembled
-PCM16 delivered to the user, and apply the unchanged frozen release gates.
+pass. The glyph evidence boundary loads the same pinned Breeze25 weights with
+two explicit decoder profiles—fixed `zh` primary and auto-language
+confirmation—plus ECAPA and SQUIM, recomputes their evidence from the exact
+assembled PCM16 delivered to the user, and applies the frozen release gates.
+The two profiles are not represented as independent model weights.
 Silent PCM accompanied by invented passing numbers is rejected and can never
 be promoted by the asset loader.
 
@@ -142,7 +145,8 @@ added, preserving every frozen asset byte.
 `root seed + global generation offset`，不會重新生成其他已覆蓋 chunks。三種 policy 都只改 native-duration endpoint estimate，
 margin 固定 +1 latent step、`min_len` 固定為 2，不會為了播放目標語速硬撐 generation loop。
 唯一例外是 completion-headroom 的一至兩單位短句：其 sparse retry 將 hard cap 下限提高到 5 steps，
-讓第一個 eligible weak-stop 有一次真正的 threshold 判定機會；所有額外內容仍須通過雙 ASR 與 tail=0。
+讓第一個 eligible weak-stop 有一次真正的 threshold 判定機會；所有額外內容仍須通過 Breeze25
+semantic gate 與 tail=0。
 選中完整 trajectory 或 coverage-sequence-DP 混合路徑後，log 會記錄每個 chunk 的 candidate、seed、policy、實際 CFG，
 並記錄每個已嘗試 row-local ordinal 的 schedule CFG。Ordinal 0 與正偶數使用 primary CFG 3.0，
 正奇數使用 alternate CFG 2.0；含 URL/email component 的 chunk 仍有 CFG 3.0 的內容安全下限。
@@ -157,13 +161,13 @@ speech-unit counter；只有 URL/email-conditioned native endpoint estimate 對
 終端 outcome 另輸出 content-free canonical evidence schema v6，包含 original chunk indices、
 row-local ordinal、network provenance、CFG contract、32/800 預算用量與 selected-path 交叉檢查，
 每個 chunk 的 stop reason、pre-fade endpoint energy、generated/hard-stop steps，
-每個 local row 的 independent-large-v3 attempted/pass/proof-count/result attestation，以及
-local、joined、independent-large-v3 與 final gate 的 bounded SQUIM scalar，
+每個 local row 的 secondary semantic projection attempted/pass/proof-count/result attestation，以及
+local、joined、secondary semantic projection 與 final gate 的 bounded SQUIM scalar，
 不包含 target/transcript/audio/embedding。
 為了讓 release contract 與正式量測一致，UI 不提供其他 primary CFG。
 內部 hosted evaluator 可注入 `[0, 2^31)` 的固定 root seed 以重現結果；UI 不暴露這個參數，
 一般請求仍只在未注入 seed 時使用系統亂數。
-初始完整 same-seed trajectory 永遠優先；通過 turbo + full large-v3 exact-whole gate 就立即回傳，
+初始完整 same-seed trajectory 永遠優先；通過 Breeze25 exact-whole semantic/release gate 就立即回傳，
 不會執行 refill 或 DP。若失敗，之後只做單 chunk refill，不再生成第二條完整 trajectory。
 Ragged DP 可混合已通過 hard gate 的 chunks，
 以及下述唯一 boundary-only、drop 不超過 0.15 的 DP-only chunks。切段保留標點，並依逗號、分號或句末標點
@@ -177,23 +181,22 @@ Ragged DP 可混合已通過 hard gate 的 chunks，
 逐 sample 冪等，因此驗證的就是使用者收到的 PCM codes；同時不讓 Gradio 對 float ndarray
 再做 peak normalization，以免額外放大底噪。
 完成 RMS matching、edge fade、pause、crossfade 與使用者 speed 後，服務會再對最終整段 waveform
-執行 normalized target 的 prefix/whole/suffix/tail、pace 與 speaker anchor/boundary gate，並要求
-turbo 與 full large-v3 的語意 hard intersection；這個 post-join gate 失敗時不會回傳先前已通過的
-chunk 音訊。除此之外，每個帶有 planner range proof 的 URL/email local chunk 在進入 coverage pool
-以前，也必須用完全相同的 `NetworkFragmentProof` 同時通過 turbo 與 pinned full large-v3；
-large-v3 reject 會成為不可被 boundary proxy 放寬的 semantic hard failure。一般 local chunk
-維持 turbo gate；已被 turbo 的非 boundary hard gate 拒絕、原本就不可能進 pool 的 network row
-不額外耗用 full large-v3。Production assembler 產生的 exact whole candidate 或 exact sequence path 仍全部
-使用 dual-ASR。Initial whole rejection 會啟動低覆蓋 refill，sequence rejection 則只會前進到
-下一條已排序的 exact path。
+執行 normalized target 的 prefix/whole/suffix/tail、pace 與 speaker anchor/boundary gate。內容只由
+固定 Breeze25 profile 解碼一次，再由 release 與 semantic-only 兩個 hard projection 檢查同一份
+exact transcript；這個 post-join gate 失敗時不會回傳先前已通過的 chunk 音訊。除此之外，每個
+帶有 planner range proof 的 URL/email local chunk 在進入 coverage pool 以前，也必須用完全相同的
+`NetworkFragmentProof` 通過 primary 與 secondary semantic projection；secondary reject 仍是不可被
+boundary proxy 放寬的 semantic hard failure。兩個 projection 透過 exact-waveform cache 共用一次
+Breeze25 decode，不再載入或執行第二個 ASR 模型。Initial whole rejection 會啟動低覆蓋 refill，
+sequence rejection 則只會前進到下一條已排序的 exact path。
 此外，初始 same-seed trajectory 只有在每個 local chunk 都通過後，才會先用同一個
 `_assemble_trajectory_audio` 組成實際播放版本並跑整段 semantic/pace/speaker gate；joined gate
 失敗會取消該 whole trajectory 的資格，但保留已通過的 local evidence 供 sequence DP 使用。
-這個額外 dual-ASR whole gate 只對 local turbo 全數通過的候選執行，DP 選定後仍會保留上述最終
+這個額外 whole gate 只對 local Breeze25 全數通過的候選執行，DP 選定後仍會保留上述最終
 post-join gate。每個 request 只在 waveform float32 bytes、sample rate、normalized target 與 pinned
-verifier profile 完全相同時重用 full large-v3 evidence；任何 sample 改變都會重新驗證。ASR loader
-異常、OOM、空 transcript 或無效 evidence 都 fail closed，不會降級為 turbo-only。同一 request
-內若 release 與 semantic verifier 使用完全相同的精確 waveform、sample rate、Whisper
+verifier profile 完全相同時重用 evidence；任何 sample 改變都會重新驗證。ASR loader
+異常、OOM、空 transcript 或無效 evidence 都 fail closed，不會降級為未驗證輸出。同一 request
+內若 release 與 semantic verifier 使用完全相同的精確 waveform、sample rate、Breeze25
 model/revision、語言、token cap 與 segmentation cap，會共用一次 transcript decode；cache
 不跨 request，exception 與無效結果不會寫入。
 初始 whole trajectory 未通過後，refill scheduler 會優先補 coverage=0 的 rows，再補不足 3 個
@@ -208,7 +211,7 @@ rank-1 path 時會立即再驗證一次；若首條 path 連 hard gate 都未通
 已通過 local hard gate 的 chunk 可直接進入 DP；唯一 rejection reason 是
 `boundary_speaker_drop`、且 drop 不超過 0.15 的 chunk 也可作為 DP-only 候選。Single-chunk
 request 可使用相同的 local proxy，但仍必須重新通過 exact whole-waveform 0.105/0.095 release guard。
-若 exact joined waveform 已通過 dual-ASR，single-chunk preferred early return 以該 release
+若 exact joined waveform 已通過 Breeze25 semantic/release projections，single-chunk preferred early return 以該 release
 ECAPA/SQUIM evidence 為準，不會因較粗的 local windowed boundary proxy 再生成多個無用候選。
 這個 boundary-only relaxation 不適用於 semantic、pace、speaker similarity、缺少 evidence 或 whole-trajectory
 accept，也不能在缺少整段 final verifier 時啟用。Local score 加上相鄰 ECAPA/RMS transition
@@ -248,10 +251,10 @@ spoken range；planner、Space runtime 與 local ASR 入口都會從 raw identif
 proof 完全相等。若 nested proof 被移除、range/rule/reordering 被修改，或非 naturalized identifier
 夾帶這組 provenance，會 fail closed。這個 naturalized phrase 在 generation planner 中是一個
 不可切 component；H07 因此是 35 public units 的單一 network chunk，沒有 artificial
-`network_internal` seam。兩個中文逗號只是模型 pause cue，Whisper 省略它們仍可通過；scheme cue、
+`network_internal` seam。兩個中文逗號只是模型 pause cue，Breeze25 省略它們仍可通過；scheme cue、
 host、path 與 terminator 仍是 exact lexical protected range。
 
-完整 identifier 仍保留為 joined、full-large-v3 與 final ASR 的 exact protected target。完整
+完整 identifier 仍保留為 joined 與 final Breeze25 ASR 的 exact protected target。完整
 URL spoken proof 不超過 36 units 時仍保持單一 atomic chunk；URL 後的逗號也留在同一 chunk。
 Hosted profile 對 bounded email 只開放一��更窄的例外：同一 strong sentence 必須恰好只有一個
 email、email 前的 prose 至少 12 units、domain fragment 至少 8 units，且在 range-proven `@`／
@@ -278,9 +281,9 @@ URL 與後續英文 prose 應以空白或中文標點分隔；未分隔的 RFC p
 本身的一部分並納入 exact gate。Quoted email local-part 暫不支援，輸入時會直接 fail closed。
 URL identifier 目前只支援 ASCII；非 ASCII IRI 必須先轉成 ASCII/percent-encoded 形式，
 否則會因字母讀音碰撞而在 normalization 前 fail closed。
-為避免 Whisper 自動句末標點和 URL 內容不可判定，URL 不接受以 `. , ! ? ; : '` 結尾；
+為避免 Breeze25 自動句末標點和 URL 內容不可判定，URL 不接受以 `. , ! ? ; : '` 結尾；
 需要這些尾端符號時請使用 percent encoding。
-Whisper 常見的 `15点30分`/`15點30分` 會視為同一讀法；裸寫 `15點30` 只有在 target
+Breeze25 常見的 `15点30分`/`15點30分` 會視為同一讀法；裸寫 `15點30` 只有在 target
 明確含同一個完整鐘點讀法時才作 ASR-only canonicalization。比分、秒數、重量、裸 `15點`、
 非法時間與真實漏字仍會被拒絕。Whole-output ASR 只使用 waveform evidence：若所有符合
 250 ms、兩側皆有 active speech 的 pause atoms 都能將音訊限制在 28 秒內，就保留
@@ -296,8 +299,8 @@ target-dependent fallback。每段至少 1.25 秒、硬上限 30 秒，每次驗
 normalization 不會修改送入模型的文字；既有同音代詞 canonicalization 仍保留。
 只有尚未 assemble 的 internal local chunk 允許首、尾 6 units 各最多一個 substitution，且
 deletion 必須為 0；由原始 `GenerationChunkSpec` 證明的 request 第一段 prefix 與最後一段
-suffix 仍必須 exact。Refill 依原始絕對 chunk provenance 套用相同角色。Joined turbo、
-independent full-large-v3 與 final whole-waveform gate 全部維持 exact endpoint。
+suffix 仍必須 exact。Refill 依原始絕對 chunk provenance 套用相同角色。Joined、semantic-only
+projection 與 final whole-waveform Breeze25 gate 全部維持 exact endpoint。
 
 自然 stop 在目前 checkpoint 上仍可能過快或錯過句尾。Demo 不再用播放目標語速決定生成長度；
 模型使用原生語速的安全上限，完成後才做保音高語速校正。缺少句末標點時只在模型輸入補上句號，
@@ -328,9 +331,11 @@ echo/smearing gate。Gate 聚合多個 active windows 的 24–180 ms 長 quefre
 delayed-copy comb peak 或 dense smearing signature；無效、非有限或缺少足夠 active-window
 evidence 都 fail closed。短於 1.0 秒時 estimator 不適用，仍由原有 strict semantic、endpoint
 與 SQUIM gate 負責。任何仍過快、被 stretch 破壞或具有可量測回音的候選均不會回傳。
-每個 local row 先完成 Turbo ASR 與同一 active-duration pace gate；若此時已確定為 semantic
-或 pace hard failure，便保留該拒絕 evidence 並跳過 ECAPA、SQUIM、echo 與 F0。只有仍可能
-回傳或進入 DP 的候選才支付完整 acoustic verification，最終 speaker/SQUIM/echo 門檻不變。
+每個 local row 先計算同一個不可繞過的 active-duration pace gate；明確超過
+`4.85 + 0.05` CPS 的候選會直接保留 fail-closed 拒絕 evidence，不再支付 Breeze25、ECAPA、
+SQUIM、echo 或 F0 成本。其餘候選才以 Breeze25 驗證內容，再對 semantic hard failure
+同樣停止後續 acoustic work。只有仍可能回傳或進入 DP 的候選才支付完整 acoustic
+verification，最終內容、speaker、SQUIM、pace 與 echo 門檻均不變。
 Median-F0 只在 multi-chunk lattice 真的出現兩條以上可選路徑、必須計算 transition ranking
 時，才對 retained DP candidates 延遲計算一次；單一路徑、single/K32、semantic reject、
 joined 與 final waveform 不再支付無用的 pYIN latency。真正進入多路徑排序時，pYIN 演算法與

app.py

@@ -169,13 +169,12 @@ from production import (
 )
 from quality_runtime import (
     BASE_GENERATION_POLICY,
+    BREEZE25_MAX_VERIFICATION_SEGMENTS,
+    BREEZE25_MODEL_ID,
+    BREEZE25_REVISION,
+    BREEZE25_WEIGHT_SHA256,
     GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS as QUALITY_GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS,
     SAFE_DURATION_GENERATION_POLICY,
-    VERIFICATION_WHISPER_MODEL_ID,
-    VERIFICATION_WHISPER_REVISION,
-    WHISPER_MAX_VERIFICATION_SEGMENTS,
-    WHISPER_MODEL_ID,
-    WHISPER_REVISION,
     CandidateGenerationContext,
     CandidateGenerationEvidence,
     CandidateVerification,
@@ -208,8 +207,7 @@ from quality_runtime import (
     run_coverage_adaptive_cascade,
     speaker_evidence_from_audio,
     squim_objective_evidence_from_audio,
-    transcribe_verification_whisper,
-    transcribe_whisper,
+    transcribe_breeze25,
     trajectory_gate_evidence,
     verify_candidate,
     verify_trajectory,
@@ -286,9 +284,9 @@ 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.
+# A single-chunk waveform that has passed both Breeze25 semantic projections
+# 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 tier.
 QUALITY_FAST_EXACT_MIN_SPEAKER_SIMILARITY = 0.23
 QUALITY_FAST_EXACT_MAX_BOUNDARY_SPEAKER_DROP = 0.08
 QUALITY_MAX_SEQUENCE_PATHS = 3
@@ -308,31 +306,37 @@ if (
     GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS
     != QUALITY_GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS
 ):
-    raise RuntimeError("glyph-hybrid Whisper segment caps disagree")
-VERIFICATION_ASR_PROFILE = (
-    f"{VERIFICATION_WHISPER_MODEL_ID}@{VERIFICATION_WHISPER_REVISION}:"
+    raise RuntimeError("glyph-hybrid Breeze25 segment caps disagree")
+BREEZE25_SEMANTIC_VERIFICATION_PROFILE = (
+    f"{BREEZE25_MODEL_ID}@{BREEZE25_REVISION}:"
+    f"weights{BREEZE25_WEIGHT_SHA256}:"
     f"greedy:zh:short{QUALITY_PREFIX_SUFFIX_UNITS}:cer{QUALITY_MAX_CER}:"
     f"prefix{QUALITY_PREFIX_SUFFIX_UNITS}=0:"
     f"suffix{QUALITY_PREFIX_SUFFIX_UNITS}=0:tail=0:"
     f"max_tokens{QUALITY_FINAL_ASR_MAX_NEW_TOKENS}"
 )
-TURBO_TRANSCRIPT_PROFILE = (
-    f"{WHISPER_MODEL_ID}@{WHISPER_REVISION}:greedy:zh:transcribe:"
+BREEZE25_TRANSCRIPT_PROFILE = (
+    f"{BREEZE25_MODEL_ID}@{BREEZE25_REVISION}:"
+    f"weights{BREEZE25_WEIGHT_SHA256}:greedy:zh:transcribe:"
     f"max_tokens{QUALITY_FINAL_ASR_MAX_NEW_TOKENS}:"
-    f"segments{WHISPER_MAX_VERIFICATION_SEGMENTS}"
+    f"segments{BREEZE25_MAX_VERIFICATION_SEGMENTS}"
 )
-LARGE_V3_TRANSCRIPT_PROFILE = (
-    f"{VERIFICATION_WHISPER_MODEL_ID}@{VERIFICATION_WHISPER_REVISION}:"
-    f"greedy:zh:transcribe:max_tokens{QUALITY_FINAL_ASR_MAX_NEW_TOKENS}:"
-    f"segments{WHISPER_MAX_VERIFICATION_SEGMENTS}"
-)
-RELEASE_TURBO_VERIFICATION_PROFILE = (
-    f"{TURBO_TRANSCRIPT_PROFILE}:release-speaker-squim-echo-wsola-v2:"
+BREEZE25_RELEASE_VERIFICATION_PROFILE = (
+    f"{BREEZE25_TRANSCRIPT_PROFILE}:release-speaker-squim-echo-wsola-v2:"
     f"pace{QUALITY_MAX_PACE_CPS}"
 )
-RELEASE_LARGE_V3_VERIFICATION_PROFILE = (
-    f"{LARGE_V3_TRANSCRIPT_PROFILE}:release-speaker-squim-echo-wsola-v2:"
-    f"pace{QUALITY_MAX_PACE_CPS}"
+BREEZE25_SNAPSHOT_ALLOW_PATTERNS = (
+    "added_tokens.json",
+    "config.json",
+    "generation_config.json",
+    "merges.txt",
+    "model.safetensors",
+    "normalizer.json",
+    "preprocessor_config.json",
+    "special_tokens_map.json",
+    "tokenizer.json",
+    "tokenizer_config.json",
+    "vocab.json",
 )
 
 
@@ -340,15 +344,15 @@ print(f"[BlueMagpie] downloading model from {REPO_ID}@{MODEL_REVISION} ...")
 MODEL_DIR = snapshot_download(REPO_ID, revision=MODEL_REVISION)
 print(f"[BlueMagpie] caching speaker encoder from {ECAPA_REPO_ID}@{ECAPA_REVISION} ...")
 ECAPA_DIR = snapshot_download(ECAPA_REPO_ID, revision=ECAPA_REVISION)
-print(f"[BlueMagpie] caching quality ASR from {WHISPER_MODEL_ID}@{WHISPER_REVISION} ...")
-ASR_DIR = snapshot_download(WHISPER_MODEL_ID, revision=WHISPER_REVISION)
-print(
-    "[BlueMagpie] caching independent final ASR from "
-    f"{VERIFICATION_WHISPER_MODEL_ID}@{VERIFICATION_WHISPER_REVISION} ..."
+BREEZE25_ASR_DIR = snapshot_download(
+    BREEZE25_MODEL_ID,
+    revision=BREEZE25_REVISION,
+    allow_patterns=BREEZE25_SNAPSHOT_ALLOW_PATTERNS,
 )
-VERIFICATION_ASR_DIR = snapshot_download(
-    VERIFICATION_WHISPER_MODEL_ID,
-    revision=VERIFICATION_WHISPER_REVISION,
+print(
+    "[BlueMagpie] cached content verifier from "
+    f"{BREEZE25_MODEL_ID}@{BREEZE25_REVISION} "
+    f"weights={BREEZE25_WEIGHT_SHA256[:12]}"
 )
 tokenizer = PreTrainedTokenizerFast(tokenizer_file=os.path.join(MODEL_DIR, "tokenizer.json"))
 print(f"[BlueMagpie] loading model on device={DEVICE} ...")
@@ -1093,7 +1097,7 @@ def _verify_trajectory_audio(
     asr_max_new_tokens: int = 128,
     *,
     release_speaker_gate: bool = False,
-    transcriber=transcribe_whisper,
+    transcriber=transcribe_breeze25,
     semantic_only: bool = False,
     network_fragment_proofs: (
         tuple[tuple[NetworkFragmentProof, ...], ...] | None
@@ -1144,8 +1148,53 @@ def _verify_trajectory_audio(
             strict=True,
         )
     ):
+        try:
+            waveform = np.asarray(audio, dtype=np.float32).reshape(-1)
+            if waveform.size == 0 or not np.isfinite(waveform).all():
+                raise ValueError("candidate waveform is invalid")
+            duration = active_voiced_duration_seconds(waveform, SR)
+        except (TypeError, ValueError, OverflowError):
+            observations.append(
+                CandidateObservation(
+                    target_text=chunk,
+                    transcript_text="",
+                    audio_duration_seconds=0.0,
+                    pace_cps=None,
+                )
+            )
+            artifacts.append(ChunkCandidateArtifact())
+            prepared_waveforms.append(None)
+            continue
+        speech_units = count_speech_units(chunk)
+        pace_cps = (
+            speech_units / duration * float(playback_speed)
+            if duration > 0.0
+            else None
+        )
+        if (
+            not semantic_only
+            and (
+                pace_cps is None
+                or pace_cps
+                > QUALITY_MAX_PACE_CPS + QUALITY_PREFLIGHT_PACE_MARGIN_CPS
+            )
+        ):
+            # A candidate that cannot pass the immutable pace gate must never
+            # be returned. Reject it before Breeze25, ECAPA, SQUIM and echo
+            # work; later cascade candidates still face every unchanged gate.
+            observations.append(
+                CandidateObservation(
+                    target_text=chunk,
+                    transcript_text="",
+                    audio_duration_seconds=duration,
+                    pace_cps=pace_cps,
+                )
+            )
+            artifacts.append(ChunkCandidateArtifact())
+            prepared_waveforms.append(None)
+            continue
         prepared = prepare_candidate_audio(
-            audio,
+            waveform,
             SR,
             transcriber=lambda waveform, sample_rate: transcriber(
                 waveform,
@@ -1166,10 +1215,6 @@ def _verify_trajectory_audio(
             prepared_waveforms.append(None)
             continue
         waveform = prepared.waveform
-        try:
-            duration = active_voiced_duration_seconds(waveform, SR)
-        except ValueError:
-            duration = 0.0
         transcript = prepared.transcript_text
         if fragment_proofs:
             fragment_evidence = canonicalize_asr_network_fragments(
@@ -1184,11 +1229,6 @@ def _verify_trajectory_audio(
                 if fragment_evidence.passed
                 else ""
             )
-        pace_cps = (
-            count_speech_units(chunk) / duration * float(playback_speed)
-            if duration > 0.0
-            else None
-        )
         semantic_observation = CandidateObservation(
             target_text=chunk,
             transcript_text=transcript,
@@ -1291,7 +1331,7 @@ def _verify_trajectory_audio(
                 begin_speaker_similarity=begin_similarity,
                 end_speaker_similarity=end_similarity,
                 pace_cps=(
-                    count_speech_units(chunk) / duration * float(playback_speed)
+                    speech_units / duration * float(playback_speed)
                     if duration > 0.0
                     else None
                 ),
@@ -1346,9 +1386,9 @@ def _verify_independent_whole_audio(
     anchor: np.ndarray,
     cache: WholeWaveformVerificationCache,
     *,
-    transcriber=transcribe_verification_whisper,
+    transcriber=transcribe_breeze25,
 ):
-    """Verify exact assembled audio with the independent full large-v3 ASR."""
+    """Apply the semantic-only projection using the cached Breeze25 transcript."""
 
     def verifier(exact_waveform, sample_rate, exact_target):
         if sample_rate != SR:
@@ -1367,7 +1407,7 @@ def _verify_independent_whole_audio(
         waveform,
         SR,
         target_text,
-        VERIFICATION_ASR_PROFILE,
+        BREEZE25_SEMANTIC_VERIFICATION_PROFILE,
         verifier,
     )
 
@@ -1437,43 +1477,45 @@ def _verify_release_whole_audio(
     )
 
 
-def _transcribe_glyph_hybrid_turbo(
+def _transcribe_glyph_hybrid_breeze_primary(
     audio: np.ndarray,
     sample_rate: int,
     *,
     language: str = "zh",
     task: str = "transcribe",
     max_new_tokens: int = 128,
+    max_verification_segments: int = GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS,
 ) -> str:
-    """Run Turbo with the bounded 128-asset + 32-carrier V5 cap."""
+    """Run the fixed-zh Breeze25 profile with the V5 segment cap."""
 
-    return transcribe_whisper(
+    return transcribe_breeze25(
         audio,
         sample_rate,
         language=language,
         task=task,
         max_new_tokens=max_new_tokens,
-        max_verification_segments=GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS,
+        max_verification_segments=max_verification_segments,
     )
 
 
-def _transcribe_glyph_hybrid_independent(
+def _transcribe_glyph_hybrid_breeze_confirmation(
     audio: np.ndarray,
     sample_rate: int,
     *,
-    language: str = "zh",
+    language: str | None = None,
     task: str = "transcribe",
     max_new_tokens: int = 128,
+    max_verification_segments: int = GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS,
 ) -> str:
-    """Run independent large-v3 with the same V5-only segment cap."""
+    """Run the auto-language Breeze25 confirmation profile for V5."""
 
-    return transcribe_verification_whisper(
+    return transcribe_breeze25(
         audio,
         sample_rate,
         language=language,
         task=task,
         max_new_tokens=max_new_tokens,
-        max_verification_segments=GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS,
+        max_verification_segments=max_verification_segments,
     )
 
 
@@ -1527,9 +1569,11 @@ _GLYPH_HYBRID_EVIDENCE_ADAPTER = HardenedGlyphHybridAdapter(
         asr_max_verification_segments=(
             GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS
         ),
-        turbo_transcriber=_transcribe_glyph_hybrid_turbo,
-        verification_transcriber=(
-            _transcribe_glyph_hybrid_independent
+        breeze_primary_transcriber=(
+            _transcribe_glyph_hybrid_breeze_primary
+        ),
+        breeze_confirmation_transcriber=(
+            _transcribe_glyph_hybrid_breeze_confirmation
         ),
     )
 )
@@ -1748,32 +1792,35 @@ def _verification_metric_log_fields(verification) -> str:
 
 
 def _verify_network_local_asr_intersection(
-    turbo_verification,
+    primary_verification,
     trajectory: tuple[np.ndarray, ...],
     chunks: tuple[str, ...],
     anchor: np.ndarray,
     proof_rows: tuple[tuple[NetworkFragmentProof, ...], ...] | None,
     *,
     candidate_seed: int,
+    transcriber=transcribe_breeze25,
 ):
-    """Require pinned large-v3 semantics before retaining network locals.
-
-    Only proof-bearing rows are sent through the independent model.  Their
-    exact ``NetworkFragmentProof`` tuples are reused unchanged, so neither ASR
-    can borrow a whole URL/email proof for a different local range.  The
-    intersection helper keeps turbo speaker/SQUIM/pace/artifact evidence while
-    projecting every independent rejection into a hard semantic local failure.
+    """Project cached Breeze25 semantics before retaining network locals.
+
+    Only proof-bearing rows receive the duplicate semantic projection. Their
+    exact ``NetworkFragmentProof`` tuples are reused unchanged, so neither
+    semantic projection can borrow a whole URL/email proof for another local
+    range. The
+    intersection helper keeps primary speaker/SQUIM/pace/artifact evidence
+    while projecting every semantic rejection into a hard local failure. The
+    request-local transcriber cache prevents a second decode of exact PCM.
     """
 
     if proof_rows is None:
-        return turbo_verification, tuple(
+        return primary_verification, tuple(
             LocalIndependentGateEvidence(False, None, 0, None)
             for _ in chunks
         )
     if (
         len(proof_rows) != len(chunks)
         or len(trajectory) != len(chunks)
-        or len(turbo_verification.candidate_results) != len(chunks)
+        or len(primary_verification.candidate_results) != len(chunks)
     ):
         raise ValueError("network local verification provenance does not align")
     independent_evidence = [
@@ -1791,7 +1838,7 @@ def _verify_network_local_asr_intersection(
         if (
             proofs
             and local_candidate_has_coverage_eligibility(
-                turbo_verification.candidate_results[index],
+                primary_verification.candidate_results[index],
                 max_local_boundary_speaker_drop=(
                     SEQUENCE_FALLBACK_MAX_LOCAL_BOUNDARY_SPEAKER_DROP
                 ),
@@ -1799,7 +1846,7 @@ def _verify_network_local_asr_intersection(
         )
     )
     if not selected_indices:
-        return turbo_verification, tuple(independent_evidence)
+        return primary_verification, tuple(independent_evidence)
     independent_proof_rows = tuple(
         proof_rows[index] for index in selected_indices
     )
@@ -1809,7 +1856,7 @@ def _verify_network_local_asr_intersection(
         anchor,
         1.0,
         QUALITY_FINAL_ASR_MAX_NEW_TOKENS,
-        transcriber=transcribe_verification_whisper,
+        transcriber=transcriber,
         semantic_only=True,
         network_fragment_proofs=independent_proof_rows,
     )
@@ -1823,7 +1870,7 @@ def _verify_network_local_asr_intersection(
         )
         comparison = result.comparison
         print(
-            "[BlueMagpie] network local independent "
+            "[BlueMagpie] network local Breeze25 projection "
             f"seed={candidate_seed} local_chunk_index={primary_index} "
             f"proof_count={len(proof_rows[primary_index])} "
             f"passed={result.passed} cer={comparison.cer:.6f} "
@@ -1834,7 +1881,7 @@ def _verify_network_local_asr_intersection(
         )
     return (
         intersect_local_semantic_verification(
-            turbo_verification,
+            primary_verification,
             independent_verification,
             selected_indices,
         ),
@@ -1852,8 +1899,8 @@ def _qualify_candidate_trajectory_audio(
     *,
     candidate_seed: int,
     chunk_specs: tuple[GenerationChunkSpec, ...] | None = None,
-    release_transcriber=transcribe_whisper,
-    independent_transcriber=transcribe_verification_whisper,
+    release_transcriber=transcribe_breeze25,
+    independent_transcriber=transcribe_breeze25,
 ):
     """Run whole-output qualification only after every local chunk passes."""
 
@@ -1863,6 +1910,8 @@ def _qualify_candidate_trajectory_audio(
         chunks,
         anchor,
         playback_speed,
+        QUALITY_FINAL_ASR_MAX_NEW_TOKENS,
+        transcriber=release_transcriber,
         network_fragment_proofs=proof_rows,
         local_endpoint_roles=_local_endpoint_role_rows(chunks, chunk_specs),
     )
@@ -1874,6 +1923,7 @@ def _qualify_candidate_trajectory_audio(
             anchor,
             proof_rows,
             candidate_seed=candidate_seed,
+            transcriber=independent_transcriber,
         )
     )
     if not local_verification.passed:
@@ -1894,7 +1944,7 @@ def _qualify_candidate_trajectory_audio(
         anchor,
         independent_cache,
         transcriber=release_transcriber,
-        verifier_profile=RELEASE_TURBO_VERIFICATION_PROFILE,
+        verifier_profile=BREEZE25_RELEASE_VERIFICATION_PROFILE,
     )
     qualified = qualify_trajectory_with_joined_output(
         local_verification,
@@ -1920,18 +1970,18 @@ def _qualify_candidate_trajectory_audio(
         independent_cache,
         transcriber=independent_transcriber,
     )
-    dual_qualified = qualify_trajectory_with_joined_output(
+    semantic_qualified = qualify_trajectory_with_joined_output(
         qualified,
         independent_verification,
     )
-    if not dual_qualified.passed:
+    if not semantic_qualified.passed:
         print(
-            "[BlueMagpie] candidate independent whole output rejected "
+            "[BlueMagpie] candidate Breeze25 semantic projection rejected "
             f"seed={candidate_seed} "
             f"{_verification_metric_log_fields(independent_verification)}"
         )
     return CandidateVerification(
-        dual_qualified,
+        semantic_qualified,
         independent_local_results=independent_local_results,
         joined_output=joined_evidence,
         independent_output=trajectory_gate_evidence(independent_verification),
@@ -1946,8 +1996,9 @@ def _verify_refill_candidate_trajectory_audio(
     chunk_specs: tuple[GenerationChunkSpec, ...] | None = None,
     *,
     candidate_seed: int,
+    transcriber=transcribe_breeze25,
 ):
-    """Apply strict dual-ASR local gates to one safe-duration refill."""
+    """Apply strict cached-Breeze25 local gates to one safe-duration refill."""
 
     if len(trajectory) != 1 or len(chunks) != 1:
         return verify_trajectory(())
@@ -1957,6 +2008,8 @@ def _verify_refill_candidate_trajectory_audio(
         chunks,
         anchor,
         playback_speed,
+        QUALITY_FINAL_ASR_MAX_NEW_TOKENS,
+        transcriber=transcriber,
         network_fragment_proofs=proof_rows,
         local_endpoint_roles=_local_endpoint_role_rows(chunks, chunk_specs),
     )
@@ -1968,6 +2021,7 @@ def _verify_refill_candidate_trajectory_audio(
             anchor,
             proof_rows,
             candidate_seed=candidate_seed,
+            transcriber=transcriber,
         )
     )
     return CandidateVerification(
@@ -1985,8 +2039,8 @@ def _verify_sequence_trajectory_audio(
     independent_cache: WholeWaveformVerificationCache,
     chunk_specs: tuple[GenerationChunkSpec, ...] | None = None,
     *,
-    release_transcriber=transcribe_verification_whisper,
-    independent_transcriber=transcribe_verification_whisper,
+    release_transcriber=transcribe_breeze25,
+    independent_transcriber=transcribe_breeze25,
 ):
     """Verify one ranked DP path after exact production assembly."""
 
@@ -1996,22 +2050,20 @@ def _verify_sequence_trajectory_audio(
         playback_speed,
         chunk_specs,
     )
-    # The release contract assigns local candidate coverage (including exact
-    # range-bound network fragments) to turbo and the exact assembled
-    # waveform to the separately pinned full large-v3 verifier.  Do not let a
-    # redundant long-form turbo decode veto a path that passes that stronger
-    # assembled-waveform gate.
+    # Local and assembled checks share one request-local Breeze25 transcript
+    # cache. The semantic-only projection remains a separate hard gate over
+    # the same exact transcript, never a second decoder invocation.
     assembled_verification = _verify_release_whole_audio(
         waveform,
         whole_target_text,
         anchor,
         independent_cache,
         transcriber=release_transcriber,
-        verifier_profile=RELEASE_LARGE_V3_VERIFICATION_PROFILE,
+        verifier_profile=BREEZE25_RELEASE_VERIFICATION_PROFILE,
     )
     status = "verified" if assembled_verification.passed else "rejected"
     print(
-        f"[BlueMagpie] sequence path large-v3 {status} "
+        f"[BlueMagpie] sequence path Breeze25 {status} "
         f"rank={sequence_result.sequence_path_rank} "
         f"chunk_candidates={sequence_result.chunk_candidate_indices} "
         f"{_verification_metric_log_fields(assembled_verification)}"
@@ -2031,7 +2083,7 @@ def _verify_sequence_trajectory_audio(
     )
     independent_status = "verified" if independent_verification.passed else "rejected"
     print(
-        f"[BlueMagpie] sequence path independent large-v3 {independent_status} "
+        f"[BlueMagpie] sequence path Breeze25 projection {independent_status} "
         f"rank={sequence_result.sequence_path_rank} "
         f"chunk_candidates={sequence_result.chunk_candidate_indices} "
         f"{_verification_metric_log_fields(independent_verification)}"
@@ -2385,15 +2437,10 @@ def _synthesize(
     anchor = _speaker_anchor_array(centroid)
     independent_cache = WholeWaveformVerificationCache()
     transcript_cache = WholeWaveformTranscriptCache()
-    cached_turbo_transcriber = _cached_request_transcriber(
-        transcript_cache,
-        TURBO_TRANSCRIPT_PROFILE,
-        transcribe_whisper,
-    )
-    cached_large_v3_transcriber = _cached_request_transcriber(
+    cached_breeze25_transcriber = _cached_request_transcriber(
         transcript_cache,
-        LARGE_V3_TRANSCRIPT_PROFILE,
-        transcribe_verification_whisper,
+        BREEZE25_TRANSCRIPT_PROFILE,
+        transcribe_breeze25,
     )
     generation_context_by_seed: dict[int, CandidateGenerationContext] = {}
     generation_endpoint_evidence_by_seed: dict[
@@ -2734,8 +2781,8 @@ def _synthesize(
                     independent_cache,
                     candidate_seed=seed,
                     chunk_specs=generation_chunk_specs(seed, candidate_chunks),
-                    release_transcriber=cached_turbo_transcriber,
-                    independent_transcriber=cached_large_v3_transcriber,
+                    release_transcriber=cached_breeze25_transcriber,
+                    independent_transcriber=cached_breeze25_transcriber,
                 ),
                 lambda trajectory, candidate_chunks, seed: (
                     _qualify_candidate_trajectory_audio(
@@ -2747,8 +2794,8 @@ def _synthesize(
                         independent_cache,
                         candidate_seed=seed,
                         chunk_specs=generation_chunk_specs(seed, candidate_chunks),
-                        release_transcriber=cached_turbo_transcriber,
-                        independent_transcriber=cached_large_v3_transcriber,
+                        release_transcriber=cached_breeze25_transcriber,
+                        independent_transcriber=cached_breeze25_transcriber,
                     )
                     if len(chunks) == 1
                     else _verify_refill_candidate_trajectory_audio(
@@ -2758,6 +2805,7 @@ def _synthesize(
                         speed,
                         generation_chunk_specs(seed, candidate_chunks),
                         candidate_seed=seed,
+                        transcriber=cached_breeze25_transcriber,
                     )
                 ),
                 sequence_final_verifier=lambda sequence_result, candidate_chunks: (
@@ -2769,8 +2817,8 @@ def _synthesize(
                         speed,
                         independent_cache,
                         chunk_specs,
-                        release_transcriber=cached_large_v3_transcriber,
-                        independent_transcriber=cached_large_v3_transcriber,
+                        release_transcriber=cached_breeze25_transcriber,
+                        independent_transcriber=cached_breeze25_transcriber,
                     )
                 ),
                 generation_evidence_factory=candidate_generation_evidence,
@@ -2895,16 +2943,8 @@ def _synthesize(
         text,
         anchor,
         independent_cache,
-        transcriber=(
-            cached_large_v3_transcriber
-            if len(chunks) > 1
-            else cached_turbo_transcriber
-        ),
-        verifier_profile=(
-            RELEASE_LARGE_V3_VERIFICATION_PROFILE
-            if len(chunks) > 1
-            else RELEASE_TURBO_VERIFICATION_PROFILE
-        ),
+        transcriber=cached_breeze25_transcriber,
+        verifier_profile=BREEZE25_RELEASE_VERIFICATION_PROFILE,
     )
     final_evidence = trajectory_gate_evidence(final_verification)
     independent_final_evidence = None
@@ -2916,7 +2956,7 @@ def _synthesize(
             text,
             anchor,
             independent_cache,
-            transcriber=cached_large_v3_transcriber,
+            transcriber=cached_breeze25_transcriber,
         )
         independent_final_evidence = trajectory_gate_evidence(
             independent_final_verification
@@ -2941,8 +2981,8 @@ def _synthesize(
         )
         print(
             "[BlueMagpie] final output rejected "
-            f"turbo={_verification_metric_log_fields(final_verification)} "
-            f"independent={independent_fields}"
+            f"breeze25={_verification_metric_log_fields(final_verification)} "
+            f"semantic_projection={independent_fields}"
         )
         raise gr.Error("最終合成結果未通過整段內容、語速與音色驗證，未回傳音訊。") from error
     except (RuntimeError, ValueError) as error:
@@ -2960,8 +3000,8 @@ def _synthesize(
     )
     print(
         "[BlueMagpie] final output verified "
-        f"turbo_score={final_verification.score:.6f} "
-        f"independent_score={independent_final_verification.score:.6f} "
+        f"breeze25_score={final_verification.score:.6f} "
+        f"semantic_projection_score={independent_final_verification.score:.6f} "
         f"independent_cache_entries={independent_cache.entry_count} "
         f"transcript_cache_entries={transcript_cache.entry_count}"
     )
@@ -3517,7 +3557,7 @@ def _synthesize_glyph_hybrid(
         1.0,
         QUALITY_FINAL_ASR_MAX_NEW_TOKENS,
         release_speaker_gate=True,
-        transcriber=_transcribe_glyph_hybrid_turbo,
+        transcriber=_transcribe_glyph_hybrid_breeze_primary,
     )
     independent_final_verification = None
     try:
@@ -3527,7 +3567,7 @@ def _synthesize_glyph_hybrid(
             plan.canonical_target,
             anchor,
             independent_cache,
-            transcriber=_transcribe_glyph_hybrid_independent,
+            transcriber=_transcribe_glyph_hybrid_breeze_confirmation,
         )
         _require_glyph_final_verification(independent_final_verification)
     except FinalOutputRejectedError as error:
@@ -3707,7 +3747,7 @@ HEADER = f"""
 台灣華語與中英混合文字轉語音。模型版本：`{CHECKPOINT}`。
 
 執行環境固定於已驗證的 model revision `{MODEL_REVISION[:8]}`、ECAPA revision
-`{ECAPA_REVISION[:8]}` 與 Whisper revision `{WHISPER_REVISION[:8]}`，避免服務重啟時
+`{ECAPA_REVISION[:8]}` 與 Breeze-ASR-25 revision `{BREEZE25_REVISION[:8]}`，避免服務重啟時
 無聲變更權重、speaker embedding 或語意驗證空間。
 
 目前預設採用穩定推論設定：候選交錯 `CFG 3.0 / 2.0`（網路內容與極短句最低 3.0）、
@@ -3722,7 +3762,8 @@ same-seed 完整 trajectory；失敗後只補低覆蓋 chunks，再以 speaker/R
 culprit-diverse exact paths；所有 chunk 首次具備 coverage 時先驗證 rank-1 exact path；若它已通過 hard gate
 但僅未達 preferred tier，下一個新 rank-1 path 會在 bounded refill 中提前驗證，同時保留 completed-lattice
 final slot。F0 只在 multi-chunk lattice 真正有替代路徑、需要 transition ranking 時才計算。單一 chunk 若 exact joined
-波形已通過雙 ASR、preferred SQUIM、release speaker、語速與 echo/smearing gate，會立即返回而不再填滿候選池。
+波形已通過 cached Breeze25 語意投影、preferred SQUIM、release speaker、語速與 echo/smearing gate，
+會立即返回而不再填滿候選池。
 NFE 固定為已驗證的 10；48 speech units 內的非網路互動 request 最多生成 10 個 TTS chunks，
 其他 request 維持 32 個 hard cap，且一律不超過 800 generated speech units。語速校正使用 deterministic WSOLA，總 rate 不低於 0.90；不少於 1 秒的
 候選與最終波形另須通過 echo/smearing gate。

glyph_assets.py

@@ -307,6 +307,17 @@ class SquimAttestation:
 
 @dataclass(frozen=True)
 class EndpointAttestation:
+    """Legacy v1 storage for the two Breeze ASR 25 decoder-profile CERs.
+
+    The serialized ``turbo_cer`` and ``large_v3_cer`` keys cannot be renamed
+    without invalidating every frozen v1 manifest hash.  Migrated bundles reuse
+    those slots for Breeze primary fixed-zh and confirmation auto-language CER,
+    but historical values retain their archival meaning and are never accepted
+    as current Breeze runtime evidence.  The hardened adapter requires the
+    official Breeze weight pin; new runtime evidence uses only honest profile
+    names.
+    """
+
     stop_reason: str
     turbo_cer: float
     large_v3_cer: float
@@ -317,6 +328,18 @@ class EndpointAttestation:
     maximum_tail_energy_ratio: float
     terminal_silence_samples: int
 
+    @property
+    def breeze_primary_cer(self) -> float:
+        """Return the primary-profile slot for a migrated Breeze bundle."""
+
+        return self.turbo_cer
+
+    @property
+    def breeze_confirmation_cer(self) -> float:
+        """Return the confirmation slot for a migrated Breeze bundle."""
+
+        return self.large_v3_cer
+
 
 @dataclass(frozen=True)
 class PcmMeasurements:
@@ -1116,10 +1139,13 @@ def _parse_endpoint(value: Any, *, context: str) -> EndpointAttestation:
     )
     if stop_reason not in ("stop_token", "verified_hard_cap"):
         raise GlyphAssetError(f"{context}.stop_reason is not an allowed completion")
-    turbo_cer = _require_finite(
+    # These two field names are frozen v1 wire compatibility only.  See
+    # ``EndpointAttestation``: their values now attest the two decoder
+    # profiles over the same pinned Breeze ASR 25 weights.
+    breeze_primary_cer = _require_finite(
         fields["turbo_cer"], context=f"{context}.turbo_cer", minimum=0.0
     )
-    large_v3_cer = _require_finite(
+    breeze_confirmation_cer = _require_finite(
         fields["large_v3_cer"], context=f"{context}.large_v3_cer", minimum=0.0
     )
     prefix_cer = _require_finite(
@@ -1154,8 +1180,8 @@ def _parse_endpoint(value: Any, *, context: str) -> EndpointAttestation:
         )
     return EndpointAttestation(
         stop_reason,
-        turbo_cer,
-        large_v3_cer,
+        breeze_primary_cer,
+        breeze_confirmation_cer,
         prefix_cer,
         suffix_cer,
         extra_tail_units,

glyph_hybrid_adapter.py

@@ -2,9 +2,10 @@
 
 The adapter is the only bridge from the hosted runtime's text-bearing objects
 to :mod:`glyph_hybrid_evidence`. It rebuilds the renderer plan, replays every
-model attempt, reruns both pinned ASRs plus ECAPA and SQUIM on exact public
-PCM, validates the immutable assembly, and only then returns content-free
-canonical JSON.
+model attempt, reruns two explicitly distinct decoder profiles over the same
+pinned Breeze ASR 25 weights plus ECAPA and SQUIM on exact public PCM,
+validates the immutable assembly, and only then returns content-free canonical
+JSON.
 """
 
 from __future__ import annotations
@@ -23,6 +24,7 @@ import glyph_ascii_v1 as glyph_ascii_module
 import glyph_assets as glyph_assets_module
 import glyph_hybrid_evidence as evidence
 import glyph_hybrid_plan as glyph_plan_module
+import quality_runtime as quality_runtime_module
 from glyph_assets import (
     AssetSegment,
     CarrierSegment,
@@ -35,25 +37,69 @@ from quality_runtime import (
     SQUIM_OBJECTIVE_SAMPLE_RATE,
     SQUIM_OBJECTIVE_WEIGHT_SHA256,
     SQUIM_OBJECTIVE_WINDOW_SECONDS,
-    VERIFICATION_WHISPER_MODEL_ID,
-    VERIFICATION_WHISPER_REVISION,
-    WHISPER_ATTENTION_IMPLEMENTATION,
-    WHISPER_MAX_MICROBATCH_SEGMENTS,
-    WHISPER_MODEL_ID,
-    WHISPER_RETURN_ATTENTION_MASK,
-    WHISPER_REVISION,
-    WHISPER_SAMPLE_RATE,
     release_speaker_evidence_from_audio,
     squim_objective_evidence_from_audio,
-    transcribe_verification_whisper,
-    transcribe_whisper,
 )
 
 
 ADAPTER_SCHEMA = "bluemagpie.glyph-hybrid.adapter.v1"
 GENERATION_POLICY_SCHEMA = "bluemagpie.glyph-generation-policy.v1"
-ASR_LANGUAGE = "zh"
 ASR_TASK = "transcribe"
+BREEZE25_MODEL_ID = getattr(
+    quality_runtime_module,
+    "BREEZE25_MODEL_ID",
+    "MediaTek-Research/Breeze-ASR-25",
+)
+BREEZE25_REVISION = getattr(
+    quality_runtime_module,
+    "BREEZE25_REVISION",
+    "cffe7ccb404d025296a00758d0a33468bec3a9d0",
+)
+BREEZE25_PRIMARY_PIN_NAME = "breeze25-primary-zh"
+BREEZE25_CONFIRMATION_PIN_NAME = "breeze25-confirmation-auto"
+BREEZE25_PRIMARY_DECODER_PROFILE = "breeze25-greedy-zh-v1"
+BREEZE25_CONFIRMATION_DECODER_PROFILE = "breeze25-greedy-auto-v1"
+BREEZE25_PRIMARY_LANGUAGE = "zh"
+BREEZE25_CONFIRMATION_LANGUAGE = None
+BREEZE25_WEIGHT_SHA256 = getattr(
+    quality_runtime_module,
+    "BREEZE25_WEIGHT_SHA256",
+    "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6",
+)
+BREEZE25_SAMPLE_RATE = getattr(
+    quality_runtime_module,
+    "BREEZE25_SAMPLE_RATE",
+    16_000,
+)
+BREEZE25_ATTENTION_IMPLEMENTATION = getattr(
+    quality_runtime_module,
+    "BREEZE25_ATTENTION_IMPLEMENTATION",
+    "eager",
+)
+BREEZE25_RETURN_ATTENTION_MASK = getattr(
+    quality_runtime_module,
+    "BREEZE25_RETURN_ATTENTION_MASK",
+    True,
+)
+BREEZE25_MAX_MICROBATCH_SEGMENTS = getattr(
+    quality_runtime_module,
+    "BREEZE25_MAX_MICROBATCH_SEGMENTS",
+    6,
+)
+
+
+def _unavailable_breeze25_transcriber(*args: Any, **kwargs: Any) -> str:
+    del args, kwargs
+    raise RuntimeError(
+        "the pinned Breeze ASR 25 runtime is unavailable"
+    )
+
+
+transcribe_breeze25 = getattr(
+    quality_runtime_module,
+    "transcribe_breeze25",
+    _unavailable_breeze25_transcriber,
+)
 
 
 class GlyphHybridAdapterError(RuntimeError):
@@ -84,10 +130,8 @@ class GlyphAdapterRuntime:
     renderer_builder: Callable[..., Any] = build_glyph_hybrid_plan
     assembly_verifier: Callable[..., None] = verify_hybrid_assembly
     carrier_conditioner: Callable[[CarrierSegment], bytes] = condition_carrier_v1
-    turbo_transcriber: Callable[..., str] = transcribe_whisper
-    verification_transcriber: Callable[..., str] = (
-        transcribe_verification_whisper
-    )
+    breeze_primary_transcriber: Callable[..., str] = transcribe_breeze25
+    breeze_confirmation_transcriber: Callable[..., str] = transcribe_breeze25
     speaker_measure: Callable[..., Any] = release_speaker_evidence_from_audio
     squim_measure: Callable[..., Any] = squim_objective_evidence_from_audio
 
@@ -173,9 +217,10 @@ def _artifact_pin(
     *,
     kind: str,
     config: Mapping[str, Any],
+    logical_name: str | None = None,
 ) -> evidence.ArtifactPin:
     return evidence.ArtifactPin(
-        name=str(pin.name),
+        name=str(logical_name if logical_name is not None else pin.name),
         kind=kind,
         uri=str(pin.uri),
         revision=str(pin.revision),
@@ -220,18 +265,16 @@ def _runtime_pins(
         revision=runtime.model_revision,
         label="BlueMagpie model",
     )
-    turbo_pin = _select_hf_pin(
-        tuple(bundle.evaluator_pins),
-        repo_id=WHISPER_MODEL_ID,
-        revision=WHISPER_REVISION,
-        label="Whisper turbo",
-    )
-    verification_pin = _select_hf_pin(
+    breeze_weights_pin = _select_hf_pin(
         tuple(bundle.evaluator_pins),
-        repo_id=VERIFICATION_WHISPER_MODEL_ID,
-        revision=VERIFICATION_WHISPER_REVISION,
-        label="Whisper large-v3",
+        repo_id=BREEZE25_MODEL_ID,
+        revision=BREEZE25_REVISION,
+        label="Breeze ASR 25",
     )
+    if getattr(breeze_weights_pin, "sha256", None) != BREEZE25_WEIGHT_SHA256:
+        raise GlyphHybridAdapterError(
+            "exact Breeze ASR 25 weight pin is unavailable"
+        )
     ecapa_pin = _select_hf_pin(
         tuple(bundle.evaluator_pins),
         repo_id=runtime.ecapa_repo_id,
@@ -312,37 +355,41 @@ def _runtime_pins(
             "inference_steps": runtime.inference_steps,
         },
     )
-    asr_config = {
+    shared_asr_config = {
         "schema": ADAPTER_SCHEMA,
-        "language": ASR_LANGUAGE,
         "task": ASR_TASK,
         "max_new_tokens": runtime.asr_max_new_tokens,
         "max_verification_segments": (
             runtime.asr_max_verification_segments
         ),
-        "sample_rate": WHISPER_SAMPLE_RATE,
-        "attention_implementation": WHISPER_ATTENTION_IMPLEMENTATION,
-        "return_attention_mask": WHISPER_RETURN_ATTENTION_MASK,
-        "max_microbatch_segments": WHISPER_MAX_MICROBATCH_SEGMENTS,
+        "sample_rate": BREEZE25_SAMPLE_RATE,
+        "attention_implementation": BREEZE25_ATTENTION_IMPLEMENTATION,
+        "return_attention_mask": BREEZE25_RETURN_ATTENTION_MASK,
+        "max_microbatch_segments": BREEZE25_MAX_MICROBATCH_SEGMENTS,
         "do_sample": False,
         "num_beams": 1,
+        "repo_id": BREEZE25_MODEL_ID,
+        "revision": BREEZE25_REVISION,
+        "shared_weights_sha256": str(breeze_weights_pin.sha256),
     }
-    turbo = _artifact_pin(
-        turbo_pin,
+    breeze_primary = _artifact_pin(
+        breeze_weights_pin,
         kind="asr",
+        logical_name=BREEZE25_PRIMARY_PIN_NAME,
         config={
-            **asr_config,
-            "repo_id": WHISPER_MODEL_ID,
-            "revision": WHISPER_REVISION,
+            **shared_asr_config,
+            "decoder_profile": BREEZE25_PRIMARY_DECODER_PROFILE,
+            "language": BREEZE25_PRIMARY_LANGUAGE,
         },
     )
-    verification = _artifact_pin(
-        verification_pin,
+    breeze_confirmation = _artifact_pin(
+        breeze_weights_pin,
         kind="asr",
+        logical_name=BREEZE25_CONFIRMATION_PIN_NAME,
         config={
-            **asr_config,
-            "repo_id": VERIFICATION_WHISPER_MODEL_ID,
-            "revision": VERIFICATION_WHISPER_REVISION,
+            **shared_asr_config,
+            "decoder_profile": BREEZE25_CONFIRMATION_DECODER_PROFILE,
+            "language": "auto",
         },
     )
     ecapa = _artifact_pin(
@@ -370,7 +417,14 @@ def _runtime_pins(
             "device": "cpu",
         },
     )
-    return source_pins, model, turbo, verification, ecapa, squim
+    return (
+        source_pins,
+        model,
+        breeze_primary,
+        breeze_confirmation,
+        ecapa,
+        squim,
+    )
 
 
 def _trusted_bundle(
@@ -760,8 +814,8 @@ class HardenedGlyphHybridAdapter:
         (
             source_pins,
             model_pin,
-            turbo_pin,
-            verification_pin,
+            breeze_primary_pin,
+            breeze_confirmation_pin,
             ecapa_pin,
             squim_pin,
         ) = _runtime_pins(runtime, bundle)
@@ -975,8 +1029,8 @@ class HardenedGlyphHybridAdapter:
             )
 
         expected_pins = {
-            turbo_pin.name: turbo_pin,
-            verification_pin.name: verification_pin,
+            breeze_primary_pin.name: breeze_primary_pin,
+            breeze_confirmation_pin.name: breeze_confirmation_pin,
             ecapa_pin.name: ecapa_pin,
             squim_pin.name: squim_pin,
         }
@@ -1000,23 +1054,25 @@ class HardenedGlyphHybridAdapter:
             key = pin.name, _sha256_bytes(pcm16_le), sample_rate
             if key not in asr_cache:
                 waveform = _pcm_waveform(pcm16_le)
-                transcriber = (
-                    runtime.turbo_transcriber
-                    if pin == turbo_pin
-                    else runtime.verification_transcriber
-                    if pin == verification_pin
-                    else None
-                )
-                if transcriber is None:
+                if pin == breeze_primary_pin:
+                    transcriber = runtime.breeze_primary_transcriber
+                    language = BREEZE25_PRIMARY_LANGUAGE
+                elif pin == breeze_confirmation_pin:
+                    transcriber = runtime.breeze_confirmation_transcriber
+                    language = BREEZE25_CONFIRMATION_LANGUAGE
+                else:
                     raise GlyphHybridAdapterError(
                         "ASR evaluator kind is not pinned"
                     )
                 transcript = transcriber(
                     waveform,
                     sample_rate,
-                    language=ASR_LANGUAGE,
+                    language=language,
                     task=ASR_TASK,
                     max_new_tokens=runtime.asr_max_new_tokens,
+                    max_verification_segments=(
+                        runtime.asr_max_verification_segments
+                    ),
                 )
                 if type(transcript) is not str:
                     raise GlyphHybridAdapterError(
@@ -1094,13 +1150,13 @@ class HardenedGlyphHybridAdapter:
             return squim_cache[key]
 
         output_pcm = bytes(assembly.pcm16_le)
-        turbo_transcript = asr_evaluator(
-            turbo_pin,
+        breeze_primary_transcript = asr_evaluator(
+            breeze_primary_pin,
             output_pcm,
             runtime.sample_rate,
         )
-        verification_transcript = asr_evaluator(
-            verification_pin,
+        breeze_confirmation_transcript = asr_evaluator(
+            breeze_confirmation_pin,
             output_pcm,
             runtime.sample_rate,
         )
@@ -1118,8 +1174,8 @@ class HardenedGlyphHybridAdapter:
         final_comparison = getattr(final_row, "comparison", None)
         if (
             final_comparison is None
-            or not turbo_transcript
-            or not verification_transcript
+            or not breeze_primary_transcript
+            or not breeze_confirmation_transcript
         ):
             raise GlyphHybridAdapterError(
                 "semantic evaluator output is unavailable"
@@ -1135,11 +1191,15 @@ class HardenedGlyphHybridAdapter:
             runtime.gate_policy,
         )
         for scope, asr_pin, transcript in (
-            ("final", turbo_pin, turbo_transcript),
+            (
+                "final",
+                breeze_primary_pin,
+                breeze_primary_transcript,
+            ),
             (
                 "independent",
-                verification_pin,
-                verification_transcript,
+                breeze_confirmation_pin,
+                breeze_confirmation_transcript,
             ),
         ):
             asr_call_id = f"asr-{scope}"
@@ -1243,8 +1303,8 @@ class HardenedGlyphHybridAdapter:
             source_pins=source_pins,
             model_pins=(model_pin,),
             evaluator_pins=(
-                turbo_pin,
-                verification_pin,
+                breeze_primary_pin,
+                breeze_confirmation_pin,
                 ecapa_pin,
                 squim_pin,
             ),

glyph_hybrid_evidence.py

@@ -40,6 +40,13 @@ MAX_ASR_CALLS = 96
 MAX_ECAPA_CALLS = 96
 MAX_SQUIM_CALLS = 96
 CONTENT_COMMITMENT_KEY_BYTES = 32
+BREEZE25_MODEL_ID = "MediaTek-Research/Breeze-ASR-25"
+BREEZE25_REVISION = "cffe7ccb404d025296a00758d0a33468bec3a9d0"
+BREEZE25_WEIGHT_SHA256 = (
+    "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6"
+)
+BREEZE25_PRIMARY_PIN_NAME = "breeze25-primary-zh"
+BREEZE25_CONFIRMATION_PIN_NAME = "breeze25-confirmation-auto"
 
 _SHA256_RE = re.compile(r"[0-9a-f]{64}\Z", flags=re.ASCII)
 _ID_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:/+-]{0,127}\Z", flags=re.ASCII)
@@ -147,6 +154,15 @@ def _require_text(value: Any, *, field: str, allow_empty: bool = False) -> str:
     return value
 
 
+def _normalized_hf_uri(value: str) -> str:
+    normalized = value.strip().rstrip("/")
+    for prefix in ("hf://", "https://huggingface.co/"):
+        if normalized.casefold().startswith(prefix):
+            normalized = normalized[len(prefix) :]
+            break
+    return normalized.casefold()
+
+
 def _require_int(
     value: Any,
     *,
@@ -2794,17 +2810,42 @@ def rebuild_hybrid_evidence(inputs: EvidenceRebuildInputs) -> HybridEvidence:
     if (
         final_asr.evaluator_pin_name
         == independent_asr.evaluator_pin_name
-        or (
-            final_asr_pin.sha256,
-            final_asr_pin.config_sha256,
+        or final_asr_pin.config_sha256
+        == independent_asr_pin.config_sha256
+    ):
+        raise GlyphHybridEvidenceError(
+            "ASR gates must use distinct pinned decoder profiles"
+        )
+    if (
+        final_asr_pin.uri,
+        final_asr_pin.revision,
+        final_asr_pin.sha256,
+    ) != (
+        independent_asr_pin.uri,
+        independent_asr_pin.revision,
+        independent_asr_pin.sha256,
+    ):
+        raise GlyphHybridEvidenceError(
+            "ASR decoder profiles must share the exact pinned model weights"
         )
-        == (
-            independent_asr_pin.sha256,
-            independent_asr_pin.config_sha256,
+    if (
+        _normalized_hf_uri(final_asr_pin.uri)
+        != BREEZE25_MODEL_ID.casefold()
+        or final_asr_pin.revision != BREEZE25_REVISION
+        or final_asr_pin.sha256 != BREEZE25_WEIGHT_SHA256
+    ):
+        raise GlyphHybridEvidenceError(
+            "ASR decoder profiles must use the official pinned Breeze ASR 25 "
+            "weights"
         )
+    if (
+        final_asr.evaluator_pin_name != BREEZE25_PRIMARY_PIN_NAME
+        or independent_asr.evaluator_pin_name
+        != BREEZE25_CONFIRMATION_PIN_NAME
     ):
         raise GlyphHybridEvidenceError(
-            "independent ASR must use a distinct pinned evaluator"
+            "ASR gates must use the honest Breeze primary and confirmation "
+            "logical pin names"
         )
     gate_call_ids = {
         call_id

latency_timing.py

@@ -18,8 +18,7 @@ from typing import Callable, Iterator
 LATENCY_STAGE_NAMES = (
     "request_total",
     "generation",
-    "turbo_asr",
-    "large_v3_asr",
+    "breeze25_asr",
     "ecapa",
     "squim",
     "echo",

production.py

@@ -57,7 +57,8 @@ _SPOKEN_DATE_RE = re.compile(
     r"(?<![A-Za-z0-9/])(\d{4})([/-])(\d{1,2})\2(\d{1,2})(?![A-Za-z0-9/])"
 )
 _SPOKEN_ZH_DATE_RE = re.compile(
-    r"(?<![A-Za-z0-9])(\d{4})年(\d{1,2})月(\d{1,2})(?:日|號)(?![A-Za-z0-9])"
+    r"(?<![A-Za-z0-9])(\d{4})\s*年\s*(\d{1,2})\s*月\s*"
+    r"(\d{1,2})\s*(?:日|號)(?![A-Za-z0-9])"
 )
 _SPOKEN_TIME_RE = re.compile(
     r"(?<![A-Za-z0-9:])([01]?\d|2[0-3]):([0-5]\d)(?![A-Za-z0-9:])"
@@ -71,6 +72,11 @@ _ASR_BARE_ZH_TIME_RE = re.compile(
     r"([0-5]?\d)(?![A-Za-z0-9]|\u5206|\u6beb?\u79d2|\u5fae\u79d2|"
     r"\u516c\u65a4|\u5343\u514b|\u516c\u514b|\u6beb\u514b|\u5ea6)"
 )
+_ASR_FORMATTED_CLOCK_RE = re.compile(
+    r"(?<![A-Za-z0-9])([01]?\d|2[0-3])\s*"
+    r"[.:\u9ede\u70b9\u6642\u65f6]\s*([0-5]?\d)(?:\s*\u5206)?"
+    r"(?![A-Za-z0-9])"
+)
 _ASR_ARABIC_DIGIT_RUN_RE = re.compile(
     r"(?<![A-Za-z0-9])\d+(?![A-Za-z0-9])"
 )
@@ -192,6 +198,10 @@ _SPOKEN_CURRENCY_SUFFIX_RE = re.compile(
 _MODEL_CODE_RE = re.compile(
     r"(?<![A-Za-z0-9])([A-Z]{2,8})[ -]*(\d{1,8})(?![A-Za-z0-9.])"
 )
+_ASR_MODEL_CODE_RE = re.compile(
+    r"(?<![A-Za-z0-9])([A-Za-z]{2,8})[ _-]*(\d{1,8})"
+    r"(?![A-Za-z0-9.])"
+)
 _UPPERCASE_ACRONYM_RE = re.compile(r"(?<![A-Za-z0-9])([A-Z]{2,8})(?![A-Za-z0-9])")
 _ZH_UNIT_READINGS = {
     "km/h": "公里每小時",
@@ -663,6 +673,92 @@ def _canonicalize_target_proven_arabic_digits(
     return "".join(output)
 
 
+def _canonicalize_target_proven_structured_asr_forms(
+    text: str,
+    normalized_target: str,
+) -> str:
+    """Canonicalize Breeze-style clock/model renderings under exact proof.
+
+    Breeze ASR 25 commonly writes a spoken clock as ``7.45 分`` and emits
+    model identifiers in lowercase without their separator (``ax418``).
+    Those are legitimate written renderings, but globally interpreting every
+    decimal or lowercase alphanumeric run would hide real content errors.
+    Each replacement is therefore derived from the candidate text, required
+    verbatim in the already-normalized target, matched at the same semantic
+    left/right anchors, and consumed at most once.
+    """
+
+    used_proofs: set[tuple[int, int, str]] = set()
+
+    def replace_matches(
+        value: str,
+        pattern: re.Pattern[str],
+        canonicalizer: Callable[[re.Match[str]], str | None],
+    ) -> str:
+        matches = tuple(pattern.finditer(value))
+        if not matches:
+            return value
+        output: list[str] = []
+        cursor = 0
+        for match in matches:
+            output.append(value[cursor : match.start()])
+            canonical = canonicalizer(match)
+            replacement: str | None = None
+            if canonical:
+                text_context = (
+                    _semantic_neighbor(value, match.start() - 1, -1),
+                    _semantic_neighbor(value, match.end(), 1),
+                )
+                proof_start = 0
+                while True:
+                    proof_start = normalized_target.find(canonical, proof_start)
+                    if proof_start < 0:
+                        break
+                    proof_end = proof_start + len(canonical)
+                    proof_key = (proof_start, proof_end, canonical)
+                    target_context = (
+                        _semantic_neighbor(
+                            normalized_target,
+                            proof_start - 1,
+                            -1,
+                        ),
+                        _semantic_neighbor(normalized_target, proof_end, 1),
+                    )
+                    if proof_key not in used_proofs and target_context == text_context:
+                        replacement = canonical
+                        used_proofs.add(proof_key)
+                        break
+                    proof_start += 1
+            output.append(replacement if replacement is not None else match.group(0))
+            cursor = match.end()
+        output.append(value[cursor:])
+        return "".join(output)
+
+    def canonical_clock(match: re.Match[str]) -> str | None:
+        try:
+            return _zh_clock_time(match.group(1), match.group(2))
+        except (TypeError, ValueError):
+            return None
+
+    def canonical_model_code(match: re.Match[str]) -> str | None:
+        letters, digits = match.groups()
+        try:
+            return f"{' '.join(letters.upper())} {_zh_digit_sequence(digits)}"
+        except ValueError:
+            return None
+
+    canonicalized = replace_matches(
+        text,
+        _ASR_FORMATTED_CLOCK_RE,
+        canonical_clock,
+    )
+    return replace_matches(
+        canonicalized,
+        _ASR_MODEL_CODE_RE,
+        canonical_model_code,
+    )
+
+
 def _canonical_jpy_amount_reading(amount: str) -> str | None:
     """Return one validated Mandarin amount reading for a JPY proof span."""
 
@@ -2632,6 +2728,10 @@ def normalize_asr_spoken_forms(
             value = value.replace(placeholder, spoken)
         return value
 
+    raw_text = _canonicalize_target_proven_structured_asr_forms(
+        raw_text,
+        normalized_target,
+    )
     target_proven_text = _canonicalize_target_proven_frequency_scales(
         raw_text,
         raw_target,

quality_runtime.py

@@ -1,6 +1,6 @@
 """Fail-closed quality runtime helpers for the BlueMagpie-TTS Space.
 
-The module deliberately has no import-time model downloads.  Both Whisper and
+The module deliberately has no import-time model downloads.  Breeze ASR 25 and
 ECAPA are supplied through small injectable boundaries so the online Space can
 load the real models lazily while unit tests remain deterministic and offline.
 """
@@ -31,20 +31,40 @@ from production import (
 )
 
 
-WHISPER_MODEL_ID = "openai/whisper-large-v3-turbo"
-WHISPER_REVISION = "41f01f3fe87f28c78e2fbf8b568835947dd65ed9"
-VERIFICATION_WHISPER_MODEL_ID = "openai/whisper-large-v3"
-VERIFICATION_WHISPER_REVISION = "06f233fe06e710322aca913c1bc4249a0d71fce1"
-WHISPER_ATTENTION_IMPLEMENTATION = "eager"
-WHISPER_RETURN_ATTENTION_MASK = True
-WHISPER_SAMPLE_RATE = 16_000
-WHISPER_MAX_SEGMENT_SECONDS = 28.0
-WHISPER_HARD_MAX_SEGMENT_SECONDS = 30.0
-WHISPER_MIN_SEGMENT_SECONDS = 1.25
-WHISPER_MIN_PAUSE_SECONDS = 0.25
-WHISPER_MAX_VERIFICATION_SEGMENTS = 12
+BREEZE25_MODEL_ID = "MediaTek-Research/Breeze-ASR-25"
+BREEZE25_REVISION = "cffe7ccb404d025296a00758d0a33468bec3a9d0"
+BREEZE25_WEIGHT_SHA256 = (
+    "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6"
+)
+BREEZE25_ATTENTION_IMPLEMENTATION = "eager"
+BREEZE25_RETURN_ATTENTION_MASK = True
+BREEZE25_LANGUAGE = "zh"
+BREEZE25_TASK = "transcribe"
+BREEZE25_SAMPLE_RATE = 16_000
+BREEZE25_MAX_SEGMENT_SECONDS = 28.0
+BREEZE25_HARD_MAX_SEGMENT_SECONDS = 30.0
+BREEZE25_MIN_SEGMENT_SECONDS = 1.25
+BREEZE25_MIN_PAUSE_SECONDS = 0.25
+BREEZE25_MAX_VERIFICATION_SEGMENTS = 12
 GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS = 160
-WHISPER_MAX_MICROBATCH_SEGMENTS = 6
+BREEZE25_MAX_MICROBATCH_SEGMENTS = 6
+
+# Compatibility names remain available while app/evaluator callers migrate.
+# They deliberately resolve to the one pinned Breeze ASR 25 contract and never
+# refer to the retired OpenAI verifier models.
+WHISPER_MODEL_ID = BREEZE25_MODEL_ID
+WHISPER_REVISION = BREEZE25_REVISION
+VERIFICATION_WHISPER_MODEL_ID = BREEZE25_MODEL_ID
+VERIFICATION_WHISPER_REVISION = BREEZE25_REVISION
+WHISPER_ATTENTION_IMPLEMENTATION = BREEZE25_ATTENTION_IMPLEMENTATION
+WHISPER_RETURN_ATTENTION_MASK = BREEZE25_RETURN_ATTENTION_MASK
+WHISPER_SAMPLE_RATE = BREEZE25_SAMPLE_RATE
+WHISPER_MAX_SEGMENT_SECONDS = BREEZE25_MAX_SEGMENT_SECONDS
+WHISPER_HARD_MAX_SEGMENT_SECONDS = BREEZE25_HARD_MAX_SEGMENT_SECONDS
+WHISPER_MIN_SEGMENT_SECONDS = BREEZE25_MIN_SEGMENT_SECONDS
+WHISPER_MIN_PAUSE_SECONDS = BREEZE25_MIN_PAUSE_SECONDS
+WHISPER_MAX_VERIFICATION_SEGMENTS = BREEZE25_MAX_VERIFICATION_SEGMENTS
+WHISPER_MAX_MICROBATCH_SEGMENTS = BREEZE25_MAX_MICROBATCH_SEGMENTS
 SQUIM_OBJECTIVE_ASSET_PATH = "models/squim_objective_dns2020.pth"
 SQUIM_OBJECTIVE_WEIGHT_SHA256 = (
     "2c54586fea83fb5eb5394d710038ee89f55cab7011a5bf730bebed4c8777e828"
@@ -745,8 +765,8 @@ def active_voiced_duration_seconds(
 
 
 @dataclass(frozen=True)
-class WhisperRuntime:
-    """Loaded processor/model pair for deterministic Whisper transcription."""
+class Breeze25Runtime:
+    """Loaded processor/model pair for deterministic Breeze ASR 25."""
 
     processor: Any
     model: Any
@@ -754,14 +774,14 @@ class WhisperRuntime:
     dtype: torch.dtype
 
 
-def _load_whisper_runtime(
+def _load_breeze25_runtime(
     model_id: str,
     revision: str,
     *,
     device: str | torch.device | None = None,
     processor_factory: Any | None = None,
     model_factory: Any | None = None,
-) -> WhisperRuntime:
+) -> Breeze25Runtime:
     """Load one exact ASR revision through the shared deterministic contract.
 
     Factory injection exists for offline tests.  The default imports
@@ -785,14 +805,14 @@ def _load_whisper_runtime(
     model = model_factory.from_pretrained(
         model_id,
         revision=revision,
-        attn_implementation=WHISPER_ATTENTION_IMPLEMENTATION,
+        attn_implementation=BREEZE25_ATTENTION_IMPLEMENTATION,
         torch_dtype=dtype,
         low_cpu_mem_usage=True,
         use_safetensors=True,
     )
     model = model.to(selected_device)
     model.eval()
-    return WhisperRuntime(
+    return Breeze25Runtime(
         processor=processor,
         model=model,
         device=selected_device,
@@ -800,49 +820,35 @@ def _load_whisper_runtime(
     )
 
 
-def load_pinned_whisper_runtime(
-    *,
-    device: str | torch.device | None = None,
-    processor_factory: Any | None = None,
-    model_factory: Any | None = None,
-) -> WhisperRuntime:
-    """Load the pinned turbo ASR used for local candidate screening."""
-
-    return _load_whisper_runtime(
-        WHISPER_MODEL_ID,
-        WHISPER_REVISION,
-        device=device,
-        processor_factory=processor_factory,
-        model_factory=model_factory,
-    )
-
-
-def load_pinned_verification_whisper_runtime(
+def load_pinned_breeze25_runtime(
     *,
     device: str | torch.device | None = None,
     processor_factory: Any | None = None,
     model_factory: Any | None = None,
-) -> WhisperRuntime:
-    """Load the independent full large-v3 ASR used only for whole outputs."""
+) -> Breeze25Runtime:
+    """Load the sole pinned content verifier used by every semantic gate."""
 
-    return _load_whisper_runtime(
-        VERIFICATION_WHISPER_MODEL_ID,
-        VERIFICATION_WHISPER_REVISION,
+    return _load_breeze25_runtime(
+        BREEZE25_MODEL_ID,
+        BREEZE25_REVISION,
         device=device,
         processor_factory=processor_factory,
         model_factory=model_factory,
     )
 
 
-class LazyWhisperASR:
+class LazyBreeze25ASR:
     """Thread-safe one-shot lazy loader with an injectable runtime factory."""
 
-    def __init__(self, runtime_loader: Callable[[], WhisperRuntime] | None = None) -> None:
-        self._runtime_loader = runtime_loader or load_pinned_whisper_runtime
-        self._runtime: WhisperRuntime | None = None
+    def __init__(
+        self,
+        runtime_loader: Callable[[], Breeze25Runtime] | None = None,
+    ) -> None:
+        self._runtime_loader = runtime_loader or load_pinned_breeze25_runtime
+        self._runtime: Breeze25Runtime | None = None
         self._lock = threading.Lock()
 
-    def get_runtime(self) -> WhisperRuntime:
+    def get_runtime(self) -> Breeze25Runtime:
         runtime = self._runtime
         if runtime is not None:
             return runtime
@@ -852,13 +858,10 @@ class LazyWhisperASR:
             return self._runtime
 
 
-_DEFAULT_WHISPER = LazyWhisperASR()
-_DEFAULT_VERIFICATION_WHISPER = LazyWhisperASR(
-    load_pinned_verification_whisper_runtime
-)
+_DEFAULT_BREEZE25 = LazyBreeze25ASR()
 
 
-def _qualified_whisper_pause_ranges(
+def _qualified_breeze25_pause_ranges(
     waveform: np.ndarray,
     *,
     sample_rate: int,
@@ -929,7 +932,7 @@ def _qualified_whisper_pause_ranges(
     return tuple(qualified)
 
 
-def _split_short_whisper_audio_at_sustained_pause(
+def _split_short_breeze25_audio_at_sustained_pause(
     waveform: np.ndarray,
     *,
     sample_rate: int,
@@ -944,7 +947,7 @@ def _split_short_whisper_audio_at_sustained_pause(
     minimum_segment = max(1, int(round(minimum_segment_seconds * rate)))
     if waveform.size < 2 * minimum_segment:
         return (waveform,)
-    pause_ranges = _qualified_whisper_pause_ranges(
+    pause_ranges = _qualified_breeze25_pause_ranges(
         waveform,
         sample_rate=rate,
         minimum_pause_seconds=minimum_pause_seconds,
@@ -965,19 +968,19 @@ def _split_short_whisper_audio_at_sustained_pause(
     )
 
 
-def _split_whisper_audio(
+def _split_breeze25_audio(
     waveform: np.ndarray,
     *,
-    sample_rate: int = WHISPER_SAMPLE_RATE,
-    max_segment_seconds: float = WHISPER_MAX_SEGMENT_SECONDS,
+    sample_rate: int = BREEZE25_SAMPLE_RATE,
+    max_segment_seconds: float = BREEZE25_MAX_SEGMENT_SECONDS,
     boundary_search_seconds: float = 1.5,
-    max_verification_segments: int = WHISPER_MAX_VERIFICATION_SEGMENTS,
+    max_verification_segments: int = BREEZE25_MAX_VERIFICATION_SEGMENTS,
 ) -> tuple[np.ndarray, ...]:
     """Create bounded verification segments without cutting voiced audio.
 
     Every qualified pause is retained when doing so keeps all segments below
     the target cap. This prevents a long multi-chunk decode from swallowing
-    several already-separated clauses in one Whisper context. If the natural
+    several already-separated clauses in one Breeze25 context. If the natural
     pause atoms cannot bound the contexts, the coarse latest-pause fallback is
     used; a long voiced span without such a pause still fails closed.
     """
@@ -991,31 +994,31 @@ def _split_whisper_audio(
         <= GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS
     ):
         raise ValueError(
-            "Whisper segment budget must be an exact integer in [1, 160]"
+            "Breeze25 segment budget must be an exact integer in [1, 160]"
         )
     if maximum_seconds is None or search_seconds is None or sample_rate <= 0:
-        raise ValueError("invalid Whisper segmentation settings")
+        raise ValueError("invalid Breeze25 segmentation settings")
     maximum_samples = max(1, int(round(maximum_seconds * sample_rate)))
-    hard_cap_samples = int(round(WHISPER_HARD_MAX_SEGMENT_SECONDS * sample_rate))
+    hard_cap_samples = int(round(BREEZE25_HARD_MAX_SEGMENT_SECONDS * sample_rate))
     if maximum_samples > hard_cap_samples:
-        raise ValueError("Whisper target segment cap exceeds the 30-second hard limit")
+        raise ValueError("Breeze25 target segment cap exceeds the 30-second hard limit")
     minimum_segment_samples = max(
         1,
-        int(round(WHISPER_MIN_SEGMENT_SECONDS * sample_rate)),
+        int(round(BREEZE25_MIN_SEGMENT_SECONDS * sample_rate)),
     )
     if waveform.size > hard_cap_samples * max_verification_segments:
         raise ValueError("verification audio exceeds the bounded ASR segment budget")
 
-    pause_ranges = _qualified_whisper_pause_ranges(
+    pause_ranges = _qualified_breeze25_pause_ranges(
         waveform,
         sample_rate=sample_rate,
-        minimum_pause_seconds=WHISPER_MIN_PAUSE_SECONDS,
+        minimum_pause_seconds=BREEZE25_MIN_PAUSE_SECONDS,
     )
-    pause_segments = _split_short_whisper_audio_at_sustained_pause(
+    pause_segments = _split_short_breeze25_audio_at_sustained_pause(
         waveform,
         sample_rate=sample_rate,
-        minimum_pause_seconds=WHISPER_MIN_PAUSE_SECONDS,
-        minimum_segment_seconds=WHISPER_MIN_SEGMENT_SECONDS,
+        minimum_pause_seconds=BREEZE25_MIN_PAUSE_SECONDS,
+        minimum_segment_seconds=BREEZE25_MIN_SEGMENT_SECONDS,
     )
     if len(pause_segments) > max_verification_segments:
         raise ValueError("verification audio exceeds the pause segment cap")
@@ -1075,27 +1078,30 @@ def _split_whisper_audio(
         )
         or sum(segment.size for segment in segments) != waveform.size
     ):
-        raise ValueError("failed to split audio within Whisper's segment limit")
+        raise ValueError("failed to split audio within Breeze25's segment limit")
     return segments
 
 
 @torch.inference_mode()
-def _transcribe_whisper(
+def _transcribe_breeze25(
     audio: np.ndarray | Sequence[float],
     sample_rate: int,
     *,
-    lazy_asr: LazyWhisperASR | None = None,
-    runtime: WhisperRuntime | None = None,
-    language: str = "zh",
-    task: str = "transcribe",
+    lazy_asr: LazyBreeze25ASR | None = None,
+    runtime: Breeze25Runtime | None = None,
+    language: str | None = BREEZE25_LANGUAGE,
+    task: str = BREEZE25_TASK,
     max_new_tokens: int = 128,
-    max_verification_segments: int = WHISPER_MAX_VERIFICATION_SEGMENTS,
+    max_verification_segments: int = BREEZE25_MAX_VERIFICATION_SEGMENTS,
 ) -> str:
-    """Transcribe ndarray audio using the shared deterministic decoder.
+    """Transcribe ndarray audio using the sole pinned Breeze25 decoder.
 
     ``runtime`` and ``lazy_asr`` are mutually exclusive injection points.  An
     empty decoded string is returned as-is; the semantic verifier will reject
-    it rather than accepting an arbitrary TTS fallback.
+    it rather than accepting an arbitrary TTS fallback. Production fixes the
+    shared mixed-language embedding with ``language="zh"``. Passing ``None``
+    is supported only as an explicit evaluation injection and omits the
+    language argument so the model performs its own language detection.
     """
 
     if runtime is not None and lazy_asr is not None:
@@ -1103,22 +1109,26 @@ def _transcribe_whisper(
     token_limit = int(max_new_tokens)
     if token_limit <= 0:
         raise ValueError("max_new_tokens must be positive")
-    waveform = _resample_audio(_mono_audio(audio), int(sample_rate), WHISPER_SAMPLE_RATE)
-    segments = _split_whisper_audio(
+    waveform = _resample_audio(
+        _mono_audio(audio),
+        int(sample_rate),
+        BREEZE25_SAMPLE_RATE,
+    )
+    segments = _split_breeze25_audio(
         waveform,
         max_verification_segments=max_verification_segments,
     )
-    selected_runtime = runtime or (lazy_asr or _DEFAULT_WHISPER).get_runtime()
+    selected_runtime = runtime or (lazy_asr or _DEFAULT_BREEZE25).get_runtime()
     decoded_segments: list[str] = []
-    for start in range(0, len(segments), WHISPER_MAX_MICROBATCH_SEGMENTS):
-        microbatch = segments[start : start + WHISPER_MAX_MICROBATCH_SEGMENTS]
+    for start in range(0, len(segments), BREEZE25_MAX_MICROBATCH_SEGMENTS):
+        microbatch = segments[start : start + BREEZE25_MAX_MICROBATCH_SEGMENTS]
         processor_input: np.ndarray | list[np.ndarray]
         processor_input = microbatch[0] if len(microbatch) == 1 else list(microbatch)
         processor_output = selected_runtime.processor(
             processor_input,
-            sampling_rate=WHISPER_SAMPLE_RATE,
+            sampling_rate=BREEZE25_SAMPLE_RATE,
             return_tensors="pt",
-            return_attention_mask=WHISPER_RETURN_ATTENTION_MASK,
+            return_attention_mask=BREEZE25_RETURN_ATTENTION_MASK,
         )
         features = processor_output.input_features.to(
             device=selected_runtime.device,
@@ -1127,15 +1137,16 @@ def _transcribe_whisper(
         attention_mask = processor_output.attention_mask.to(
             device=selected_runtime.device
         )
-        token_ids = selected_runtime.model.generate(
-            features,
-            attention_mask=attention_mask,
-            language=language,
-            task=task,
-            do_sample=False,
-            num_beams=1,
-            max_new_tokens=token_limit,
-        )
+        generation_kwargs = {
+            "attention_mask": attention_mask,
+            "task": task,
+            "do_sample": False,
+            "num_beams": 1,
+            "max_new_tokens": token_limit,
+        }
+        if language is not None:
+            generation_kwargs["language"] = language
+        token_ids = selected_runtime.model.generate(features, **generation_kwargs)
         decoded = selected_runtime.processor.batch_decode(
             token_ids,
             skip_special_tokens=True,
@@ -1146,21 +1157,21 @@ def _transcribe_whisper(
     return " ".join(text for text in decoded_segments if text)
 
 
-@timed_latency_stage("turbo_asr")
-def transcribe_whisper(
+@timed_latency_stage("breeze25_asr")
+def transcribe_breeze25(
     audio: np.ndarray | Sequence[float],
     sample_rate: int,
     *,
-    lazy_asr: LazyWhisperASR | None = None,
-    runtime: WhisperRuntime | None = None,
-    language: str = "zh",
-    task: str = "transcribe",
+    lazy_asr: LazyBreeze25ASR | None = None,
+    runtime: Breeze25Runtime | None = None,
+    language: str | None = BREEZE25_LANGUAGE,
+    task: str = BREEZE25_TASK,
     max_new_tokens: int = 128,
-    max_verification_segments: int = WHISPER_MAX_VERIFICATION_SEGMENTS,
+    max_verification_segments: int = BREEZE25_MAX_VERIFICATION_SEGMENTS,
 ) -> str:
-    """Transcribe with the pinned Turbo candidate-screening ASR."""
+    """Transcribe with the sole pinned Breeze ASR 25 content verifier."""
 
-    return _transcribe_whisper(
+    return _transcribe_breeze25(
         audio,
         sample_rate,
         lazy_asr=lazy_asr,
@@ -1172,33 +1183,22 @@ def transcribe_whisper(
     )
 
 
-@timed_latency_stage("large_v3_asr")
-def transcribe_verification_whisper(
-    audio: np.ndarray | Sequence[float],
-    sample_rate: int,
-    *,
-    lazy_asr: LazyWhisperASR | None = None,
-    runtime: WhisperRuntime | None = None,
-    language: str = "zh",
-    task: str = "transcribe",
-    max_new_tokens: int = 128,
-    max_verification_segments: int = WHISPER_MAX_VERIFICATION_SEGMENTS,
-) -> str:
-    """Transcribe with the separately pinned full large-v3 final verifier."""
-
-    selected_lazy = lazy_asr
-    if runtime is None and selected_lazy is None:
-        selected_lazy = _DEFAULT_VERIFICATION_WHISPER
-    return _transcribe_whisper(
-        audio,
-        sample_rate,
-        lazy_asr=selected_lazy,
-        runtime=runtime,
-        language=language,
-        task=task,
-        max_new_tokens=max_new_tokens,
-        max_verification_segments=max_verification_segments,
-    )
+# Compatibility aliases are direct references, not decorated wrappers.  All
+# callers therefore share one lazy model and each decode is timed exactly once.
+WhisperRuntime = Breeze25Runtime
+LazyWhisperASR = LazyBreeze25ASR
+load_pinned_whisper_runtime = load_pinned_breeze25_runtime
+load_pinned_verification_whisper_runtime = load_pinned_breeze25_runtime
+_DEFAULT_WHISPER = _DEFAULT_BREEZE25
+_DEFAULT_VERIFICATION_WHISPER = _DEFAULT_BREEZE25
+_qualified_whisper_pause_ranges = _qualified_breeze25_pause_ranges
+_split_short_whisper_audio_at_sustained_pause = (
+    _split_short_breeze25_audio_at_sustained_pause
+)
+_split_whisper_audio = _split_breeze25_audio
+_transcribe_whisper = _transcribe_breeze25
+transcribe_whisper = transcribe_breeze25
+transcribe_verification_whisper = transcribe_breeze25
 
 
 @dataclass(frozen=True)
@@ -1229,7 +1229,7 @@ def prepare_candidate_audio(
         if selected_sample_rate <= 0:
             raise ValueError("sample_rate must be positive")
         waveform = _mono_audio(audio)
-        transcript = (transcriber or transcribe_whisper)(
+        transcript = (transcriber or transcribe_breeze25)(
             waveform,
             selected_sample_rate,
         )
@@ -2462,15 +2462,16 @@ def intersect_local_semantic_verification(
 ) -> TrajectoryGateResult:
     """Hard-intersect selected local rows without replacing acoustic evidence.
 
-    ``primary_verification`` owns the turbo ASR, speaker, SQUIM, pace and
+    ``primary_verification`` owns the Breeze25, speaker, SQUIM, pace and
     boundary-proxy evidence consumed by the coverage selector.
-    ``independent_verification`` contains semantic-only large-v3 results for
-    the selected network-conditioned rows in the order given by
-    ``primary_indices``.  A large-v3 rejection is projected onto the
+    ``independent_verification`` contains a semantic-only projection for the
+    selected network-conditioned rows in the order given by
+    ``primary_indices``. A secondary rejection is projected onto the
     corresponding primary row with allow-listed semantic reason codes, making
     it impossible for either the strict pool or the boundary-only proxy to
-    retain that local candidate.  Passing intersections return the original
-    primary object unchanged.
+    retain that local candidate. Production reuses the exact Breeze25
+    transcript cache, so this projection does not decode twice. Passing
+    intersections return the original primary object unchanged.
     """
 
     if not isinstance(primary_verification, TrajectoryGateResult):
@@ -4598,7 +4599,7 @@ def _bind_generation_endpoint_evidence(
             artifacts,
             strict=True,
         )
-        if result.comparison.passed is True
+        if result.passed is True
     ):
         raise RuntimeError("candidate endpoint evidence is invalid")
     return replace(verification, chunk_artifacts=artifacts)
@@ -5903,7 +5904,7 @@ def run_coverage_adaptive_cascade(
         )
 
     # If every initial local chunk was strict, the initial exact assembly was
-    # already rejected by turbo or large-v3.  Do not spend another final check
+    # already rejected by Breeze25. Do not spend another final check
     # on that identical waveform.  Boundary-recovered initial paths are not
     # excluded because the exact whole checks have not run for them yet.
     excluded_path_list: list[tuple[int, ...]] = []

tests/test_coverage_adaptive.py

@@ -637,7 +637,7 @@ def test_single_exact_fast_tier_never_uses_local_proxy():
     assert result.seed == 11
 
 
-def test_single_exact_fast_tier_requires_independent_whole_asr_evidence():
+def test_single_exact_fast_tier_requires_whole_semantic_projection_evidence():
     chunk = ("完整內容",)
     generated = []
 
@@ -766,6 +766,73 @@ def test_preferred_refill_selects_prior_natural_endpoint_over_forced_candidate()
     ]
 
 
+def test_endpoint_binding_keeps_preflight_rejection_and_continues_to_refill():
+    chunk = ("完整內容",)
+    generated = []
+
+    def verifier(trajectory, candidate_chunks, seed):
+        if seed == 10:
+            return verify_trajectory(
+                [
+                    CandidateObservation(
+                        target_text=candidate_chunks[0],
+                        transcript_text=candidate_chunks[0],
+                        audio_duration_seconds=0.5,
+                        pace_cps=8.0,
+                    )
+                ],
+                chunk_artifacts=(ChunkCandidateArtifact(),),
+                max_pace_cps=4.3,
+            )
+        return _local_verification(candidate_chunks)
+
+    def generation_evidence(candidate_index, seed, chunk_indices, candidate_chunks):
+        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",),
+            chunk_endpoint_energy_ratios=(0.10,),
+            chunk_generated_steps=(4,),
+            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(
+            "passing 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.70,
+        preferred_max_boundary_speaker_drop=0.10,
+        require_endpoint_evidence=True,
+    )
+
+    assert generated == [10, 11]
+    assert result.seed == 11
+    assert result.diagnostics.attempts[0].trajectory_passed is False
+    assert (
+        "chunk_0:pace_too_fast"
+        in result.diagnostics.attempts[0].trajectory_rejection_reasons
+    )
+    assert (
+        result.diagnostics.attempts[0].chunk_stop_reasons
+        == ("stop_threshold",)
+    )
+
+
 def test_fast_exact_refill_cannot_select_relaxed_endpoint_waiver_candidate():
     chunk = ("完整內容",)
     generated = []
@@ -2464,7 +2531,7 @@ def test_final_verifier_exception_invalid_evidence_and_all_reject_fail_closed():
         run_coverage_adaptive_cascade(
             **common,
             sequence_final_verifier=lambda *args: (_ for _ in ()).throw(
-                RuntimeError("large-v3 OOM")
+                RuntimeError("Breeze25 verifier OOM")
             ),
         )
     with pytest.raises(RuntimeError, match="invalid result"):

tests/test_glyph_app_integration.py

@@ -374,9 +374,9 @@ def test_pure_asset_integration_makes_zero_model_calls_and_still_emits_schema7()
         "WholeWaveformVerificationCache": object,
         "_verify_trajectory_audio": lambda *args, **kwargs: final,
         "QUALITY_FINAL_ASR_MAX_NEW_TOKENS": 440,
-        "transcribe_whisper": object(),
-        "_transcribe_glyph_hybrid_turbo": object(),
-        "_transcribe_glyph_hybrid_independent": object(),
+        "transcribe_breeze25": object(),
+        "_transcribe_glyph_hybrid_breeze_primary": object(),
+        "_transcribe_glyph_hybrid_breeze_confirmation": object(),
         "_require_glyph_final_verification": lambda value: None,
         "_verify_independent_whole_audio": lambda *args, **kwargs: final,
         "FinalOutputRejectedError": RuntimeError,
@@ -801,22 +801,26 @@ def test_hybrid_assembly_has_no_post_asset_global_audio_transform():
     assert "pcm16_audio_output(assembly.sample_rate, waveform)" in source
 
 
-def test_hybrid_only_whisper_wrappers_pin_the_160_segment_override():
-    turbo = _function_source("_transcribe_glyph_hybrid_turbo")
-    independent = _function_source("_transcribe_glyph_hybrid_independent")
+def test_hybrid_only_breeze25_wrappers_pin_the_160_segment_override():
+    primary = _function_source("_transcribe_glyph_hybrid_breeze_primary")
+    confirmation = _function_source(
+        "_transcribe_glyph_hybrid_breeze_confirmation"
+    )
     hybrid = _function_source("_synthesize_glyph_hybrid")
 
     assert (
-        "max_verification_segments="
+        "max_verification_segments: int = "
         "GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS"
-    ) in turbo
+    ) in primary
     assert (
-        "max_verification_segments="
+        "max_verification_segments: int = "
         "GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS"
-    ) in independent
-    for source in (turbo, independent):
+    ) in confirmation
+    for source in (primary, confirmation):
+        assert "transcribe_breeze25(" in source
         assert "language=language" in source
         assert "task=task" in source
         assert "max_new_tokens=max_new_tokens" in source
-    assert "transcriber=_transcribe_glyph_hybrid_turbo" in hybrid
-    assert "transcriber=_transcribe_glyph_hybrid_independent" in hybrid
+        assert "max_verification_segments=max_verification_segments" in source
+    assert "transcriber=_transcribe_glyph_hybrid_breeze_primary" in hybrid
+    assert "transcriber=_transcribe_glyph_hybrid_breeze_confirmation" in hybrid

tests/test_glyph_assets.py

@@ -76,6 +76,17 @@ def _pin(name: str, index: int) -> dict[str, object]:
     }
 
 
+def _breeze25_pin() -> dict[str, object]:
+    return {
+        "name": "breeze-asr-25",
+        "uri": "hf://MediaTek-Research/Breeze-ASR-25",
+        "revision": "cffe7ccb404d025296a00758d0a33468bec3a9d0",
+        "sha256": (
+            "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6"
+        ),
+    }
+
+
 def _entry_for_file(
     spec: ga.GlyphSpec,
     *,
@@ -188,8 +199,7 @@ def bundle_fixture(tmp_path: Path) -> BundleFixture:
         "source_pins": [_pin("asset-builder", 1)],
         "model_pins": [_pin("bluemagpie-checkpoint", 2)],
         "evaluator_pins": [
-            _pin("whisper-turbo", 3),
-            _pin("whisper-large-v3", 4),
+            _breeze25_pin(),
             _pin("ecapa", 5),
             _pin("squim", 6),
         ],
@@ -221,6 +231,8 @@ def test_loads_exact_immutable_32_entry_manifest(bundle_fixture: BundleFixture):
     with pytest.raises(TypeError):
         bundle.join_profile["speed"] = 0.9
     decoded = bundle.assets[0].decoded_pcm16()
+    assert bundle.assets[0].endpoint.breeze_primary_cer == 0.0
+    assert bundle.assets[0].endpoint.breeze_confirmation_cer == 0.0
     assert not decoded.flags.writeable
     with pytest.raises(ValueError):
         decoded[0] = 1

tests/test_glyph_hybrid_adapter.py

@@ -27,10 +27,6 @@ from glyph_hybrid_evidence import (
 )
 from quality_runtime import (
     SQUIM_OBJECTIVE_WEIGHT_SHA256,
-    VERIFICATION_WHISPER_MODEL_ID,
-    VERIFICATION_WHISPER_REVISION,
-    WHISPER_MODEL_ID,
-    WHISPER_REVISION,
 )
 
 
@@ -171,11 +167,11 @@ def _bundle(anchor_sha256: str, asset_pcm: bytes):
             _pin("bluemagpie-checkpoint", MODEL_REPO_ID, MODEL_REVISION),
         ),
         evaluator_pins=(
-            _pin("whisper-turbo", WHISPER_MODEL_ID, WHISPER_REVISION),
             _pin(
-                "whisper-large-v3",
-                VERIFICATION_WHISPER_MODEL_ID,
-                VERIFICATION_WHISPER_REVISION,
+                "breeze-asr-25",
+                adapter_module.BREEZE25_MODEL_ID,
+                adapter_module.BREEZE25_REVISION,
+                adapter_module.BREEZE25_WEIGHT_SHA256,
             ),
             _pin("ecapa", ECAPA_REPO_ID, ECAPA_REVISION),
             _pin(
@@ -208,14 +204,23 @@ def _runtime(
     transcript: str,
     counters: dict[str, int],
 ) -> GlyphAdapterRuntime:
+    asr_languages: list[str | None] = []
+
     def transcriber(audio, sample_rate, **kwargs):
         assert sample_rate == SAMPLE_RATE
-        assert kwargs["language"] == "zh"
+        assert kwargs["language"] in {
+            adapter_module.BREEZE25_PRIMARY_LANGUAGE,
+            adapter_module.BREEZE25_CONFIRMATION_LANGUAGE,
+        }
         assert kwargs["task"] == "transcribe"
         assert kwargs["max_new_tokens"] == 160
+        assert kwargs["max_verification_segments"] == 160
+        asr_languages.append(kwargs["language"])
         counters["asr"] += 1
         return transcript
 
+    transcriber.languages = asr_languages
+
     def speaker_measure(
         audio,
         sample_rate,
@@ -272,8 +277,8 @@ def _runtime(
             "assembly",
             counters["assembly"] + 1,
         ),
-        turbo_transcriber=transcriber,
-        verification_transcriber=transcriber,
+        breeze_primary_transcriber=transcriber,
+        breeze_confirmation_transcriber=transcriber,
         speaker_measure=speaker_measure,
         squim_measure=squim_measure,
     )
@@ -452,6 +457,10 @@ def test_adapter_replays_generation_and_reruns_pinned_evaluators(
         "squim": 1,
         "assembly": 1,
     }
+    assert case.runtime.breeze_primary_transcriber.languages == [
+        adapter_module.BREEZE25_PRIMARY_LANGUAGE,
+        adapter_module.BREEZE25_CONFIRMATION_LANGUAGE,
+    ]
     assert payload["request_proof"]["content_commitment_scheme"] == (
         "hmac-sha256-v1"
     )
@@ -479,6 +488,26 @@ def test_adapter_replays_generation_and_reruns_pinned_evaluators(
             payload["request_proof"]["independent_gate"]["asr_call_id"]
         ]["evaluator_pin_name"]
     )
+    evaluator_pins = {
+        pin["name"]: pin
+        for pin in payload["renderer_contract"]["evaluator_pins"]
+    }
+    primary_pin = evaluator_pins[
+        adapter_module.BREEZE25_PRIMARY_PIN_NAME
+    ]
+    confirmation_pin = evaluator_pins[
+        adapter_module.BREEZE25_CONFIRMATION_PIN_NAME
+    ]
+    assert (
+        primary_pin["uri"],
+        primary_pin["revision"],
+        primary_pin["sha256"],
+    ) == (
+        confirmation_pin["uri"],
+        confirmation_pin["revision"],
+        confirmation_pin["sha256"],
+    )
+    assert primary_pin["config_sha256"] != confirmation_pin["config_sha256"]
     asset_segment = next(
         row for row in segments.values() if row["kind"] == "asset"
     )

tests/test_glyph_hybrid_evidence.py

@@ -75,6 +75,13 @@ CONTENT_COMMITMENT_KEY = hashlib.sha256(
 ).digest()
 SPEAKER_ANCHOR_SHA256 = _sha("speaker-anchor")
 GENERATION_POLICY_SHA256 = _sha("quality-primary")
+BREEZE25_MODEL_ID = "MediaTek-Research/Breeze-ASR-25"
+BREEZE25_REVISION = "cffe7ccb404d025296a00758d0a33468bec3a9d0"
+BREEZE25_WEIGHT_SHA256 = (
+    "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6"
+)
+BREEZE25_PRIMARY_PIN_NAME = "breeze25-primary-zh"
+BREEZE25_CONFIRMATION_PIN_NAME = "breeze25-confirmation-auto"
 
 
 def test_schema7_default_gate_policy_is_the_frozen_per_return_contract():
@@ -241,6 +248,20 @@ def _pin(name: str) -> ArtifactPin:
     )
 
 
+def _breeze25_profile_pin(
+    name: str,
+    decoder_profile: str,
+) -> ArtifactPin:
+    return ArtifactPin(
+        name=name,
+        kind="asr",
+        uri=f"hf://{BREEZE25_MODEL_ID}",
+        revision=BREEZE25_REVISION,
+        sha256=BREEZE25_WEIGHT_SHA256,
+        config_sha256=_sha(f"breeze25:{decoder_profile}"),
+    )
+
+
 def _inputs() -> EvidenceRebuildInputs:
     raw = "甲a乙"
     canonical = "甲第一個英文字母乙"
@@ -295,8 +316,14 @@ def _inputs() -> EvidenceRebuildInputs:
         source_pins=(_pin("source"),),
         model_pins=(_pin("tts-model"),),
         evaluator_pins=(
-            _pin("asr-large-v3"),
-            _pin("asr-large-v2"),
+            _breeze25_profile_pin(
+                BREEZE25_PRIMARY_PIN_NAME,
+                "fixed-zh",
+            ),
+            _breeze25_profile_pin(
+                BREEZE25_CONFIRMATION_PIN_NAME,
+                "auto-language",
+            ),
             _pin("ecapa"),
             _pin("squim"),
         ),
@@ -393,7 +420,7 @@ def _inputs() -> EvidenceRebuildInputs:
         TrustedAsrCall(
             call_id="asr-final",
             scope="final",
-            evaluator_pin_name="asr-large-v3",
+            evaluator_pin_name=BREEZE25_PRIMARY_PIN_NAME,
             input_pcm16_le=output,
             target_text=canonical,
             transcript_text=canonical,
@@ -420,7 +447,7 @@ def _inputs() -> EvidenceRebuildInputs:
         TrustedAsrCall(
             call_id="asr-independent",
             scope="independent",
-            evaluator_pin_name="asr-large-v2",
+            evaluator_pin_name=BREEZE25_CONFIRMATION_PIN_NAME,
             input_pcm16_le=output,
             target_text=canonical,
             transcript_text=canonical,
@@ -966,7 +993,7 @@ def test_evaluator_calls_must_use_exact_pcm_pins_scope_and_subject_attribution()
     local_asr = TrustedAsrCall(
         call_id="asr-local-wrong-target",
         scope="local-primary",
-        evaluator_pin_name="asr-large-v3",
+        evaluator_pin_name=BREEZE25_PRIMARY_PIN_NAME,
         input_pcm16_le=model.output_pcm16_le,
         target_text="錯",
         transcript_text="甲",
@@ -1167,17 +1194,17 @@ def test_endpoint_and_active_speech_are_recomputed_from_exact_pcm():
         )
 
 
-def test_independent_asr_anchor_and_generation_policy_are_frozen():
+def test_independent_asr_profile_anchor_and_generation_policy_are_frozen():
     inputs = _inputs()
     independent_asr = inputs.calls[6]
     assert isinstance(independent_asr, TrustedAsrCall)
     same_asr = replace(
         independent_asr,
-        evaluator_pin_name="asr-large-v3",
+        evaluator_pin_name=BREEZE25_PRIMARY_PIN_NAME,
     )
     with pytest.raises(
         GlyphHybridEvidenceError,
-        match="distinct pinned evaluator",
+        match="distinct pinned decoder profiles",
     ):
         rebuild_hybrid_evidence(
             replace(
@@ -1190,6 +1217,70 @@ def test_independent_asr_anchor_and_generation_policy_are_frozen():
             )
         )
 
+    different_weights_pin = replace(
+        inputs.contract.evaluator_pins[1],
+        sha256=_sha("different-breeze25-weights"),
+    )
+    with pytest.raises(
+        GlyphHybridEvidenceError,
+        match="share the exact pinned model weights",
+    ):
+        rebuild_hybrid_evidence(
+            replace(
+                inputs,
+                contract=replace(
+                    inputs.contract,
+                    evaluator_pins=(
+                        inputs.contract.evaluator_pins[0],
+                        different_weights_pin,
+                        *inputs.contract.evaluator_pins[2:],
+                    ),
+                ),
+            )
+        )
+
+    foreign_weights_pins = tuple(
+        replace(
+            pin,
+            uri="hf://untrusted/other-asr",
+            revision="foreign-revision",
+            sha256=_sha("foreign-shared-weights"),
+        )
+        if pin.kind == "asr"
+        else pin
+        for pin in inputs.contract.evaluator_pins
+    )
+    with pytest.raises(
+        GlyphHybridEvidenceError,
+        match="official pinned Breeze ASR 25 weights",
+    ):
+        rebuild_hybrid_evidence(
+            replace(
+                inputs,
+                contract=replace(
+                    inputs.contract,
+                    evaluator_pins=foreign_weights_pins,
+                ),
+            )
+        )
+
+    swapped_calls = list(inputs.calls)
+    swapped_calls[3] = replace(
+        inputs.calls[3],
+        evaluator_pin_name=BREEZE25_CONFIRMATION_PIN_NAME,
+    )
+    swapped_calls[6] = replace(
+        inputs.calls[6],
+        evaluator_pin_name=BREEZE25_PRIMARY_PIN_NAME,
+    )
+    with pytest.raises(
+        GlyphHybridEvidenceError,
+        match="honest Breeze primary and confirmation logical pin names",
+    ):
+        rebuild_hybrid_evidence(
+            replace(inputs, calls=tuple(swapped_calls))
+        )
+
     ecapa = inputs.calls[4]
     assert isinstance(ecapa, TrustedEcapaCall)
     wrong_anchor = replace(

tests/test_inference_cleanup.py

@@ -215,7 +215,7 @@ def test_trajectory_verifier_skips_acoustic_models_after_semantic_preflight_fail
             "np": np,
             "CandidateObservation": CandidateObservation,
             "ChunkCandidateArtifact": ChunkCandidateArtifact,
-            "transcribe_whisper": lambda *_args, **_kwargs: "",
+            "transcribe_breeze25": lambda *_args, **_kwargs: "",
             "prepare_candidate_audio": lambda *_args, **_kwargs: SimpleNamespace(
                 waveform=waveform,
                 transcript_text="錯誤內容",
@@ -264,6 +264,7 @@ def test_trajectory_verifier_skips_acoustic_models_after_semantic_preflight_fail
 
 def test_trajectory_verifier_skips_acoustics_above_conservative_pace_preflight():
     acoustic_calls = []
+    asr_calls = []
     waveform = np.ones(2 * 48_000, dtype=np.float32)
     target = "甲乙丙丁戊己庚辛壬癸"
 
@@ -271,17 +272,18 @@ def test_trajectory_verifier_skips_acoustics_above_conservative_pace_preflight()
         acoustic_calls.append((args, kwargs))
         raise AssertionError("acoustic model should not run")
 
+    def forbidden_asr(*args, **kwargs):
+        asr_calls.append((args, kwargs))
+        raise AssertionError("Breeze25 should not run after hard pace rejection")
+
     verify_audio = _isolated_app_function(
         "_verify_trajectory_audio",
         {
             "np": np,
             "CandidateObservation": CandidateObservation,
             "ChunkCandidateArtifact": ChunkCandidateArtifact,
-            "transcribe_whisper": lambda *_args, **_kwargs: "",
-            "prepare_candidate_audio": lambda *_args, **_kwargs: SimpleNamespace(
-                waveform=waveform,
-                transcript_text=target,
-            ),
+            "transcribe_breeze25": lambda *_args, **_kwargs: "",
+            "prepare_candidate_audio": forbidden_asr,
             "active_voiced_duration_seconds": lambda *_args, **_kwargs: 2.0,
             "count_speech_units": count_speech_units,
             "verify_candidate": verify_candidate,
@@ -318,8 +320,10 @@ def test_trajectory_verifier_skips_acoustics_above_conservative_pace_preflight()
 
     assert not verification.passed
     assert verification.candidate_results[0].rejection_reasons == (
+        "semantic_gate",
         "pace_too_fast",
     )
+    assert asr_calls == []
     assert acoustic_calls == []
 
 
@@ -350,7 +354,7 @@ def test_borderline_preflight_still_runs_acoustics_then_enforces_final_pace_gate
             "np": np,
             "CandidateObservation": CandidateObservation,
             "ChunkCandidateArtifact": ChunkCandidateArtifact,
-            "transcribe_whisper": lambda *_args, **_kwargs: "",
+            "transcribe_breeze25": lambda *_args, **_kwargs: "",
             "prepare_candidate_audio": lambda *_args, **_kwargs: SimpleNamespace(
                 waveform=waveform,
                 transcript_text=target,

tests/test_latency_timing.py

@@ -8,6 +8,8 @@ import torch
 
 import latency_timing
 from quality_runtime import (
+    Breeze25Runtime,
+    transcribe_breeze25,
     WhisperRuntime,
     transcribe_verification_whisper,
     transcribe_whisper,
@@ -37,7 +39,7 @@ def test_request_timer_emits_fixed_content_free_cumulative_schema(monkeypatch):
     with latency_timing.latency_request(emit=emitted.append) as totals:
         with latency_timing.latency_stage("generation"):
             pass
-        with latency_timing.latency_stage("turbo_asr"):
+        with latency_timing.latency_stage("breeze25_asr"):
             pass
 
     assert len(emitted) == 1
@@ -51,10 +53,8 @@ def test_request_timer_emits_fixed_content_free_cumulative_schema(monkeypatch):
     assert fields["request_total_calls"] == "1"
     assert fields["generation_seconds"] == "2.500000"
     assert fields["generation_calls"] == "1"
-    assert fields["turbo_asr_seconds"] == "1.000000"
-    assert fields["turbo_asr_calls"] == "1"
-    assert fields["large_v3_asr_seconds"] == "0.000000"
-    assert fields["large_v3_asr_calls"] == "0"
+    assert fields["breeze25_asr_seconds"] == "1.000000"
+    assert fields["breeze25_asr_calls"] == "1"
     assert totals.active_depths == {}
 
 
@@ -112,8 +112,11 @@ class _Model:
         return torch.ones((features.shape[0], 2), dtype=torch.long)
 
 
-def test_dual_asr_wrappers_accumulate_under_distinct_stage_names():
-    runtime = WhisperRuntime(
+def test_compatibility_asr_aliases_share_one_stage_without_nested_timing():
+    assert WhisperRuntime is Breeze25Runtime
+    assert transcribe_whisper is transcribe_breeze25
+    assert transcribe_verification_whisper is transcribe_breeze25
+    runtime = Breeze25Runtime(
         processor=_Processor(),
         model=_Model(),
         device=torch.device("cpu"),
@@ -134,10 +137,10 @@ def test_dual_asr_wrappers_accumulate_under_distinct_stage_names():
         )
 
     fields = _fields(emitted[0])
-    assert fields["turbo_asr_calls"] == "1"
-    assert fields["large_v3_asr_calls"] == "1"
-    assert float(fields["turbo_asr_seconds"]) >= 0.0
-    assert float(fields["large_v3_asr_seconds"]) >= 0.0
+    assert fields["breeze25_asr_calls"] == "2"
+    assert float(fields["breeze25_asr_seconds"]) >= 0.0
+    assert "turbo_asr_calls" not in fields
+    assert "large_v3_asr_calls" not in fields
 
 
 def _decorator_stage(node):
@@ -182,11 +185,12 @@ def test_space_wires_every_requested_latency_stage_without_gate_changes():
     )
     assert generate_source is not None
     assert 'with latency_stage("generation"):' in generate_source
-    assert _decorator_stage(quality_functions["transcribe_whisper"]) == "turbo_asr"
     assert (
-        _decorator_stage(quality_functions["transcribe_verification_whisper"])
-        == "large_v3_asr"
+        _decorator_stage(quality_functions["transcribe_breeze25"])
+        == "breeze25_asr"
     )
+    assert "transcribe_whisper" not in quality_functions
+    assert "transcribe_verification_whisper" not in quality_functions
     assert _decorator_stage(quality_functions["speaker_evidence_from_audio"]) == "ecapa"
     assert (
         _decorator_stage(quality_functions["release_speaker_evidence_from_audio"])

tests/test_production.py

@@ -3461,6 +3461,76 @@ def test_asr_comparison_canonicalizes_target_proven_bare_clock_time_only():
     )
 
 
+def test_breeze_asr_spaced_date_and_dot_clock_are_exact_target_proven_forms():
+    target = "維護時段是二零二六年八月九日晚上七點四十五分。"
+    transcript = "維護時段是 2026 年 8 月 9 日晚上 7.45 分"
+
+    comparison = compare_asr_text(target, transcript)
+
+    assert comparison.passed
+    assert comparison.cer == 0.0
+    assert comparison.prefix_cer == 0.0
+    assert comparison.suffix_cer == 0.0
+    assert comparison.extra_tail_units == 0
+
+
+def test_breeze_asr_target_proven_dot_clock_may_omit_written_minute_unit():
+    target = "海龜調查預定在二零三三年四月二十七日凌晨四點五十五分出發。"
+    transcript = "海龜調查預定在 2033 年 4 月 27 日凌晨 4.55 出發"
+
+    comparison = compare_asr_text(target, transcript)
+
+    assert comparison.passed
+    assert comparison.cer == 0.0
+    assert comparison.prefix_cer == 0.0
+    assert comparison.suffix_cer == 0.0
+
+
+@pytest.mark.parametrize(
+    "transcript",
+    (
+        "維護時段是 2026 年 8 月 8 日晚上 7.45 分",
+        "維護時段是 2026 年 8 月 9 日晚上 7.44 分",
+        "維護時段是 2027 年 8 月 9 日晚上 7.45 分",
+    ),
+)
+def test_breeze_asr_structured_date_clock_forms_keep_wrong_values_visible(
+    transcript,
+):
+    target = "維護時段是二零二六年八月九日晚上七點四十五分。"
+
+    comparison = compare_asr_text(target, transcript)
+
+    assert comparison.edit_distance > 0
+    assert comparison.target_text != comparison.transcript_text
+
+
+def test_breeze_asr_lowercase_compact_model_code_requires_exact_target_proof():
+    target = "請先安裝韌體 v3.7.2，再核對模組代碼 AX-418。"
+    transcript = "請先安裝韌體版本 3.7.2再核對模組代碼 ax418"
+
+    comparison = compare_asr_text(target, transcript)
+
+    assert comparison.passed
+    assert comparison.cer == 0.0
+    assert comparison.prefix_cer == 0.0
+    assert comparison.suffix_cer == 0.0
+
+
+@pytest.mark.parametrize(
+    "transcript",
+    (
+        "請先安裝韌體版本 3.7.2再核對模組代碼 ax419",
+        "請先安裝韌體版本 3.7.2再核對模組代碼 bx418",
+        "請先安裝韌體版本 3.7.2再核對模組代碼 ax4188",
+    ),
+)
+def test_breeze_asr_model_code_proof_rejects_wrong_or_extra_atoms(transcript):
+    target = "請先安裝韌體 v3.7.2，再核對模組代碼 AX-418。"
+
+    assert not compare_asr_text(target, transcript).passed
+
+
 def test_asr_numeric_runs_require_exact_target_proven_cardinal_values():
     target = "原價是 NT$1,250，折扣後是 NT$999。"
     transcript = "原價是新台幣1250，折扣後是新台幣999。"

tests/test_quality_runtime.py

@@ -7,6 +7,7 @@ import pytest
 import soundfile as sf
 import torch
 
+import quality_runtime
 from production import (
     count_network_endpoint_duration_units,
     count_speech_units,
@@ -16,6 +17,13 @@ from production import (
 from quality_runtime import (
     ADAPTIVE_CASCADE_STAGE_LIMITS,
     BASE_GENERATION_POLICY,
+    BREEZE25_ATTENTION_IMPLEMENTATION,
+    BREEZE25_LANGUAGE,
+    BREEZE25_MODEL_ID,
+    BREEZE25_RETURN_ATTENTION_MASK,
+    BREEZE25_REVISION,
+    BREEZE25_TASK,
+    BREEZE25_WEIGHT_SHA256,
     COMPLETION_HEADROOM_GENERATION_POLICY,
     CASCADE_EVIDENCE_LOG_PREFIX,
     CASCADE_EVIDENCE_SCHEMA_VERSION,
@@ -38,8 +46,10 @@ from quality_runtime import (
     CandidateVerification,
     CascadeResult,
     ChunkCandidateArtifact,
+    Breeze25Runtime,
     FinalOutputRejectedError,
     LazySquimObjective,
+    LazyBreeze25ASR,
     LazyWhisperASR,
     LocalIndependentGateEvidence,
     NoQualifiedCandidateError,
@@ -67,6 +77,7 @@ from quality_runtime import (
     intersect_local_semantic_verification,
     local_candidate_has_coverage_eligibility,
     load_pinned_whisper_runtime,
+    load_pinned_breeze25_runtime,
     load_pinned_verification_whisper_runtime,
     load_pinned_squim_objective_runtime,
     prepare_candidate_audio,
@@ -83,6 +94,7 @@ from quality_runtime import (
     squim_objective_evidence_from_audio,
     trim_release_speaker_activity,
     transcribe_whisper,
+    transcribe_breeze25,
     transcribe_verification_whisper,
     trajectory_gate_evidence,
     verify_candidate,
@@ -607,13 +619,13 @@ def _joined_verification(target, transcript):
     )
 
 
-def test_pinned_whisper_loader_uses_exact_revision_without_global_download():
+def test_pinned_breeze25_loader_uses_exact_revision_without_global_download():
     processor = _FakeProcessor()
     model = _FakeWhisperModel()
     processor_factory = _Factory(processor)
     model_factory = _Factory(model)
 
-    runtime = load_pinned_whisper_runtime(
+    runtime = load_pinned_breeze25_runtime(
         device="cpu",
         processor_factory=processor_factory,
         model_factory=model_factory,
@@ -625,19 +637,64 @@ def test_pinned_whisper_loader_uses_exact_revision_without_global_download():
     assert runtime.dtype == torch.float32
     assert model.evaluated
     assert processor_factory.calls == [
-        ((WHISPER_MODEL_ID,), {"revision": WHISPER_REVISION})
+        ((BREEZE25_MODEL_ID,), {"revision": BREEZE25_REVISION})
     ]
     model_args, model_kwargs = model_factory.calls[0]
-    assert model_args == (WHISPER_MODEL_ID,)
-    assert model_kwargs["revision"] == WHISPER_REVISION
-    assert model_kwargs["attn_implementation"] == WHISPER_ATTENTION_IMPLEMENTATION
+    assert model_args == (BREEZE25_MODEL_ID,)
+    assert model_kwargs["revision"] == BREEZE25_REVISION
+    assert model_kwargs["attn_implementation"] == BREEZE25_ATTENTION_IMPLEMENTATION
     assert model_kwargs["torch_dtype"] == torch.float32
     assert model_kwargs["use_safetensors"] is True
-    assert WHISPER_ATTENTION_IMPLEMENTATION == "eager"
-    assert WHISPER_RETURN_ATTENTION_MASK is True
+    assert BREEZE25_MODEL_ID == "MediaTek-Research/Breeze-ASR-25"
+    assert BREEZE25_REVISION == "cffe7ccb404d025296a00758d0a33468bec3a9d0"
+    assert BREEZE25_WEIGHT_SHA256 == (
+        "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6"
+    )
+    assert BREEZE25_ATTENTION_IMPLEMENTATION == "eager"
+    assert BREEZE25_RETURN_ATTENTION_MASK is True
+    assert BREEZE25_LANGUAGE == "zh"
+    assert BREEZE25_TASK == "transcribe"
+
+
+def test_pinned_breeze25_loader_uses_fp16_on_explicit_cuda_device():
+    processor = _FakeProcessor()
+    model = _FakeWhisperModel()
+    processor_factory = _Factory(processor)
+    model_factory = _Factory(model)
+
+    runtime = load_pinned_breeze25_runtime(
+        device="cuda",
+        processor_factory=processor_factory,
+        model_factory=model_factory,
+    )
+
+    assert runtime.device == torch.device("cuda")
+    assert runtime.dtype == torch.float16
+    assert model.device == torch.device("cuda")
+    assert model_factory.calls[0][1]["torch_dtype"] == torch.float16
+
+
+def test_legacy_whisper_loader_names_alias_the_single_breeze25_contract():
+    assert WhisperRuntime is Breeze25Runtime
+    assert LazyWhisperASR is LazyBreeze25ASR
+    assert load_pinned_whisper_runtime is load_pinned_breeze25_runtime
+    assert load_pinned_verification_whisper_runtime is load_pinned_breeze25_runtime
+    assert transcribe_whisper is transcribe_breeze25
+    assert transcribe_verification_whisper is transcribe_breeze25
+    assert WHISPER_MODEL_ID == BREEZE25_MODEL_ID
+    assert WHISPER_REVISION == BREEZE25_REVISION
+    assert VERIFICATION_WHISPER_MODEL_ID == BREEZE25_MODEL_ID
+    assert VERIFICATION_WHISPER_REVISION == BREEZE25_REVISION
+    assert WHISPER_ATTENTION_IMPLEMENTATION == BREEZE25_ATTENTION_IMPLEMENTATION
+    assert WHISPER_RETURN_ATTENTION_MASK is BREEZE25_RETURN_ATTENTION_MASK
+    assert quality_runtime._DEFAULT_WHISPER is quality_runtime._DEFAULT_BREEZE25
+    assert (
+        quality_runtime._DEFAULT_VERIFICATION_WHISPER
+        is quality_runtime._DEFAULT_BREEZE25
+    )
 
 
-def test_pinned_verification_whisper_loader_is_separate_and_exact():
+def test_legacy_verification_loader_cannot_select_a_second_model():
     processor = _FakeProcessor()
     model = _FakeWhisperModel()
     processor_factory = _Factory(processor)
@@ -665,16 +722,16 @@ def test_pinned_verification_whisper_loader_is_separate_and_exact():
     assert model_kwargs["use_safetensors"] is True
 
 
-def test_lazy_whisper_runtime_loads_once_and_transcription_is_deterministic():
+def test_lazy_breeze25_runtime_loads_once_and_transcription_is_deterministic():
     processor = _FakeProcessor()
     model = _FakeWhisperModel()
-    runtime = WhisperRuntime(processor, model, torch.device("cpu"), torch.float32)
+    runtime = Breeze25Runtime(processor, model, torch.device("cpu"), torch.float32)
     loads = []
-    lazy_asr = LazyWhisperASR(lambda: loads.append("load") or runtime)
+    lazy_asr = LazyBreeze25ASR(lambda: loads.append("load") or runtime)
     audio_8khz = _tone(sample_rate=8_000, seconds=0.5)
 
-    first = transcribe_whisper(audio_8khz, 8_000, lazy_asr=lazy_asr)
-    second = transcribe_whisper(audio_8khz, 8_000, lazy_asr=lazy_asr)
+    first = transcribe_breeze25(audio_8khz, 8_000, lazy_asr=lazy_asr)
+    second = transcribe_breeze25(audio_8khz, 8_000, lazy_asr=lazy_asr)
 
     assert first == second == "合成內容完整。"
     assert loads == ["load"]
@@ -689,20 +746,40 @@ def test_lazy_whisper_runtime_loads_once_and_transcription_is_deterministic():
     assert torch.equal(attention_mask, processor.attention_masks[0])
     assert attention_mask.device == runtime.device
     assert generation_kwargs == {
-        "language": "zh",
         "task": "transcribe",
         "do_sample": False,
         "num_beams": 1,
         "max_new_tokens": 128,
+        "language": "zh",
     }
 
 
-def test_verification_transcriber_uses_injected_full_runtime_without_turbo_state():
+def test_breeze25_auto_language_ab_injection_omits_language_generate_argument():
     processor = _FakeProcessor()
     model = _FakeWhisperModel()
-    runtime = WhisperRuntime(processor, model, torch.device("cpu"), torch.float32)
+    runtime = Breeze25Runtime(processor, model, torch.device("cpu"), torch.float32)
+
+    transcript = transcribe_breeze25(
+        _tone(seconds=0.5),
+        16_000,
+        runtime=runtime,
+        language=None,
+    )
+
+    assert transcript == "合成內容完整。"
+    generation_kwargs = model.generate_calls[0][1]
+    assert "language" not in generation_kwargs
+    assert generation_kwargs["task"] == "transcribe"
+    assert generation_kwargs["do_sample"] is False
+    assert generation_kwargs["num_beams"] == 1
+
+
+def test_legacy_verification_transcriber_uses_injected_shared_runtime():
+    processor = _FakeProcessor()
+    model = _FakeWhisperModel()
+    runtime = Breeze25Runtime(processor, model, torch.device("cpu"), torch.float32)
     loads = []
-    lazy_asr = LazyWhisperASR(lambda: loads.append("verification") or runtime)
+    lazy_asr = LazyBreeze25ASR(lambda: loads.append("verification") or runtime)
 
     transcript = transcribe_verification_whisper(
         _tone(seconds=0.5),

tests/test_release_pins.py

@@ -346,26 +346,32 @@ def test_barbet_runtime_dependency_is_commit_pinned():
     ]
 
 
-def test_quality_asr_is_revision_pinned():
+def test_breeze25_content_asr_is_revision_and_weight_pinned_once():
     quality_path = ROOT / "quality_runtime.py"
     quality_source = quality_path.read_text(encoding="utf-8")
     constants = _string_constants(quality_path)
     app_source = (ROOT / "app.py").read_text(encoding="utf-8")
 
-    assert constants["WHISPER_MODEL_ID"] == "openai/whisper-large-v3-turbo"
-    assert constants["WHISPER_REVISION"] == "41f01f3fe87f28c78e2fbf8b568835947dd65ed9"
-    assert constants["VERIFICATION_WHISPER_MODEL_ID"] == "openai/whisper-large-v3"
+    assert constants["BREEZE25_MODEL_ID"] == "MediaTek-Research/Breeze-ASR-25"
     assert (
-        constants["VERIFICATION_WHISPER_REVISION"]
-        == "06f233fe06e710322aca913c1bc4249a0d71fce1"
+        constants["BREEZE25_REVISION"]
+        == "cffe7ccb404d025296a00758d0a33468bec3a9d0"
     )
-    assert constants["WHISPER_ATTENTION_IMPLEMENTATION"] == "eager"
-    assert "WHISPER_RETURN_ATTENTION_MASK = True" in quality_source
-    assert "snapshot_download(WHISPER_MODEL_ID, revision=WHISPER_REVISION)" in app_source
-    assert "snapshot_download(\n    VERIFICATION_WHISPER_MODEL_ID," in app_source
-    assert "revision=VERIFICATION_WHISPER_REVISION" in app_source
-    assert "load_pinned_verification_whisper_runtime" in quality_source
-    assert "transcribe_verification_whisper" in quality_source
+    assert (
+        constants["BREEZE25_WEIGHT_SHA256"]
+        == "c5d952b3bc03ea277209aff0ef5b5c4c055d74449ff794c02d8f4e315fdef6b6"
+    )
+    assert "load_pinned_breeze25_runtime" in quality_source
+    assert "transcribe_breeze25" in quality_source
+    assert app_source.count("snapshot_download(\n    BREEZE25_MODEL_ID,") == 1
+    assert "snapshot_download(WHISPER_MODEL_ID" not in app_source
+    assert "snapshot_download(\n    VERIFICATION_WHISPER_MODEL_ID," not in app_source
+    allow_patterns = _literal_constants(ROOT / "app.py")[
+        "BREEZE25_SNAPSHOT_ALLOW_PATTERNS"
+    ]
+    assert "model.safetensors" in allow_patterns
+    assert "optimizer.bin" not in allow_patterns
+    assert not any(pattern.startswith("whisper-github/") for pattern in allow_patterns)
 
 
 def test_quality_runtime_dependencies_are_version_pinned():
@@ -737,7 +743,7 @@ def test_network_endpoint_headroom_is_isolated_from_public_unit_contracts():
     ) == 1
 
 
-def test_network_local_dual_asr_capability_is_range_bound_for_initial_and_refill():
+def test_network_local_breeze25_projection_is_range_bound_for_initial_and_refill():
     app_source = (ROOT / "app.py").read_text(encoding="utf-8")
     quality_source = (ROOT / "quality_runtime.py").read_text(encoding="utf-8")
     app_tree = ast.parse(app_source)
@@ -779,11 +785,12 @@ def test_network_local_dual_asr_capability_is_range_bound_for_initial_and_refill
         )
     )
     assert "proof_rows[index] for index in selected_indices" in helper_source
-    assert "transcriber=transcribe_verification_whisper" in helper_source
+    assert "transcriber=transcribe_breeze25" in helper_source
+    assert "transcriber=transcriber" in helper_source
     assert "semantic_only=True" in helper_source
     assert "network_fragment_proofs=independent_proof_rows" in helper_source
     assert "intersect_local_semantic_verification(" in helper_source
-    assert "[BlueMagpie] network local independent " in helper_source
+    assert "[BlueMagpie] network local Breeze25 projection " in helper_source
     assert "proof_count=" in helper_source
     assert "transcript_text" not in helper_source
     for caller_source in (initial_source, refill_source):
@@ -798,6 +805,7 @@ def test_network_local_dual_asr_capability_is_range_bound_for_initial_and_refill
         assert "network_fragment_proofs=proof_rows" in caller_source
         assert "proof_rows," in caller_source[intersection_index:]
         assert "candidate_seed=" in caller_source[intersection_index:]
+        assert "transcriber=" in caller_source[intersection_index:]
     assert "semantic_reasons = [\"semantic_gate\"]" in intersection_source
     assert "\"network_protected_span_mismatch\"" in intersection_source
     assert "chunk_artifacts=primary_verification.chunk_artifacts" in (
@@ -812,7 +820,7 @@ def test_network_local_dual_asr_capability_is_range_bound_for_initial_and_refill
     assert '"independent_local_results"' in quality_source
 
 
-def test_network_local_dual_asr_runtime_reuses_exact_proof_rows_and_logs_no_text(
+def test_network_local_breeze25_projection_reuses_exact_proof_rows_and_logs_no_text(
     capsys,
 ):
     source = (ROOT / "app.py").read_text(encoding="utf-8")
@@ -869,7 +877,7 @@ def test_network_local_dual_asr_runtime_reuses_exact_proof_rows_and_logs_no_text
         "_verify_trajectory_audio": fake_verify,
         "QUALITY_FINAL_ASR_MAX_NEW_TOKENS": 440,
         "SEQUENCE_FALLBACK_MAX_LOCAL_BOUNDARY_SPEAKER_DROP": 0.15,
-        "transcribe_verification_whisper": verification_transcriber,
+        "transcribe_breeze25": verification_transcriber,
         "intersect_local_semantic_verification": fake_intersect,
         "local_candidate_has_coverage_eligibility": (
             lambda result, **_kwargs: result is primary_results[1]
@@ -885,6 +893,7 @@ def test_network_local_dual_asr_runtime_reuses_exact_proof_rows_and_logs_no_text
         "anchor",
         proof_rows,
         candidate_seed=123,
+        transcriber=verification_transcriber,
     )
 
     assert result[0] == "combined"
@@ -1045,10 +1054,7 @@ def test_app_reverifies_the_post_join_speed_adjusted_whole_waveform():
     return_index = synthesize_source.index("return SR, waveform")
     assert assemble_index < verify_index < require_index < return_index
     assert "text," in synthesize_source[verify_index:require_index]
-    assert "RELEASE_LARGE_V3_VERIFICATION_PROFILE" in synthesize_source[
-        verify_index:require_index
-    ]
-    assert "RELEASE_TURBO_VERIFICATION_PROFILE" in synthesize_source[
+    assert "BREEZE25_RELEASE_VERIFICATION_PROFILE" in synthesize_source[
         verify_index:require_index
     ]
     assert "        1.0," in release_verify_source
@@ -1249,7 +1255,7 @@ def test_whole_candidate_qualification_uses_the_exact_return_assembler_after_loc
         "joined_verification = _verify_release_whole_audio("
     )
     assert local_index < local_fail_index < assemble_index < joined_index
-    assert "RELEASE_TURBO_VERIFICATION_PROFILE" in qualify_source[joined_index:]
+    assert "BREEZE25_RELEASE_VERIFICATION_PROFILE" in qualify_source[joined_index:]
     assert "qualify_trajectory_with_joined_output(" in qualify_source[joined_index:]
     assert "waveform = _assemble_trajectory_audio(" in synthesize_source
     assert "cascade.trajectory" in synthesize_source
@@ -1257,7 +1263,7 @@ def test_whole_candidate_qualification_uses_the_exact_return_assembler_after_loc
     assert "require_verified_final_output(final_verification)" in synthesize_source
 
 
-def test_space_hard_intersects_dual_asr_on_whole_and_proven_network_locals():
+def test_space_uses_one_cached_breeze25_transcriber_for_every_semantic_gate():
     source = (ROOT / "app.py").read_text(encoding="utf-8")
     tree = ast.parse(source)
     functions = {
@@ -1300,18 +1306,34 @@ def test_space_hard_intersects_dual_asr_on_whole_and_proven_network_locals():
             synthesize_source,
         )
     )
-    assert "transcriber=transcribe_whisper" in verify_source
+    assert "transcriber=transcribe_breeze25" in verify_source
     assert "speaker_gate_enabled=not semantic_only" in verify_source
-    assert "transcriber=transcribe_verification_whisper" in independent_source
+    assert "transcriber=transcribe_breeze25" in independent_source
     assert "semantic_only=True" in independent_source
     assert "cache.verify(" in independent_source
-    assert "VERIFICATION_ASR_PROFILE" in independent_source
+    assert "BREEZE25_SEMANTIC_VERIFICATION_PROFILE" in independent_source
     assert "local_verification = _verify_trajectory_audio(" in refill_source
     assert "_verify_independent_whole_audio" not in refill_source
-    assert "transcriber=transcribe_verification_whisper" in network_local_source
+    assert "transcriber=transcribe_breeze25" in network_local_source
     assert "semantic_only=True" in network_local_source
     assert "network_fragment_proofs=independent_proof_rows" in network_local_source
     assert "intersect_local_semantic_verification(" in network_local_source
+    assert "BREEZE25_TRANSCRIPT_PROFILE" in synthesize_source
+    assert synthesize_source.count(
+        "cached_breeze25_transcriber = _cached_request_transcriber("
+    ) == 1
+    assert "transcribe_breeze25," in synthesize_source
+    assert "cached_turbo_transcriber" not in synthesize_source
+    assert "cached_large_v3_transcriber" not in synthesize_source
+    assert "transcribe_whisper" not in synthesize_source
+    assert "transcribe_verification_whisper" not in synthesize_source
+    assert synthesize_source.count(
+        "release_transcriber=cached_breeze25_transcriber"
+    ) == 3
+    assert synthesize_source.count(
+        "independent_transcriber=cached_breeze25_transcriber"
+    ) == 3
+    assert "transcriber=cached_breeze25_transcriber" in synthesize_source
 
     local_index = qualify_source.index("local_verification = _verify_trajectory_audio(")
     local_fail_index = qualify_source.index("if not local_verification.passed:")
@@ -1321,8 +1343,8 @@ def test_space_hard_intersects_dual_asr_on_whole_and_proven_network_locals():
     )
     turbo_fail_index = qualify_source.index("if not qualified.passed:")
     independent_index = qualify_source.index("_verify_independent_whole_audio(")
-    dual_index = qualify_source.index(
-        "dual_qualified = qualify_trajectory_with_joined_output("
+    semantic_projection_index = qualify_source.index(
+        "semantic_qualified = qualify_trajectory_with_joined_output("
     )
     assert (
         local_index
@@ -1331,7 +1353,7 @@ def test_space_hard_intersects_dual_asr_on_whole_and_proven_network_locals():
         < turbo_joined_index
         < turbo_fail_index
         < independent_index
-        < dual_index
+        < semantic_projection_index
     )
 
     sequence_assemble = sequence_source.index("_assemble_trajectory_audio(")
@@ -1762,16 +1784,13 @@ def test_assembled_h06_email_separator_uses_400ms_proven_network_pause():
     )
 
 
-def test_space_locks_waveform_only_bounded_whisper_segmentation():
+def test_space_locks_waveform_only_bounded_breeze25_segmentation():
     source = (ROOT / "quality_runtime.py").read_text(encoding="utf-8")
-    readme = (ROOT / "README.md").read_text(encoding="utf-8")
 
-    assert "WHISPER_MAX_SEGMENT_SECONDS = 28.0" in source
-    assert "WHISPER_HARD_MAX_SEGMENT_SECONDS = 30.0" in source
-    assert "WHISPER_MIN_SEGMENT_SECONDS = 1.25" in source
-    assert "WHISPER_MIN_PAUSE_SECONDS = 0.25" in source
-    assert "WHISPER_MAX_VERIFICATION_SEGMENTS = 12" in source
+    assert "BREEZE25_MAX_SEGMENT_SECONDS = 28.0" in source
+    assert "BREEZE25_HARD_MAX_SEGMENT_SECONDS = 30.0" in source
+    assert "BREEZE25_MIN_SEGMENT_SECONDS = 1.25" in source
+    assert "BREEZE25_MIN_PAUSE_SECONDS = 0.25" in source
+    assert "BREEZE25_MAX_VERIFICATION_SEGMENTS = 12" in source
     assert "GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS = 160" in source
-    assert "WHISPER_MAX_MICROBATCH_SEGMENTS = 6" in source
-    assert "target-dependent fallback" in readme
-    assert "每次驗證最多 12 段" in readme
+    assert "BREEZE25_MAX_MICROBATCH_SEGMENTS = 6" in source

tests/test_silence_segmentation_security.py

@@ -7,12 +7,13 @@ import pytest
 import torch
 
 from quality_runtime import (
+    BREEZE25_MAX_VERIFICATION_SEGMENTS,
+    Breeze25Runtime,
     GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS,
     WHISPER_MAX_VERIFICATION_SEGMENTS,
-    WhisperRuntime,
-    _split_short_whisper_audio_at_sustained_pause,
-    _split_whisper_audio,
-    transcribe_whisper,
+    _split_breeze25_audio,
+    _split_short_breeze25_audio_at_sustained_pause,
+    transcribe_breeze25,
 )
 
 
@@ -58,10 +59,10 @@ def test_pause_threshold_is_inclusive_at_250_ms():
             (_constant(2.0), np.zeros(pause_samples, dtype=np.float32), _constant(2.0))
         )
 
-    below = _split_short_whisper_audio_at_sustained_pause(
+    below = _split_short_breeze25_audio_at_sustained_pause(
         waveform(249), sample_rate=SAMPLE_RATE
     )
-    boundary = _split_short_whisper_audio_at_sustained_pause(
+    boundary = _split_short_breeze25_audio_at_sustained_pause(
         waveform(250), sample_rate=SAMPLE_RATE
     )
 
@@ -74,8 +75,8 @@ def test_segmentation_is_deterministic_lossless_and_contiguous():
         (_constant(2.0), _pause(0.25), _constant(2.0, 0.15))
     )
 
-    first = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
-    second = _split_whisper_audio(waveform.copy(), sample_rate=SAMPLE_RATE)
+    first = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
+    second = _split_breeze25_audio(waveform.copy(), sample_rate=SAMPLE_RATE)
 
     assert [segment.size for segment in first] == [segment.size for segment in second]
     assert all(np.array_equal(left, right) for left, right in zip(first, second))
@@ -85,7 +86,7 @@ def test_segmentation_is_deterministic_lossless_and_contiguous():
 def test_pure_silence_is_not_turned_into_meaningless_asr_batch_segments():
     waveform = np.zeros(MAXIMUM_SEGMENT_SAMPLES, dtype=np.float32)
 
-    segments = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+    segments = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
     assert len(segments) == 1
 
@@ -95,7 +96,7 @@ def test_peak_transient_does_not_reclassify_continuous_low_energy_speech_as_paus
     waveform = (0.01 * np.sin(2.0 * np.pi * 220.0 * time)).astype(np.float32)
     waveform[2_990:3_010] = 0.9
 
-    segments = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+    segments = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
     assert len(segments) == 1
 
@@ -105,7 +106,7 @@ def test_every_nonempty_verifier_segment_respects_minimum_and_target_cap():
         (_constant(27.65), _pause(0.30), _constant(0.20))
     )
 
-    segments = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+    segments = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
     assert np.array_equal(np.concatenate(segments), waveform)
     assert len(segments) == 1
@@ -125,7 +126,7 @@ def test_adversarial_short_pause_density_fails_closed_above_segment_cap():
     )
 
     with pytest.raises(ValueError, match="pause segment cap"):
-        _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+        _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
 
 def test_long_nine_pause_atoms_remain_independent_verified_contexts():
@@ -136,7 +137,7 @@ def test_long_nine_pause_atoms_remain_independent_verified_contexts():
         cursor += round(duration * SAMPLE_RATE)
         waveform[cursor - 150 : cursor + 150] = 0.0
 
-    segments = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+    segments = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
     assert len(segments) == len(expected_seconds)
     assert np.array_equal(np.concatenate(segments), waveform)
@@ -154,7 +155,7 @@ def test_h11_shorter_atomic_layout_preserves_every_proven_pause_atom():
         cursor += round(duration * SAMPLE_RATE)
         waveform[cursor - 150 : cursor + 150] = 0.0
 
-    segments = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+    segments = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
     assert len(segments) == len(atomic_seconds)
     assert np.array_equal(np.concatenate(segments), waveform)
@@ -170,7 +171,7 @@ def test_h06_network_seam_from_app_contract_splits_exactly_two_segments():
         (_constant(4.51), _pause(network_pause_seconds), _constant(2.55))
     )
 
-    segments = _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+    segments = _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
     assert network_pause_seconds == 0.40
     assert len(segments) == 2
@@ -181,7 +182,7 @@ def test_long_continuous_voiced_audio_without_qualified_pause_fails_closed():
     waveform = _constant(61.0)
 
     with pytest.raises(ValueError, match="no qualified 250ms pause"):
-        _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+        _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
 
 def test_long_coarse_split_allows_exactly_twelve_segments_and_rejects_thirteen():
@@ -197,11 +198,11 @@ def test_long_coarse_split_allows_exactly_twelve_segments_and_rejects_thirteen()
             )
         )
 
-    twelve = _split_whisper_audio(waveform(12), sample_rate=SAMPLE_RATE)
+    twelve = _split_breeze25_audio(waveform(12), sample_rate=SAMPLE_RATE)
 
     assert len(twelve) == MAXIMUM_VERIFIER_SEGMENTS
     with pytest.raises(ValueError, match="pause segment cap"):
-        _split_whisper_audio(waveform(13), sample_rate=SAMPLE_RATE)
+        _split_breeze25_audio(waveform(13), sample_rate=SAMPLE_RATE)
 
 
 class _RecordingProcessor:
@@ -244,14 +245,14 @@ def test_verification_asr_uses_bounded_microbatches_not_one_unbounded_batch():
         )
     )
     processor = _RecordingProcessor()
-    runtime = WhisperRuntime(
+    runtime = Breeze25Runtime(
         processor,
         _FakeModel(),
         torch.device("cpu"),
         torch.float32,
     )
 
-    transcribe_whisper(waveform, sample_rate, runtime=runtime)
+    transcribe_breeze25(waveform, sample_rate, runtime=runtime)
 
     batch_sizes = [len(audio) if isinstance(audio, list) else 1 for audio in processor.calls]
     assert batch_sizes == [6, 1]
@@ -270,14 +271,14 @@ def test_long_nine_atom_regression_uses_two_bounded_pause_atom_batches():
             cursor - round(0.15 * sample_rate) : cursor + round(0.15 * sample_rate)
         ] = 0.0
     processor = _RecordingProcessor()
-    runtime = WhisperRuntime(
+    runtime = Breeze25Runtime(
         processor,
         _FakeModel(),
         torch.device("cpu"),
         torch.float32,
     )
 
-    transcript = transcribe_whisper(waveform, sample_rate, runtime=runtime)
+    transcript = transcribe_breeze25(waveform, sample_rate, runtime=runtime)
 
     assert [
         len(audio) if isinstance(audio, list) else 1
@@ -299,21 +300,22 @@ def test_glyph_override_expands_only_the_explicit_bounded_segment_budget():
     )
 
     with pytest.raises(ValueError, match="pause segment cap"):
-        _split_whisper_audio(waveform, sample_rate=SAMPLE_RATE)
+        _split_breeze25_audio(waveform, sample_rate=SAMPLE_RATE)
 
-    segments = _split_whisper_audio(
+    segments = _split_breeze25_audio(
         waveform,
         sample_rate=SAMPLE_RATE,
         max_verification_segments=13,
     )
 
-    assert WHISPER_MAX_VERIFICATION_SEGMENTS == 12
+    assert BREEZE25_MAX_VERIFICATION_SEGMENTS == 12
+    assert WHISPER_MAX_VERIFICATION_SEGMENTS == BREEZE25_MAX_VERIFICATION_SEGMENTS
     assert GLYPH_HYBRID_MAX_VERIFICATION_SEGMENTS == 160
     assert len(segments) == 13
     assert sum(segment.size for segment in segments) == waveform.size
     for invalid in (True, 0, 161):
         with pytest.raises(ValueError, match=r"integer in \[1, 160\]"):
-            _split_whisper_audio(
+            _split_breeze25_audio(
                 waveform,
                 sample_rate=SAMPLE_RATE,
                 max_verification_segments=invalid,