fix(td): 偿还 TD-19-F/G 与 TD-28-A/B（暂停图标白像素判定/OCR 检索全库化/质量分滑动窗口/增量合并索引）

Author: Aparencia

app/src-tauri/src/chapter_note.rs

@@ -128,25 +128,35 @@ pub fn assemble_hybrid_note(
 /// @ai-context: 近似口径——调用方传**净化后**块可得精确分；本函数接受原料块
 ///              （junk/低分块压分 → 门控更严，宁缺毋滥符合 spec 哲学）；无
 ///              行合并上下文时 merged_lines 取块文本（块即行保守近似）。
+/// @ai-context: TD-2026-08-28-A 偿还——原实现每章节全量过滤 blocks（O(C×B)）+
+///              每块文本克隆；改为块按时间戳排序一次 + 章节有序滑动窗口
+///              （partition_point 定界），整体 O(B log B + C log B)，章节间隙块
+///              语义不变（不属于任何窗口——与原 filter 行为一致）。
 pub fn chapter_quality_scores(
     chapters: &[ChapterBoundary],
     blocks: &[SessionOcrBlock],
 ) -> Vec<f32> {
     let mut bounds: Vec<&ChapterBoundary> = chapters.iter().collect();
     bounds.sort_by_key(|c| c.time_ms);
+    if bounds.is_empty() {
+        return Vec::new();
+    }
+    // 画面块按时间戳排序（只一次——窗口定界用；region 过滤与原实现一致）
+    let mut full: Vec<&SessionOcrBlock> = blocks.iter().filter(|bl| bl.region == "full").collect();
+    full.sort_by_key(|bl| bl.timestamp_ms);
+    // 起始游标跳过最早章节之前的块（与原实现 timestamp >= b.time 语义一致）
+    let mut start = full.partition_point(|bl| bl.timestamp_ms < bounds[0].time_ms);
     bounds
         .iter()
         .enumerate()
-        .map(|(i, b)| {
+        .map(|(i, _b)| {
             let next_ms = bounds.get(i + 1).map(|n| n.time_ms);
-            let window: Vec<&SessionOcrBlock> = blocks
-                .iter()
-                .filter(|bl| {
-                    bl.region == "full"
-                        && bl.timestamp_ms >= b.time_ms
-                        && next_ms.is_none_or(|n| bl.timestamp_ms < n)
-                })
-                .collect();
+            // 窗口内块（时间序连续——章节有序，块有序，滑动定界无需重扫）
+            let end = full.partition_point(|bl| {
+                next_ms.is_none_or(|n| bl.timestamp_ms < n)
+            });
+            let window = &full[start..end];
+            start = end;
             if window.is_empty() {
                 return 0.0;
             }

app/src-tauri/src/db_ocr_search.rs

@@ -40,19 +40,23 @@ pub struct OcrBlockHit {
     pub screen_last_ms: Option<u64>,
 }
 
-/// 会话检索范围上限（与旧实现 list_sessions(None, 500, 0) 同口径）。
-const SESSION_SCOPE: i64 = 500;
-
+/// 会话检索范围（TD-2026-08-19-G 偿还：原 500 上限静默截断已移除——全库检索，
+/// 结果由 limit 有界；本常量删除，保留占位注释防回归引入）。
+///
+/// @ai-context: 曾经 const SESSION_SCOPE: i64 = 500；若未来重新加上限，必须
+///              在 UI 暴露"仅搜最近 N 会话"并明示（静默截断是 2026-08-19-G 根因）。
 /// 检索会话 OCR 块（REQ-133）：关键词 → 命中块 + 会话标题 + 图路径 + 屏区间。
 ///
 /// @ai-context: 只搜画面要点（region=full——字幕区是转写冗余，搜字幕用段搜索）；
 ///              大小写不敏感（LIKE 对 ASCII 天然忽略大小写，CJK 无大小写概念）；
 ///              结果有界（100 条防超大 payload）。
-/// @ai-context: M2 修复——单条 SQL 语义等价于旧逐会话循环：
-///              ① 会话范围 = 最近 500 会话（started_at DESC, id DESC 子查询）；
-///              ② 屏区间 = 同会话同屏全部块（含字幕块，旧实现不过滤 region）
+/// @ai-context: M2 修复——单条 SQL 语义等价于旧逐会话循环（无会话范围上限；
+///              屏区间 = 同会话同屏全部块（含字幕块，旧实现不过滤 region）
 ///              的 min/max 时间戳（LEFT JOIN 聚合子查询）；
-///              ③ 排序 = 会话倒序 + 块时间升序（与旧双层循环一致）。
+///              排序 = 会话倒序 + 块时间升序（与旧双层循环一致）。
+/// @ai-context: TD-2026-08-19-G 偿还——原 SESSION_SCOPE=500 静默截断：会话数
+///              >500 时旧会话命中被漏（用户"搜不到"无从感知）；移除上限改全库
+///              检索（本地 SQLite 万行级 + 结果 LIMIT 100 有界，无性能顾虑）。
 /// @param data_dir - 应用数据目录（图存在性校验；None 时 image_path 恒 None）
 pub fn search_ocr_blocks(
     db: &Db,
@@ -83,13 +87,10 @@ pub fn search_ocr_blocks(
              ) sr ON sr.session_id = b.session_id AND sr.screen_id = b.screen_id
              WHERE b.region = 'full'
                AND b.text LIKE ?1 ESCAPE '\\'
-               AND b.session_id IN (
-                   SELECT id FROM sessions ORDER BY started_at DESC, id DESC LIMIT ?2
-               )
              ORDER BY s.started_at DESC, s.id DESC, b.timestamp_ms ASC
-             LIMIT ?3",
+             LIMIT ?2",
         )?;
-        let rows = stmt.query_map(params![pattern, SESSION_SCOPE, limit as i64], |row| {
+        let rows = stmt.query_map(params![pattern, limit as i64], |row| {
             Ok(OcrBlockHit {
                 ocr_block_id: row.get(0)?,
                 session_id: row.get(1)?,
@@ -218,6 +219,29 @@ mod tests {
         assert_eq!(search_ocr_blocks(&db, None, "关键词", 3).unwrap().len(), 3);
     }
 
+    #[test]
+    fn search_beyond_500_sessions_not_silently_truncated() {
+        // TD-2026-08-19-G 回归：原 SESSION_SCOPE=500 静默截断——第 501+ 会话的
+        // 命中被漏（用户"搜不到"无感知）；移除上限后全库命中
+        let db = Db::open(":memory:").unwrap();
+        // Arrange：造 501 会话，命中关键词放在**最早**（第 1 个）会话
+        let mut hit_sid = 0;
+        for i in 0..501 {
+            let s = db.create_session(&NewSession {
+                title: format!("会话{}", i), source_window: None, profile: None, kind: None,
+            }).unwrap();
+            if i == 0 {
+                add_block(&db, s.id, 1000, "老会话目标词", "full", None);
+                hit_sid = s.id;
+            }
+        }
+        // Act
+        let hits = search_ocr_blocks(&db, None, "目标词", 10).unwrap();
+        // Assert：命中（旧实现此用例必失败——第 1 会话不在最近 500 之内）
+        assert_eq!(hits.len(), 1);
+        assert_eq!(hits[0].session_id, hit_sid);
+    }
+
     #[test]
     fn search_returns_screen_range_across_regions() {
         // Arrange：同屏含 full 块(2000) 与 subtitle 块(500/3000)——

app/src-tauri/src/incremental_merge.rs

@@ -52,14 +52,26 @@ fn position_stable(a: &ScreenFrame, b: &ScreenFrame) -> bool {
 
 /// 跨帧增量合并：顺序扫描——后帧包含前帧且位置稳定 → 合并（文本取后帧）；
 /// 否则新屏（翻页）。输入须按时间序（调用方保证）。
+///
+/// @ai-context: TD-2026-08-28-B 偿还——原实现每帧 `frames.iter().find(p.id==cur.id)`
+///              线性回查 O(n²)；改为预建 id→帧索引（HashMap），回查 O(1)，
+///              整体 O(n)。纯函数零副作用（输入不变）。
 pub fn merge_incremental(frames: &[ScreenFrame]) -> Vec<MergedScreen> {
     let mut out: Vec<MergedScreen> = Vec::new();
+    // 帧索引（首帧 id → 帧；id 唯一性由调用方保证——同屏帧集）
+    let by_id: std::collections::HashMap<u64, &ScreenFrame> =
+        frames.iter().map(|f| (f.id, f)).collect();
     for f in frames {
         let Some(cur) = out.last_mut() else {
             out.push(MergedScreen { id: f.id, text: f.text.clone() });
             continue;
         };
-        if text_contains(&cur.text, &f.text) && position_stable(frames.iter().find(|p| p.id == cur.id).unwrap_or(f), f) {
+        if text_contains(&cur.text, &f.text)
+            && position_stable(
+                by_id.get(&cur.id).copied().unwrap_or(f),
+                f,
+            )
+        {
             // 同屏增量：文本取后帧（更完整），屏号保持首帧
             cur.text = f.text.clone();
         } else {

app/src-tauri/src/player_behavior.rs

@@ -56,9 +56,12 @@ pub fn detect_player_action(frame: &RgbImage) -> Option<PlayerAction> {
 ///
 /// @ai-context: 播放器暂停态 = 视频暗遮罩 + 中央大图标（白三角/双竖条），
 ///              用中央区域颜色统计近似：中央区暗像素占比高（暗遮罩/黑圆盘）
-///              且存在中等占比亮像素（白色图标）→ 判定暂停。
-/// @ai-context: 阈值偏严防假信号：暗色视频场景无图标时 bright 占比过低不判；
+///              且存在中等占比**白色**像素（图标是白色，非任意亮色）→ 判定暂停。
+/// @ai-context: 阈值偏严防假信号：暗色视频场景无图标时白像素占比过低不判；
 ///              全亮画面 dark 不足不判；字幕在画面底部、不落在中央区（不干扰）。
+/// @ai-context: TD-2026-08-19-F 偿还——原实现只判"亮像素"（lum>210），暗底+中央
+///              亮色内容（如暗色视频里发光的彩色标题/物体）会误报为暂停；
+///              图标白 = 高亮 + 低饱和（R≈G≈B，±40 容差），彩色亮块不再命中。
 /// @ai-context: 输入为 RGB 字节（image::RgbImage.as_raw()）；w/h 为像素尺寸；
 ///              输入异常（尺寸过小/字节不足）→ false（防御）。
 pub fn detect_pause_icon(pixels: &[u8], w: u32, h: u32) -> bool {
@@ -71,19 +74,25 @@ pub fn detect_pause_icon(pixels: &[u8], w: u32, h: u32) -> bool {
     let x0 = w / 2 - cw / 2;
     let y0 = h / 2 - ch / 2;
     let mut dark = 0u32;
-    let mut bright = 0u32;
+    let mut white = 0u32;
     let mut total = 0u32;
     for y in y0..(y0 + ch).min(h) {
         for x in x0..(x0 + cw).min(w) {
             let i = ((y * w + x) * 3) as usize;
+            let r = pixels[i] as u32;
+            let g = pixels[i + 1] as u32;
+            let b = pixels[i + 2] as u32;
             // 近似亮度（Rec.601 整数版，0-255）
-            let lum = (pixels[i] as u32 * 299 + pixels[i + 1] as u32 * 587 + pixels[i + 2] as u32 * 114)
-                / 1000;
+            let lum = (r * 299 + g * 587 + b * 114) / 1000;
             if lum < 45 {
                 dark += 1;
             }
+            // 图标白：高亮 + 低饱和（R≈G≈B ±40——白三角/双竖条；彩色亮块不算）
             if lum > 210 {
-                bright += 1;
+                let (r, g, b) = (r as i32, g as i32, b as i32);
+                if (r - g).abs() < 40 && (g - b).abs() < 40 && (r - b).abs() < 40 {
+                    white += 1;
+                }
             }
             total += 1;
         }
@@ -92,8 +101,8 @@ pub fn detect_pause_icon(pixels: &[u8], w: u32, h: u32) -> bool {
         return false;
     }
     let dark_ratio = dark as f32 / total as f32;
-    let bright_ratio = bright as f32 / total as f32;
-    dark_ratio >= 0.55 && (0.02..=0.6).contains(&bright_ratio)
+    let white_ratio = white as f32 / total as f32;
+    dark_ratio >= 0.55 && (0.015..=0.35).contains(&white_ratio)
 }
 
 /// 采样间隔按播放速率缩放（M17，纯函数）。

app/src-tauri/src/player_behavior_tests.rs

@@ -91,6 +91,27 @@ fn tiny_frame_returns_none() {
     assert!(detect_player_action(&frame).is_none());
 }
 
+#[test]
+fn dark_scene_with_colored_glow_not_detected() {
+    // TD-2026-08-19-F 回归：暗底 + 中央亮**彩色**内容（发光红点/橙标题）——
+    // 修复前被判为暂停（bright 满足），修复后白色判据拒绝
+    let frame = RgbImage::from_fn(240, 135, |x, y| {
+        let cx = 120i32;
+        let cy = 67i32;
+        let dx = x as i32 - cx;
+        let dy = y as i32 - cy;
+        if dx * dx + dy * dy <= 15 * 15 {
+            Rgb([255, 40, 40]) // 中央亮红圆（饱和度极高，非白）
+        } else {
+            Rgb([30, 30, 30]) // 暗底
+        }
+    });
+    // Act
+    let action = detect_player_action(&frame);
+    // Assert：彩色亮内容不是暂停图标 → 不判
+    assert!(action.is_none());
+}
+
 #[test]
 fn speed_scaled_interval_boundaries() {
     // Assert：1.0x → base；2.0x → base/2；0.5x → base*2（上限保护）