fix(review): 新增代码审查五处修复

Author: Aparencia

app/src-tauri/src/commands_session.rs

@@ -348,7 +348,10 @@ pub fn course_of(title: &str) -> String {
     while i + 1 < chars.len() {
         if chars[i] == '第' {
             let mut j = i + 1;
-            while j < chars.len() && (chars[j].is_ascii_digit() || is_cjk_num(chars[j])) {
+            // 中文数字判定复用 series_detect（单一来源，防两处漂移）
+            while j < chars.len()
+                && (chars[j].is_ascii_digit() || crate::series_detect::is_cjk_num_char(chars[j]))
+            {
                 j += 1;
             }
             // "第X章/节/讲/课/部分" → 前缀即课程键
@@ -361,11 +364,6 @@ pub fn course_of(title: &str) -> String {
     t.to_string()
 }
 
-/// 中文数字判定（课程前缀匹配用）。
-fn is_cjk_num(c: char) -> bool {
-    "零〇一二三四五六七八九十百".contains(c)
-}
-
 /// 课程分组（会话列表按课程键分组，组内新→旧；v0.7.1：组内携带转化状态标记）。
 #[derive(Debug, Clone, serde::Serialize)]
 #[serde(rename_all = "camelCase")]

app/src-tauri/src/commands_speaker.rs

@@ -37,17 +37,35 @@ pub struct SpeakerAnalysisResult {
 }
 
 /// 会话讲者切换分析（弱化版说话人分离；幂等懒加载）。
+///
+/// @ai-context: 异步命令 + spawn_blocking——分析含模型加载（~1s）+ 逐段
+///              embedding（百段 <2s，千段长会话可能 10s+），不得占用异步
+///              运行时线程（审查 B11：同步命令在长会话上阻塞 IPC 吞吐）。
 #[tauri::command]
-pub fn analyze_session_speakers(
+pub async fn analyze_session_speakers(
     state: State<'_, AppState>,
     session_id: i64,
 ) -> Result<SpeakerAnalysisResult, String> {
     if session_id <= 0 {
         return Err("无效的会话 id".to_string());
     }
+    let db = state.db.clone();
+    let model_dir = state.model_dir.clone();
+    let data_dir = state.data_dir.clone();
+    tauri::async_runtime::spawn_blocking(move || analyze_speakers_impl(db, model_dir, data_dir, session_id))
+        .await
+        .map_err(|e| format!("讲者分析任务失败: {}", e))?
+}
+
+/// 分析实现（阻塞线程内执行；与命令层解耦便于独立演进）。
+fn analyze_speakers_impl(
+    db: crate::db::Db,
+    model_dir: std::path::PathBuf,
+    data_dir: std::path::PathBuf,
+    session_id: i64,
+) -> Result<SpeakerAnalysisResult, String> {
     // 1) 幂等：已有分析结果（SpeakerChange 事件）→ 直接返回
-    let existing = state
-        .db
+    let existing = db
         .list_events_by_kind(session_id, EventKind::SpeakerChange)
         .map_err(|e| e.to_string())?;
     if !existing.is_empty() {
@@ -68,17 +86,14 @@ pub fn analyze_session_speakers(
         });
     }
     // 2) 模型缺失 → 未启用（前端提示——诚实降级，不阻断）
-    let Some(model_path) = speaker_engine::speaker_model_path(&state.model_dir) else {
+    let Some(model_path) = speaker_engine::speaker_model_path(&model_dir) else {
         return Ok(SpeakerAnalysisResult { enabled: false, changes: Vec::new() });
     };
     // 3) 音频 + 段边界（端点断句产出 = 语音段）
-    let wav_path = state
-        .data_dir
-        .join("session-audio")
-        .join(format!("{}.wav", session_id));
+    let wav_path = data_dir.join("session-audio").join(format!("{}.wav", session_id));
     let wave = sherpa_onnx::Wave::read(&wav_path.to_string_lossy())
         .ok_or_else(|| "会话音频缺失（实时捕获未落盘或已清理）".to_string())?;
-    let segments = state.db.list_segments(session_id).map_err(|e| e.to_string())?;
+    let segments = db.list_segments(session_id).map_err(|e| e.to_string())?;
     if segments.is_empty() {
         return Ok(SpeakerAnalysisResult { enabled: true, changes: Vec::new() });
     }
@@ -105,7 +120,7 @@ pub fn analyze_session_speakers(
     // 5) 相邻余弦判定（纯函数）→ 落库 → 返回
     let changes = detect_speaker_changes(&speech);
     for c in &changes {
-        let _ = state.db.add_event(&NewSessionEvent {
+        let _ = db.add_event(&NewSessionEvent {
             session_id,
             kind: EventKind::SpeakerChange,
             timestamp_ms: c.time_ms,

app/src-tauri/src/live_session_frame.rs

@@ -203,6 +203,12 @@ pub fn run_screen_worker(
                             }
                         }
                     }
+                    // v0.7.2（REQ-151）：暂停态也探测播放器信息（时间文本仍在画面）——
+                    // 会话开始时视频已暂停的场景，时长/集号识别不因此缺席
+                    if last_info_probe_at.elapsed() >= Duration::from_secs(10) {
+                        last_info_probe_at = Instant::now();
+                        probe_player_info(&app, &engines, &session_info, &roi_tracker, &latest_frame);
+                    }
                 }
             }
             std::thread::sleep(Duration::from_millis(WORKER_POLL_MS));
@@ -354,61 +360,7 @@ pub fn run_screen_worker(
             // 失败 → 静默跳过（诚实：不猜不填；下轮再试）
             if last_info_probe_at.elapsed() >= Duration::from_secs(10) {
                 last_info_probe_at = Instant::now();
-                let mut probe =
-                    latest_frame.lock().ok().and_then(|g| g.clone()).unwrap_or(LatestCapturedFrame {
-                        timestamp_ms: 0,
-                        bgraw: Vec::new(),
-                        width: 0,
-                        height: 0,
-                    });
-                if !probe.bgraw.is_empty() {
-                    if let Some(rect) = roi_tracker.playback_rect() {
-                        let w = probe.width as i32;
-                        let h = probe.height as i32;
-                        let q = crate::capture::frame_diff::Rect {
-                            left: rect.left.clamp(0, w),
-                            top: rect.top.clamp(0, h),
-                            right: rect.right.clamp(0, w),
-                            bottom: rect.bottom.clamp(0, h),
-                        };
-                        if q.width() > 0 && q.height() > 0 {
-                            crate::capture::frame_diff::crop_frame(
-                                &mut probe.bgraw,
-                                &mut probe.width,
-                                &mut probe.height,
-                                Some(&q),
-                            );
-                        }
-                    }
-                    if !probe.bgraw.is_empty() {
-                        // P4：OCR 输入缩小（播放器 UI 文字大，质量无损）
-                        crate::capture::frame_diff::downscale_bgra(
-                            &mut probe.bgraw,
-                            &mut probe.width,
-                            &mut probe.height,
-                            960,
-                        );
-                        if let Some(img) = crate::region_ocr::bgra_to_rgb_image(
-                            &probe.bgraw,
-                            probe.width,
-                            probe.height,
-                        ) {
-                            if let Ok(blocks) = engines.recognize_image(img) {
-                                let text = blocks
-                                    .iter()
-                                    .map(|b| b.text.as_str())
-                                    .collect::<Vec<_>>()
-                                    .join(" ");
-                                if session_info.observe_player_text(&text) {
-                                    let _ = app.emit(
-                                        "live:session-info",
-                                        session_info.snapshot(),
-                                    );
-                                }
-                            }
-                        }
-                    }
-                }
+                probe_player_info(&app, &engines, &session_info, &roi_tracker, &latest_frame);
             }
         }
         // 诊断：每 15s 打印采样统计（会话无 OCR 时定位失败阶段；静默失败可见化）
@@ -439,6 +391,62 @@ pub fn run_screen_worker(
     eprintln!("[ScreenWorker] 屏幕采样线程退出（会话 {}）", session_id);
 }
 
+/// 播放器信息探测（REQ-151，v0.7.2）：播放器区域 OCR 文本（时间对/分P）→
+/// 会话信息更新 → 值变化才 emit live:session-info（防 IPC 风暴）。
+///
+/// @ai-context: 主采样循环与自动暂停轻量轮询共用——暂停时播放器时间文本仍
+///              在画面，时长/集号识别不因暂停缺席（10s 节流由调用方控制）；
+///              无播放区域/OCR 失败 → 静默跳过（诚实：不猜不填，下轮再试）。
+fn probe_player_info(
+    app: &tauri::AppHandle,
+    engines: &crate::engine::EnginePool,
+    session_info: &crate::session_info::SessionInfoCollector,
+    roi_tracker: &crate::region_tracker::RoiTracker,
+    latest_frame: &Arc<Mutex<Option<LatestCapturedFrame>>>,
+) {
+    let mut probe = latest_frame
+        .lock()
+        .ok()
+        .and_then(|g| g.clone())
+        .unwrap_or(LatestCapturedFrame { timestamp_ms: 0, bgraw: Vec::new(), width: 0, height: 0 });
+    if probe.bgraw.is_empty() {
+        return;
+    }
+    if let Some(rect) = roi_tracker.playback_rect() {
+        let w = probe.width as i32;
+        let h = probe.height as i32;
+        let q = crate::capture::frame_diff::Rect {
+            left: rect.left.clamp(0, w),
+            top: rect.top.clamp(0, h),
+            right: rect.right.clamp(0, w),
+            bottom: rect.bottom.clamp(0, h),
+        };
+        if q.width() > 0 && q.height() > 0 {
+            crate::capture::frame_diff::crop_frame(
+                &mut probe.bgraw,
+                &mut probe.width,
+                &mut probe.height,
+                Some(&q),
+            );
+        }
+    }
+    if probe.bgraw.is_empty() {
+        return;
+    }
+    // P4：OCR 输入缩小（播放器 UI 文字大，质量无损）
+    crate::capture::frame_diff::downscale_bgra(&mut probe.bgraw, &mut probe.width, &mut probe.height, 960);
+    let Some(img) =
+        crate::region_ocr::bgra_to_rgb_image(&probe.bgraw, probe.width, probe.height)
+    else {
+        return;
+    };
+    let Ok(blocks) = engines.recognize_image(img) else { return };
+    let text = blocks.iter().map(|b| b.text.as_str()).collect::<Vec<_>>().join(" ");
+    if session_info.observe_player_text(&text) {
+        let _ = app.emit("live:session-info", session_info.snapshot());
+    }
+}
+
 /// 单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
 #[cfg(test)]
 #[path = "live_session_frame_tests.rs"]

app/src-tauri/src/live_session_loop.rs

@@ -161,6 +161,9 @@ pub(crate) fn run_audio_loop(
                 );
                 // 重建流（reset 预留给复用场景：清句音频/状态，热词重读）
                 ctx.asr_engine.reset();
+                // REQ-154（v0.7.2 S-2）：暂停边沿重置语速基准——恢复后首段与
+                // 暂停前比较会跨暂停区间误判语速骤变（暂停时长不计入段间）
+                last_speech_rate = None;
                 let _ = ctx.db.add_event(&crate::session_events::NewSessionEvent::simple(
                     ctx.session_id,
                     crate::session_events::EventKind::Pause,

app/src-tauri/src/series_detect.rs

@@ -19,26 +19,36 @@ pub struct SeriesInfo {
     pub episode: Option<u32>,
 }
 
-/// 平台后缀剥离表（窗口标题常见形态；命中剥离，未命中原样返回）。
-const PLATFORM_SUFFIXES: &[&str] = &[
-    "_哔哩哔哩_bilibili",
-    " - YouTube",
-    " - 腾讯视频",
-    "_爱奇艺",
-    " - 优酷",
-    " - 芒果TV",
-    " - 西瓜视频",
-    " - 抖音",
+/// 平台后缀表（单一来源：normalize_title 剥离与 session_info 平台识别共用——
+/// 剥离的后缀即平台证据，两处维护会漂移）。
+const PLATFORM_SUFFIXES: &[(&str, &str)] = &[
+    ("_哔哩哔哩_bilibili", "哔哩哔哩"),
+    (" - YouTube", "YouTube"),
+    (" - 腾讯视频", "腾讯视频"),
+    ("_爱奇艺", "爱奇艺"),
+    (" - 优酷", "优酷"),
+    (" - 芒果TV", "芒果TV"),
+    (" - 西瓜视频", "西瓜视频"),
+    (" - 抖音", "抖音"),
 ];
 
+/// 平台识别（REQ-151：窗口标题后缀 → 平台显示名；未知 → None）。
+pub fn detect_platform(title: &str) -> Option<&'static str> {
+    let t = title.trim();
+    PLATFORM_SUFFIXES
+        .iter()
+        .find(|(suffix, _)| t.ends_with(suffix))
+        .map(|(_, name)| *name)
+}
+
 /// 模式 2 集号后缀（中文"第X"式；**不含"章节讲课部分"**——course_of 的
 /// "第X章"分组语义保留现状零回归，series 检测只管集/话/期/回）。
 const EPISODE_UNITS: &str = "集话期回";
 
 /// 标题预处理：剥离平台后缀（窗口标题污染源，必须先剥离再识别系列）。
 pub fn normalize_title(title: &str) -> String {
     let t = title.trim();
-    for suffix in PLATFORM_SUFFIXES {
+    for (suffix, _) in PLATFORM_SUFFIXES {
         if let Some(rest) = t.strip_suffix(suffix) {
             let rest = rest.trim();
             if !rest.is_empty() {

app/src-tauri/src/session_info.rs

@@ -42,32 +42,9 @@ pub struct SessionInfo {
     pub total_episodes: Option<u32>,
 }
 
-/// 平台识别（纯函数）：窗口标题后缀 → 平台显示名；未知 → None。
-///
-/// @ai-context: 与 series_detect::normalize_title 同后缀表（保持一致——剥离的
-///              后缀即平台证据）；浏览器窗口无平台后缀时诚实 None（不猜）。
-pub fn detect_platform(title: &str) -> Option<&'static str> {
-    let t = title.trim();
-    if t.ends_with("_哔哩哔哩_bilibili") {
-        Some("哔哩哔哩")
-    } else if t.ends_with(" - YouTube") {
-        Some("YouTube")
-    } else if t.ends_with(" - 腾讯视频") {
-        Some("腾讯视频")
-    } else if t.ends_with("_爱奇艺") {
-        Some("爱奇艺")
-    } else if t.ends_with(" - 优酷") {
-        Some("优酷")
-    } else if t.ends_with(" - 芒果TV") {
-        Some("芒果TV")
-    } else if t.ends_with(" - 西瓜视频") {
-        Some("西瓜视频")
-    } else if t.ends_with(" - 抖音") {
-        Some("抖音")
-    } else {
-        None
-    }
-}
+/// 平台识别（纯函数）：复用 series_detect 单一来源（标题后缀表统一维护，
+/// 剥离的后缀即平台证据——两处维护会漂移）。
+pub use crate::series_detect::detect_platform;
 
 /// 时间文本解析（`mm:ss` 或 `hh:mm:ss` → 秒；非时间形态 None）。
 ///

app/src/components/LiveActivityPanel.tsx

@@ -83,21 +83,27 @@ function fmtDur(secs: number): string {
  *              现状整句挤在一行灰斜里越滚越长；按句读切分后每句一行，全部可见。
  *              句读保留在句尾；无句读尾段为"残余"（调用方加 … 表示仍在识别）。
  *              不切英文句点（Mr./U.S. 缩写防误切）与逗号（句内成分不拆行）。
+ *              连续句读（"结束。。"）切出的纯标点段过滤（防垃圾行）。
  */
 function splitBySentence(text: string): string[] {
   const parts: string[] = [];
   let buf = "";
   for (const ch of text) {
     buf += ch;
     if ("。！？!?…".includes(ch)) {
-      parts.push(buf);
+      if (hasText(buf)) parts.push(buf);
       buf = "";
     }
   }
-  if (buf.trim().length > 0) parts.push(buf);
+  if (hasText(buf)) parts.push(buf);
   return parts;
 }
 
+/** 段是否含实质内容（过滤纯标点/空白段——连续句读切出的垃圾段不展示） */
+function hasText(seg: string): boolean {
+  return seg.trim().length > 0 && !/^[。！？!?…\s]+$/.test(seg);
+}
+
 export default function LiveActivityPanel({ sessionId }: { sessionId?: number | null }) {
   const [tab, setTab] = useState<"transcript" | "ocr">("transcript");
   // 状态机（简要徽标文本）