feat(asr): REQ-269 ASR 混淆画像闭环后端（采集+确认制+共现纠错）

Author: Aparencia

app/src-tauri/src/app_setup.rs

@@ -98,6 +98,12 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
     let profile_memory = std::sync::Arc::new(std::sync::Mutex::new(
         crate::video_profile::ProfileMemory::load(&profile_memory_path),
     ));
+    // v0.20.2（REQ-269）：ASR 混淆画像闭环表（采纳流采集/候选确认制；
+    // asr_confusion.json 可校准——缺失走默认、损坏回退默认，同 ui_junk 先例）
+    let asr_confusion_path = data_dir.join("asr_confusion.json");
+    let asr_confusion = std::sync::Arc::new(std::sync::Mutex::new(
+        crate::asr_confusion::AsrConfusionStore::load(&asr_confusion_path),
+    ));
     // v0.5.0 M8（REQ-055）：补缝式 AI 护栏骨架（配额/缓存/审计；云端 V1.0 生效）
     let ai_guardrails =
         std::sync::Arc::new(std::sync::Mutex::new(crate::ai_guardrails::AiGuardrails::default()));
@@ -290,6 +296,9 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
         float_ui: std::sync::Arc::new(std::sync::Mutex::new(crate::commands_window::FloatUi::default())),
         // v0.20.2（REQ-268）：会话第二遍离线精修运行注册表（默认空）
         second_pass_jobs: std::sync::Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
+        // v0.20.2（REQ-269）：ASR 混淆画像闭环表（内存态单点 + JSON 校准路径）
+        asr_confusion,
+        asr_confusion_path,
     });
     // v0.12.3（P2-10）：浮窗预创建常驻（隐藏）——打开秒显、点击期零建窗风险；
     // 失败幂等回落为打开时懒创建（open_capture_float 内部兜底）。

app/src-tauri/src/asr_confusion.rs

@@ -0,0 +1,212 @@
+//! ASR 同音混淆画像闭环（v0.20.2 / REQ-269）。
+//!
+//! @ai-context: 画像源——用户「采纳」的离线精修草稿（REQ-268 裁决流）：
+//!              旧文本（被换掉）与精修文本（用户选中的更优面）做字符级对齐，
+//!              连续错位段聚成词级对 (wrong, right)——采纳=有标注的弱参考，
+//!              画像即真实产出，无人工标注成本。
+//! @ai-context: 闭环三步——① 聚合画像（词级对 + 次数，JSON 可校准）；② 候选
+//!              （次数 ≥ 门槛、未确认未忽略）经确认制进规则表（OCR ocr_confusion
+//!              哲学迁移：共现才替换——from 只在「正确词 to 已出现在同文语料」时
+//!              才替换，无共现不猜，防错纠）；③ 反哺 hotwords 由命令层完成
+//!              （确认即把 to 加入热词注入流式 ASR，下次识别自带正确词先验）。
+//! @ai-context: 只读消费面=产物文本组装（commands_session_note 转换/预览），
+//!              原料 session_segments 永不变（与 REQ-268 同可逆契约）。
+//! @ai-context: 纯逻辑 + JSON IO（路径注入，测试用内存/temp）；无网络依赖。
+
+use serde::{Deserialize, Serialize};
+
+/// 词级混淆对统计（wrong=被换掉的旧文本词段；right=用户采纳的新词段）。
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct AsrPair {
+    pub wrong: String,
+    pub right: String,
+    /// 出现次数（采纳流聚合）
+    pub count: u64,
+}
+
+/// 已确认纠错规则（from → to；from 为待替换词形，to 为正确词）。
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AsrRule {
+    pub from: String,
+    pub to: String,
+}
+
+/// 画像 + 规则 + 忽略单（单文件 JSON 校准，data_dir/asr_confusion.json）。
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+pub struct AsrConfusionStore {
+    /// 词级画像（wrong→right 计数）
+    #[serde(default)]
+    pub pairs: Vec<AsrPair>,
+    /// 已确认规则（用户裁决——机器不自动生效）
+    #[serde(default)]
+    pub rules: Vec<AsrRule>,
+    /// 已忽略候选键（"wrong|right"——不再推荐）
+    #[serde(default)]
+    pub dismissed: Vec<String>,
+}
+
+/// 候选次数门槛（防单次噪声；与 OCR 画像 min_count 先例同哲学）。
+pub const MIN_CANDIDATE_COUNT: u64 = 2;
+/// 词级对最大长度（超长=对齐错位噪声，不提名——宁漏勿错）。
+pub const MAX_RUN_CHARS: usize = 8;
+
+impl AsrConfusionStore {
+    /// 从磁盘加载（缺失/损坏 → 空画像与规则，不阻断启动——校准文件可删）。
+    pub fn load(path: &std::path::Path) -> Self {
+        match std::fs::read_to_string(path) {
+            Ok(raw) => serde_json::from_str(&raw).unwrap_or_default(),
+            Err(_) => Self::default(),
+        }
+    }
+
+    /// 原子写（先 tmp 后 rename——防写一半损坏；vocab.json 同款）。
+    pub fn save(&self, path: &std::path::Path) -> crate::error::Result<()> {
+        let raw = serde_json::to_string_pretty(self)
+            .map_err(|e| crate::error::AppError::Io(format!("序列化 ASR 混淆表失败: {}", e)))?;
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let tmp = path.with_extension("json.tmp");
+        std::fs::write(&tmp, raw)?;
+        std::fs::rename(&tmp, path)?;
+        Ok(())
+    }
+
+    /// 记录一次采纳差异（old=被换旧文，new=采纳精修文——new 侧为弱参考）：
+    /// 聚合词级对计数；返回新增对数。
+    pub fn record_adoption(&mut self, old: &str, new: &str) -> usize {
+        let mut added = 0;
+        for (wrong, right) in word_pairs(old, new) {
+            match self.pairs.iter_mut().find(|p| p.wrong == wrong && p.right == right) {
+                Some(p) => p.count += 1,
+                None => {
+                    self.pairs.push(AsrPair { wrong, right, count: 1 });
+                    added += 1;
+                }
+            }
+        }
+        added
+    }
+
+    /// 候选（次数达标、未被确认/忽略；按次数降序，最多 limit 条）。
+    pub fn candidates(&self, limit: usize) -> Vec<&AsrPair> {
+        let mut list: Vec<&AsrPair> = self
+            .pairs
+            .iter()
+            .filter(|p| {
+                p.count >= MIN_CANDIDATE_COUNT
+                    && !self.rules.iter().any(|r| r.from == p.wrong)
+                    && !self.dismissed.iter().any(|k| k == &pair_key(&p.wrong, &p.right))
+            })
+            .collect();
+        list.sort_by_key(|p| std::cmp::Reverse(p.count));
+        list.truncate(limit);
+        list
+    }
+
+    /// 确认候选 → 规则表（from=wrong，to=right；重复 from 覆盖——现场校准优先）；
+    /// 返回 true=生效。
+    pub fn confirm(&mut self, wrong: &str, right: &str) -> bool {
+        if wrong.trim().is_empty() || right.trim().is_empty() || wrong == right {
+            return false;
+        }
+        let from = wrong.trim();
+        let to = right.trim();
+        if let Some(r) = self.rules.iter_mut().find(|r| r.from == from) {
+            r.to = to.to_string();
+        } else {
+            self.rules.push(AsrRule { from: from.to_string(), to: to.to_string() });
+        }
+        // 规则已生效的画像对不再推荐（候选过滤器同样拦截）
+        self.pairs.retain(|p| p.wrong != from || p.right != to);
+        true
+    }
+
+    /// 忽略候选（仅记录，不删历史画像——未来可再评估）。
+    pub fn dismiss(&mut self, wrong: &str, right: &str) {
+        let key = pair_key(wrong, right);
+        if !self.dismissed.iter().any(|k| *k == key) {
+            self.dismissed.push(key.clone());
+        }
+        self.pairs.retain(|p| pair_key(&p.wrong, &p.right) != key);
+    }
+
+    /// 删除规则（恢复画像原样——只回规则表，历史计数已在 confirm 时移除）。
+    pub fn remove_rule(&mut self, from: &str) -> bool {
+        let before = self.rules.len();
+        self.rules.retain(|r| r.from != from);
+        self.rules.len() != before
+    }
+}
+
+fn pair_key(wrong: &str, right: &str) -> String {
+    format!("{}|{}", wrong, right)
+}
+
+/// 纠错（纯函数）：长词优先顺序替换；**共现才替换**——正确词 to 未出现在
+/// 语料（同会话全文）中不猜（OCR ocr_correction 哲学迁移：互证缺失=孤立词形，
+/// 可能是特有词而非错词）。
+pub fn apply_rules(text: &str, corpus: &str, rules: &[AsrRule]) -> String {
+    if rules.is_empty() || text.is_empty() || corpus.is_empty() {
+        return text.to_string();
+    }
+    let mut sorted = rules.to_vec();
+    sorted.sort_by_key(|r| std::cmp::Reverse(r.from.chars().count()));
+    let mut out = text.to_string();
+    for r in sorted {
+        if !r.from.is_empty() && out.contains(&r.from) && corpus.contains(&r.to) {
+            out = out.replace(&r.from, &r.to);
+        }
+    }
+    out
+}
+
+/// 词级对提取（纯函数）：两段采纳差异文本 → 连续错位段词对 (old 侧, new 侧)。
+///
+/// @ai-context: 复用 eval_confusion::diff_ops（字符级 DP 回溯，去标点口径同
+///              CER/画像）——连续非匹配操作聚成段；**含单字对**（同音词常见
+///              仅首字不同：概念/该念）——单字替换风险由「确认制 + 共现才
+///              替换 + JSON 可删」三重把关（OCR 0/O 先例同哲学）；超长段
+///              （> MAX_RUN_CHARS，插删错位）丢弃——宁漏勿错，候选只做提名人。
+fn word_pairs(old: &str, new: &str) -> Vec<(String, String)> {
+    use crate::asr_rescore::strip_punct;
+    use crate::eval_confusion::{diff_ops, EditOp};
+    let old_chars = strip_punct(old);
+    let new_chars = strip_punct(new);
+    if old_chars.len() > 2000 || new_chars.len() > 2000 {
+        return Vec::new(); // 超长护栏（同 eval_confusion::MAX_DIFF_CHARS 精神）
+    }
+    let ops = diff_ops(&old_chars, &new_chars);
+    let mut out = Vec::new();
+    let mut run_old: Vec<char> = Vec::new();
+    let mut run_new: Vec<char> = Vec::new();
+    let mut flush = |run_old: &mut Vec<char>, run_new: &mut Vec<char>, out: &mut Vec<(String, String)>| {
+        if !run_old.is_empty()
+            && !run_new.is_empty()
+            && run_old.len() == run_new.len()
+            && run_old.len() <= MAX_RUN_CHARS
+        {
+            out.push((run_old.iter().collect::<String>(), run_new.iter().collect::<String>()));
+        }
+        run_old.clear();
+        run_new.clear();
+    };
+    for op in ops {
+        match op {
+            EditOp::Match(_) => flush(&mut run_old, &mut run_new, &mut out),
+            EditOp::Sub(a, b) => {
+                run_old.push(a);
+                run_new.push(b);
+            }
+            // 插/删不配对——仅计入两侧串影响长度不等，flush 时按规则丢弃
+            EditOp::Ins(c) => run_new.push(c),
+            EditOp::Del(c) => run_old.push(c),
+        }
+    }
+    flush(&mut run_old, &mut run_new, &mut out);
+    out
+}
+
+#[cfg(test)]
+#[path = "asr_confusion_tests.rs"]
+mod tests;

app/src-tauri/src/asr_confusion_tests.rs

@@ -0,0 +1,152 @@
+//! ASR 混淆画像闭环纯逻辑单测（v0.20.2 / REQ-269，AAA）。
+//!
+//! @ai-context: 验收门槛「画像闭环单测（共现才替换、确认制）」：候选门槛、
+//!              确认进入规则、忽略去候选、共现门、JSON 往返全覆盖。
+
+use super::*;
+
+// ── word_pairs（词级对提取）──
+
+#[test]
+fn word_pairs_extracts_homophone_substitution() {
+    // 旧文"毕需掌握" → 新文"必须掌握"：单错词对（毕需, 必须）
+    let pairs = word_pairs("毕需掌握", "必须掌握");
+    assert!(pairs.contains(&("毕需".to_string(), "必须".to_string())), "{pairs:?}");
+}
+
+#[test]
+fn word_pairs_single_char_homophone_emitted() {
+    // 同音词仅首字不同（概念/该念 型）：单字替换对入候选——确认制+共现守卫把关
+    let pairs = word_pairs("基本该念", "基本概念");
+    assert!(pairs.contains(&("该".to_string(), "概".to_string())), "{pairs:?}");
+    // 完全一致无对
+    assert!(word_pairs("今天讲熵减", "今天讲熵减").is_empty());
+}
+
+#[test]
+fn word_pairs_multiple_terms() {
+    let pairs = word_pairs("毕需掌握基本该念", "必须掌握基本概念");
+    assert!(pairs.contains(&("毕需".to_string(), "必须".to_string())));
+    assert!(pairs.contains(&("该".to_string(), "概".to_string())), "{pairs:?}");
+}
+
+#[test]
+fn word_pairs_identical_no_pairs() {
+    assert!(word_pairs("今天讲熵减", "今天讲熵减").is_empty());
+}
+
+#[test]
+fn word_pairs_overlong_safe() {
+    let long_a = "字".repeat(3000);
+    let long_b = "词".repeat(3000);
+    assert!(word_pairs(&long_a, &long_b).is_empty(), "超长护栏");
+}
+
+// ── record_adoption / candidates（采集与门槛）──
+
+#[test]
+fn record_aggregates_and_candidate_threshold() {
+    // Arrange
+    let mut store = AsrConfusionStore::default();
+    // Act：同对两次采纳 → count 2（达门槛）；单次噪声不入候选
+    store.record_adoption("毕需掌握", "必须掌握");
+    store.record_adoption("毕需掌握基本该念", "必须掌握基本概念");
+    store.record_adoption("随机噪词句子", "另一写法句子");
+    // Assert
+    let cands = store.candidates(10);
+    assert_eq!(cands.len(), 1, "仅达门槛的候选");
+    assert_eq!(cands[0].wrong, "毕需");
+    assert_eq!(cands[0].right, "必须");
+    assert_eq!(cands[0].count, 2);
+}
+
+// ── confirm / dismiss（确认制）──
+
+#[test]
+fn confirm_moves_pair_to_rules_and_hides_candidate() {
+    let mut store = AsrConfusionStore::default();
+    store.record_adoption("毕需掌握", "必须掌握");
+    store.record_adoption("毕需掌握", "必须掌握");
+    // Act：确认
+    assert!(store.confirm("毕需", "必须"));
+    // Assert：规则生效、候选消失、重复确认覆盖
+    assert_eq!(store.rules.len(), 1);
+    assert!(store.candidates(10).is_empty());
+    store.confirm("毕需", "必需");
+    assert_eq!(store.rules[0].to, "必需", "重复 from 覆盖=现场校准优先");
+}
+
+#[test]
+fn confirm_guards_empty_and_equal() {
+    let mut store = AsrConfusionStore::default();
+    assert!(!store.confirm("", "必须"));
+    assert!(!store.confirm("毕需", ""));
+    assert!(!store.confirm("同词", "同词"));
+}
+
+#[test]
+fn dismiss_hides_candidate_keeps_history() {
+    let mut store = AsrConfusionStore::default();
+    store.record_adoption("毕需掌握", "必须掌握");
+    store.record_adoption("毕需掌握", "必须掌握");
+    // Act
+    store.dismiss("毕需", "必须");
+    // Assert
+    assert!(store.candidates(10).is_empty());
+    assert!(store.rules.is_empty());
+}
+
+// ── apply_rules（共现才替换）──
+
+#[test]
+fn apply_requires_cooccurrence() {
+    let rules = vec![AsrRule { from: "毕需".into(), to: "必须".into() }];
+    // 语料无"必须"→ 不猜（可能是特有词形）
+    let no_corpus = apply_rules("毕需很重要", "全篇无此词", &rules);
+    assert_eq!(no_corpus, "毕需很重要");
+    // 语料有"必须"→ 替换
+    let with_corpus = apply_rules("毕需很重要", "必须与毕需同现", &rules);
+    assert_eq!(with_corpus, "必须很重要");
+}
+
+#[test]
+fn apply_longest_first_and_empty_safe() {
+    let rules = vec![
+        AsrRule { from: "毕需掌握".into(), to: "必须掌握".into() },
+        AsrRule { from: "毕需".into(), to: "必须".into() },
+    ];
+    let corpus = "必须掌握已经讲过了";
+    let out = apply_rules("毕需掌握与毕需", corpus, &rules);
+    // 长词先替换；剩余短词仍可命中（链式顺序语义，与 vocab 同哲学）
+    assert_eq!(out, "必须掌握与必须");
+    assert_eq!(apply_rules("内容", corpus, &[]), "内容");
+    assert_eq!(apply_rules("", corpus, &rules), "");
+}
+
+// ── JSON 持久化 ──
+
+#[test]
+fn save_load_roundtrip_and_missing_is_default() {
+    let dir = std::env::temp_dir().join(format!("entropy-asr-confusion-{}", std::process::id()));
+    let path = dir.join("asr_confusion.json");
+    let mut store = AsrConfusionStore::default();
+    store.record_adoption("毕需掌握", "必须掌握");
+    store.record_adoption("毕需掌握", "必须掌握");
+    store.confirm("毕需", "必须");
+    store.save(&path).unwrap();
+    let loaded = AsrConfusionStore::load(&path);
+    assert_eq!(loaded.rules, store.rules);
+    assert_eq!(loaded.dismissed, store.dismissed);
+    let missing = AsrConfusionStore::load(std::path::Path::new("C:/nonexistent/x.json"));
+    assert_eq!(missing, AsrConfusionStore::default());
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn remove_rule_works() {
+    let mut store = AsrConfusionStore::default();
+    store.confirm("毕需", "必须");
+    assert!(store.remove_rule("毕需"));
+    assert!(store.rules.is_empty());
+    assert!(!store.remove_rule("不存在"));
+}