feat(asr): REQ-265 端点参数档案化骨架（asr-params.json，默认零变更）

Author: Aparencia

app/src-tauri/src/live_session_lifecycle.rs

@@ -346,12 +346,9 @@ fn run_session(
     let epoch = Instant::now();
 
     // 1) 流式 ASR（SenseVoice 重打分接离线引擎池；M5 热词经共享词表注入）
-    // ADR-012 F3-1：rule3 最长句 env 可覆盖（默认 8s——5s 过短致句中硬切）
-    let rule3_secs = std::env::var("ENTROPY_ASR_RULE3_SECS")
-        .ok()
-        .and_then(|v| v.parse::<f32>().ok())
-        .unwrap_or(8.0);
-    let asr_config = StreamingAsrConfig { rule3_min_utterance_secs: rule3_secs };
+    // v0.20.1 REQ-265：端点配置档案化（asr-params.json + 遗留 env 覆盖；
+    // 默认值即原常量零行为变更——与 run_prepared 同口径防漂移）
+    let asr_config = StreamingAsrConfig::from_env();
     let asr_engine = match StreamingAsrEngine::load(
         &params.streaming_models,
         &asr_config,

app/src-tauri/src/live_session_prepare.rs

@@ -102,12 +102,9 @@ impl PreparedSession {
 
 /// 预备线程入口：加载引擎 → 置 Ready → park 等 Start/Cancel/TTL。
 pub fn run_prepared(rx: mpsc::Receiver<PrepareMsg>, env: PrepareEnv, status: Arc<Mutex<PrepareStatus>>) {
-    // 与 run_session 同口径的 rule3 配置（env 可覆盖，防两处漂移）
-    let rule3_secs = std::env::var("ENTROPY_ASR_RULE3_SECS")
-        .ok()
-        .and_then(|v| v.parse::<f32>().ok())
-        .unwrap_or(8.0);
-    let asr_config = StreamingAsrConfig { rule3_min_utterance_secs: rule3_secs };
+    // 与 run_session 同口径的端点配置（v0.20.1 REQ-265：档案 asr-params.json +
+    // 遗留 env 覆盖，防两处漂移；默认值即原常量零变更）
+    let asr_config = StreamingAsrConfig::from_env();
     let engine = match StreamingAsrEngine::load(
         &env.streaming_models,
         &asr_config,

app/src-tauri/src/streaming_asr.rs

@@ -40,19 +40,83 @@ pub struct StreamingAsrModels {
     pub tokens: String,
 }
 
-/// 流式引擎配置（ADR-012 F3-1：rule3 可配置）。
-#[derive(Debug, Clone, Copy)]
+/// 流式引擎配置（ADR-012 F3-1：rule3 可配置；v0.20.1 REQ-265：rule1/2 一并入档——
+/// 默认值即原常量，零行为变更；档案化来源：`asr-params.json`（可选，经
+/// ENTROPY_ASR_PARAMS_JSON 指定）+ 遗留 env ENTROPY_ASR_RULE3_SECS 覆盖）。
+#[derive(Debug, Clone, PartialEq)]
 pub struct StreamingAsrConfig {
-    /// rule3 最长句强制断句（秒；默认 8s——5s 过短致句中硬切，20s 过长）
+    /// 端点 rule1：尾静音断句秒数（默认 2.4——sherpa-onnx 惯例）。
+    pub rule1_min_trailing_silence: f32,
+    /// 端点 rule2：短停顿断句秒数（默认 1.2）。
+    pub rule2_min_trailing_silence: f32,
+    /// rule3 最长句强制断句（秒；默认 8s——5s 过短致句中硬切，20s 过长）。
     pub rule3_min_utterance_secs: f32,
 }
 
 impl Default for StreamingAsrConfig {
     fn default() -> Self {
-        Self { rule3_min_utterance_secs: 8.0 }
+        Self {
+            rule1_min_trailing_silence: 2.4,
+            rule2_min_trailing_silence: 1.2,
+            rule3_min_utterance_secs: 8.0,
+        }
+    }
+}
+
+impl StreamingAsrConfig {
+    /// 从 asr-params.json（可选）加载：缺失/损坏 → 默认 + 提示（不阻断启动，
+    /// 同 audio-preproc.json 先例）；字段可缺省。
+    ///
+    /// @ai-context: JSON 形态 `{"rule1S": 2.4, "rule2S": 1.2, "rule3S": 8.0}`——
+    ///              字段名沿用 harness 参数注入面的短名，标定结论可直接落档。
+    pub fn load_from_file(path: &std::path::Path) -> Self {
+        let mut cfg = Self::default();
+        if let Ok(raw) = std::fs::read_to_string(path) {
+            match serde_json::from_str::<AsrParamsFile>(&raw) {
+                Ok(f) => {
+                    if let Some(v) = f.rule1_s {
+                        cfg.rule1_min_trailing_silence = v;
+                    }
+                    if let Some(v) = f.rule2_s {
+                        cfg.rule2_min_trailing_silence = v;
+                    }
+                    if let Some(v) = f.rule3_s {
+                        cfg.rule3_min_utterance_secs = v;
+                    }
+                }
+                Err(e) => eprintln!("[AsrParams] asr-params.json 解析失败，使用默认: {}", e),
+            }
+        }
+        cfg
+    }
+
+    /// 档案 + 遗留 env 覆盖（生产装配入口：文件优先、env 最高优先级保持旧行为）。
+    pub fn from_env() -> Self {
+        let mut cfg = Self::default();
+        if let Ok(p) = std::env::var("ENTROPY_ASR_PARAMS_JSON") {
+            cfg = Self::load_from_file(std::path::Path::new(&p));
+        }
+        if let Ok(v) = std::env::var("ENTROPY_ASR_RULE3_SECS") {
+            if let Ok(s) = v.parse::<f32>() {
+                cfg.rule3_min_utterance_secs = s;
+            }
+        }
+        cfg
     }
 }
 
+/// asr-params.json 的 serde 形态（字段可缺省）。
+#[derive(Debug, Clone, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AsrParamsFile {
+    #[serde(default)]
+    rule1_s: Option<f32>,
+    #[serde(default)]
+    rule2_s: Option<f32>,
+    #[serde(default)]
+    rule3_s: Option<f32>,
+}
+
 /// 流式 ASR 事件（文本事件，时间戳由编排层标注）。
 #[derive(Debug, Clone, PartialEq)]
 pub enum StreamingAsrEvent {
@@ -127,10 +191,10 @@ impl StreamingAsrEngine {
         // 带 graph 的流，断言 abort（exit 0xffffffff，用户真机日志实证 Decode:101）；
         // 无热词时同样兼容（beam 搜索对普通流无副作用，识别质量相当或更优）。
         recognizer_config.decoding_method = Some("modified_beam_search".into());
-        // 端点规则：尾静音 2.4s / 1.2s 断句（sherpa-onnx 默认），
-        // rule3 强制断句 = 可配置（ADR-012 F3-1：默认 8s，env 可覆盖）
-        recognizer_config.rule1_min_trailing_silence = 2.4;
-        recognizer_config.rule2_min_trailing_silence = 1.2;
+        // 端点规则：rule1/2/3 来自配置（默认 2.4/1.2/8.0 即原常量，零行为变更；
+        // 档案/覆盖来源见 StreamingAsrConfig::from_env/load_from_file）
+        recognizer_config.rule1_min_trailing_silence = config.rule1_min_trailing_silence;
+        recognizer_config.rule2_min_trailing_silence = config.rule2_min_trailing_silence;
         recognizer_config.rule3_min_utterance_length = config.rule3_min_utterance_secs;
 
         let recognizer = OnlineRecognizer::create(&recognizer_config)

app/src-tauri/src/streaming_asr_tests.rs

@@ -426,3 +426,36 @@ fn token_chars_load_single_char_columns_only() {
     assert!(set.contains(&'a') && set.contains(&'b') && set.contains(&'焦') && set.contains(&'▁'));
     assert_eq!(set.len(), 4);
 }
+
+// ── REQ-265（v0.20.1）：端点参数档案化（asr-params.json）──
+
+#[test]
+fn params_file_overrides_and_partial_fields_ok() {
+    // Arrange：临时 asr-params.json——只给 rule3（rule1/2 缺省走默认）
+    let raw = r#"{"rule3S": 6.5}"#;
+    let path = std::env::temp_dir().join(format!("asr_params_{}.json", std::process::id()));
+    std::fs::write(&path, raw).expect("写临时 params");
+    // Act
+    let cfg = StreamingAsrConfig::load_from_file(&path);
+    let _ = std::fs::remove_file(&path);
+    // Assert：覆盖生效；缺省字段保持默认（默认值即原常量，零行为变更）
+    assert_eq!(cfg.rule3_min_utterance_secs, 6.5);
+    assert_eq!(cfg.rule1_min_trailing_silence, 2.4);
+    assert_eq!(cfg.rule2_min_trailing_silence, 1.2);
+}
+
+#[test]
+fn params_file_bad_or_missing_falls_back_defaults() {
+    // Arrange：损坏 JSON 与缺失文件
+    let path = std::env::temp_dir().join(format!("asr_params_bad_{}.json", std::process::id()));
+    std::fs::write(&path, "{not json").expect("写坏 params");
+    // Act
+    let bad = StreamingAsrConfig::load_from_file(&path);
+    let missing = StreamingAsrConfig::load_from_file(
+        std::path::Path::new(&format!("{}.nope", path.to_string_lossy())),
+    );
+    let _ = std::fs::remove_file(&path);
+    // Assert：默认兜底（不阻断启动，同 audio-preproc.json 先例）
+    assert_eq!(bad, StreamingAsrConfig::default());
+    assert_eq!(missing, StreamingAsrConfig::default());
+}

app/src-tauri/src/title_rules.rs

@@ -49,7 +49,7 @@ pub fn title_hotword_candidates(raw: &str) -> Vec<String> {
         if tok.chars().all(|c| c.is_ascii_digit()) {
             continue; // 纯数字（年份/计数）无术语价值
         }
-        if BRAND_SUFFIXES.iter().any(|b| tok == *b) {
+        if BRAND_SUFFIXES.contains(&tok) {
             continue; // 平台品牌名不入词表
         }
         if !out.iter().any(|t| t == tok) {