feat(asr): REQ-265 rule3 默认 12s 定案 + REQ-267 排空专用单测

Author: Aparencia

app/src-tauri/src/bin/asr_eval_stream.rs

@@ -27,7 +27,8 @@ pub struct StreamParams {
 
 impl Default for StreamParams {
     fn default() -> Self {
-        Self { rule1_s: 2.4, rule2_s: 1.2, rule3_s: 8.0 }
+        // rule3 与生产同默认（12s，REQ-265 首轮标定定案 2026-09-05）
+        Self { rule1_s: 2.4, rule2_s: 1.2, rule3_s: 12.0 }
     }
 }
 

app/src-tauri/src/engine.rs

@@ -161,6 +161,16 @@ impl EnginePool {
         Self::assemble(asr_tx, ocr_tx)
     }
 
+    /// 测试用：注入 ASR 通道并共享 receiver（REQ-267 排空单测专用——
+    /// 队列中已有请求时 drain_asr_backlog 应逐条回复 Err 并清空）。
+    #[cfg(test)]
+    pub fn with_asr_channel_and_rx(asr_tx: Sender<AsrRequest>, asr_rx: Receiver<AsrRequest>) -> Self {
+        let (ocr_tx, _) = mpsc::channel::<OcrRequest>();
+        let mut p = Self::assemble(asr_tx, ocr_tx);
+        p.asr_rx = Some(Arc::new(Mutex::new(asr_rx)));
+        p
+    }
+
     /// 测试装配：计数/状态 Arc 全部归零或默认（start 与测试构造共用，避免重复）。
     #[cfg(test)]
     fn assemble(asr_tx: Sender<AsrRequest>, ocr_tx: Sender<OcrRequest>) -> Self {
@@ -479,6 +489,29 @@ mod tests {
         assert_eq!(pool.rescore_timeout_count(), 1);
     }
 
+    #[test]
+    fn drain_asr_backlog_replies_err_and_empties_queue() {
+        // Arrange：持活 receiver + 队列中 2 个待处理请求（REQ-267：worker 串行
+        // 慢机下调用方超时后积压——排空必须逐条回复 Err 而非滞留陈旧状态）
+        let (asr_tx, asr_rx) = mpsc::channel::<AsrRequest>();
+        let pool = EnginePool::with_asr_channel_and_rx(asr_tx, asr_rx);
+        let (r1, rr1) = mpsc::channel();
+        let (r2, rr2) = mpsc::channel();
+        pool.asr_tx
+            .send(AsrRequest::TranscribePcm { samples: vec![0.0f32], sample_rate: 16_000, reply: r1 })
+            .expect("send1");
+        pool.asr_tx
+            .send(AsrRequest::Transcribe { path: String::new(), reply: r2 })
+            .expect("send2");
+        // Act：排空
+        pool.drain_asr_backlog();
+        // Assert：两条积压请求即刻收到可诊断 Err；队列清空后再排为空操作
+        let e1 = rr1.recv_timeout(std::time::Duration::from_millis(200)).expect("reply1 应即时到达");
+        let e2 = rr2.recv_timeout(std::time::Duration::from_millis(200)).expect("reply2 应即时到达");
+        assert!(e1.is_err() && e2.is_err(), "积压请求应收到废弃 Err");
+        pool.drain_asr_backlog(); // 不 panic（空队列 no-op）
+    }
+
     #[test]
     fn recognize_image_timeout_returns_err_on_bounded_wait() {
         // Arrange：持活 receiver 的 OCR 通道——send 成功、recv 必超时（无 worker 应答）

app/src-tauri/src/streaming_asr.rs

@@ -49,7 +49,8 @@ pub struct StreamingAsrConfig {
     pub rule1_min_trailing_silence: f32,
     /// 端点 rule2：短停顿断句秒数（默认 1.2）。
     pub rule2_min_trailing_silence: f32,
-    /// rule3 最长句强制断句（秒；默认 8s——5s 过短致句中硬切，20s 过长）。
+    /// rule3 最长句强制断句（秒；默认 12s——REQ-265 首轮标定定案：
+    /// 8s 硬切中长句致句碎，12s 5/5 样本一致更优；20s 仍过长）。
     pub rule3_min_utterance_secs: f32,
 }
 
@@ -58,7 +59,9 @@ impl Default for StreamingAsrConfig {
         Self {
             rule1_min_trailing_silence: 2.4,
             rule2_min_trailing_silence: 1.2,
-            rule3_min_utterance_secs: 8.0,
+            // REQ-265 首轮标定（2026-09-05，弱参考 5 样本 5/5 一致改善 Δ≈0.029）：
+            // rule3 8s → 12s（8s 硬切中长句；12s 贴合自然语流）；用户裁决定案
+            rule3_min_utterance_secs: 12.0,
         }
     }
 }

app/src-tauri/src/streaming_asr_tests.rs

@@ -62,12 +62,13 @@ fn silence_blocks_counter_counts_all_silent_blocks() {
     assert_eq!(blocks, 10);
 }
 
-// ── rule3 配置（ADR-012 F3-1）──
+// ── rule3 配置（ADR-012 F3-1；REQ-265 首轮标定定案 2026-09-05）──
 
 #[test]
-fn default_rule3_is_8_seconds() {
-    // 默认 8s（5s 过短致句中硬切，取证 ADR-012）
-    assert_eq!(StreamingAsrConfig::default().rule3_min_utterance_secs, 8.0);
+fn default_rule3_is_12_seconds_after_calibration() {
+    // REQ-265 首轮标定（弱参考 5 样本 5/5 一致改善 Δ≈0.029）：8s 硬切中长句
+    // 致句碎，12s 贴合自然语流——用户裁决（2026-09-05）默认 8s → 12s
+    assert_eq!(StreamingAsrConfig::default().rule3_min_utterance_secs, 12.0);
 }
 
 // ── 热词 tokens 过滤（2026-08-21：领域热词含 tokens 表外字 → 解码 abort）──