fix(v0.14): 审查即修（词间空格/无效bbox/worker退出/悬空边/副作用）

Author: Aparencia

app/src-tauri/src/db_notes.rs

@@ -88,6 +88,14 @@ impl Db {
     /// 删除笔记；返回是否实际删除。
     pub fn delete_note(&self, id: i64) -> Result<bool> {
         self.with_conn(|conn| {
+            // v0.14 C3 审查（L5 悬空边）：笔记删除级联清理 knowledge_links 的
+            // target 引用——图谱/反查不出现指向已删除笔记的悬空边。先清引用
+            // 后删笔记：失败半态 = 反查少一条（可重挂），优于悬空边；单连接
+            // Mutex 串行执行无并发窗口（项目无事务先例，保持 with_conn 风格）
+            conn.execute(
+                "DELETE FROM knowledge_links WHERE target_type = 'note' AND target_id = ?1",
+                params![id],
+            )?;
             let affected = conn.execute("DELETE FROM notes WHERE id = ?1", params![id])?;
             Ok(affected > 0)
         })

app/src-tauri/src/engine_worker.rs

@@ -250,10 +250,12 @@ pub(crate) fn ocr_worker_loop(
                         };
                         (result, reply)
                     }
-                    // 外层 match 已分流 RecognizeLines（返回类型不同）——逻辑不可达
+                    // 外层 match 已分流 RecognizeLines（返回类型不同）——逻辑不可达；
+                    // 防御（审查 L2）：即使可达也不得以裸 return 退出主循环（会
+                    // 静默终止整个 OCR worker，后续请求全部失败）——跳过继续
                     OcrRequest::RecognizeLines { reply, .. } => {
                         let _ = reply.send(Err(AppError::Ocr("行级重识别请求分流失效".to_string())));
-                        return;
+                        continue;
                     }
                 };
                 if result.is_err() {

app/src-tauri/src/line_rec_engine.rs

@@ -35,8 +35,12 @@ pub fn is_suspect_line(text: &str, score: f32) -> bool {
 }
 
 /// 行图裁剪（纯函数）：bbox + padding → 裁剪图（越界 clamp）。
+///
+/// @ai-context: 空矩形防御（审查 M2 双保险）——非法 bbox（零宽高）不裁剪返回
+///              原图；调用方 rec_pipeline_on_blocks 已先过滤无效 bbox（无效
+///              不送识别），本检查兜底防未来调用方遗漏（原图送识别会以整屏
+///              结果静默替换碎片，污染落库数据）。
 pub fn crop_line(image: &RgbImage, bbox: &TextBox) -> RgbImage {
-    // 空矩形防御：非法 bbox（零宽高）不裁剪（返回原图——调用方按 1:1 索引忽略）
     if bbox.w <= 0.0 || bbox.h <= 0.0 {
         return image.clone();
     }
@@ -128,7 +132,11 @@ pub fn rec_pipeline_on_blocks(
     let suspects: Vec<usize> = blocks
         .iter()
         .enumerate()
-        .filter(|(_, b)| b.bbox.is_some() && is_suspect_line(&b.text, b.score))
+        .filter(|(_, b)| {
+            // 无效 bbox（零宽高）不裁剪不识别（审查 M2）——crop_line 对无效
+            // bbox 返回原图，若送识别会以整屏图结果静默替换碎片文本（落库污染）
+            b.bbox.is_some_and(|bb| bb.w > 0.0 && bb.h > 0.0) && is_suspect_line(&b.text, b.score)
+        })
         .map(|(i, _)| i)
         .collect();
     if suspects.is_empty() {

app/src-tauri/src/line_rec_engine_tests.rs

@@ -183,3 +183,22 @@ fn pipeline_all_healthy_no_rec_call() {
     // Assert：0 替换（无识别请求——crops 空）
     assert_eq!(replaced, 0);
 }
+
+#[test]
+fn invalid_bbox_never_sent_to_recognition() {
+    // Arrange：零宽 bbox 疑碎块 + 识别器返回整屏内容（审查 M2——原实现会把
+    //          整屏图送识别并静默替换碎片文本，污染落库）
+    let mut blocks = vec![blk("碎", 0.9, Some((10.0, 10.0, 0.0, 20.0)))];
+    let rec = FakeRec {
+        results: vec![LineRecResult { text: "整屏内容".to_string(), score: 0.9 }],
+        fail: false,
+    };
+    let img = RgbImage::from_pixel(100, 50, image::Rgb([0, 0, 0]));
+
+    // Act
+    let replaced = rec_pipeline_on_blocks(&rec, &img, &mut blocks, 0.5);
+
+    // Assert：无效 bbox 不裁剪不识别——块文本原样保留
+    assert_eq!(replaced, 0);
+    assert_eq!(blocks[0].text, "碎", "无效 bbox 块不得被整屏结果替换");
+}

app/src-tauri/src/note_filter_ocr.rs

@@ -177,17 +177,23 @@ fn to_line_input(b: &SessionOcrBlock) -> crate::line_merge::LineInput {
 }
 
 /// 两块合并（① 产物）：文本直拼（中文行内拼接）+ 得分均值 + bbox 并集。
+///
+/// @ai-context: ASCII 词间空格保持（审查 M1）——英文/数字 OCR 块 trim 后直拼会
+///              单词粘连（"Hello " + "World" → "HelloWorld"，空格信息已丢失
+///              不可恢复）；中文无词间空格不受影响。
 fn merge_two(a: &SessionOcrBlock, b: &SessionOcrBlock) -> SessionOcrBlock {
     let (ba, bb) = (a.bbox.unwrap(), b.bbox.unwrap());
     let x = ba.x.min(bb.x);
     let y = ba.y.min(bb.y);
     let x2 = (ba.x + ba.w).max(bb.x + bb.w);
     let y2 = (ba.y + ba.h).max(bb.y + bb.h);
+    let (a_t, b_t) = (a.text.trim(), b.text.trim());
+    let gap = if ascii_gap(a_t, b_t) { " " } else { "" };
     SessionOcrBlock {
         id: a.id,
         session_id: a.session_id,
         timestamp_ms: a.timestamp_ms,
-        text: format!("{}{}", a.text.trim(), b.text.trim()),
+        text: format!("{}{}{}", a_t, gap, b_t),
         score: (a.score + b.score) / 2.0,
         region: a.region.clone(),
         region_kind: a.region_kind.clone(),
@@ -196,6 +202,13 @@ fn merge_two(a: &SessionOcrBlock, b: &SessionOcrBlock) -> SessionOcrBlock {
     }
 }
 
+/// ASCII 词间空格判定（审查 M1）：a 尾字符与 b 首字符均为 ASCII 字母/数字 →
+/// 需补空格（英文/数字行合并场景；中文首尾字符非 ASCII 不触发）。
+fn ascii_gap(a: &str, b: &str) -> bool {
+    a.chars().last().is_some_and(|c| c.is_ascii_alphanumeric())
+        && b.chars().next().is_some_and(|c| c.is_ascii_alphanumeric())
+}
+
 /// 块 → 净化行（trim 文本/bbox）。
 fn to_purified(b: &SessionOcrBlock) -> PurifiedLine {
     PurifiedLine {

app/src-tauri/src/note_filter_ocr_tests.rs

@@ -242,3 +242,31 @@ fn bbox_shift_keeps_both_frames() {
     // Assert：两屏都输出（位置位移 → 新屏，不误并）
     assert_eq!(result.ocr_body, vec!["标题内容".to_string(), "标题内容更多".to_string()]);
 }
+
+// ── 审查 M1 回归：ASCII 词间空格保持 ────────────────────────────
+
+#[test]
+fn merge_two_keeps_ascii_word_gap() {
+    // Arrange：英文行合并（"Hello " + "World"）——trim 后直拼会单词粘连
+    let a = blk_boxed(1_000, "Hello ", 0.9, 0.0, 0.0, 50.0, 20.0);
+    let b = blk_boxed(1_000, "World", 0.9, 50.0, 0.0, 50.0, 20.0);
+
+    // Act
+    let merged = super::merge_two(&a, &b);
+
+    // Assert：补词间空格（空格信息在 trim 前已存在，恢复语义）
+    assert_eq!(merged.text, "Hello World");
+}
+
+#[test]
+fn merge_two_chinese_joins_without_gap() {
+    // Arrange：中文行合并——无词间空格语义，直拼不受影响（零回归）
+    let a = blk_boxed(1_000, "红色代表", 0.9, 0.0, 0.0, 80.0, 20.0);
+    let b = blk_boxed(1_000, "热情", 0.9, 80.0, 0.0, 40.0, 20.0);
+
+    // Act
+    let merged = super::merge_two(&a, &b);
+
+    // Assert：中文直拼无空格
+    assert_eq!(merged.text, "红色代表热情");
+}

app/src/components/GroupSidebar.tsx

@@ -188,22 +188,25 @@ export default function GroupSidebar({
 
   /** 访问组：写最近使用（LRU）+ 过滤切换（toggle=组行单击互斥；recent=直达） */
   const handleGroupSelect = (g: NoteGroup, toggle: boolean) => {
-    setRecentIds((cur) => {
-      const next = pushRecentGroup(cur, g.id);
-      writeRecentGroupIds(window.localStorage, next);
-      return next;
-    });
+    setRecentIds((cur) => pushRecentGroup(cur, g.id));
     onGroupFilterChange(toggle ? (groupFilter === g.id ? null : g.id) : g.id);
   };
 
   const toggleFolded = (kind: string) => {
-    setFolded((cur) => {
-      const next = { ...cur, [kind]: !cur[kind] };
-      writeFolded(window.localStorage, kind, next[kind]);
-      return next;
-    });
+    setFolded((cur) => ({ ...cur, [kind]: !cur[kind] }));
   };
 
+  // v0.14 C1 审查（L6）：setState updater 保持纯函数——localStorage 副作用移出，
+  // 经 useEffect 在 state 落定后同步（StrictMode 双调用/并发渲染下行为确定）；
+  // 挂载后首写与初始化值相同，幂等无副作用
+  useEffect(() => {
+    writeRecentGroupIds(window.localStorage, recentIds);
+  }, [recentIds]);
+  useEffect(() => {
+    // folded 键数固定（GROUP_SECTIONS），全量写量级忽略
+    Object.entries(folded).forEach(([kind, value]) => writeFolded(window.localStorage, kind, value));
+  }, [folded]);
+
   /** 拖拽归组（组行 drop；noteId 来自 NoteListView 行 dragStart） */
   const handleGroupDrop = (g: NoteGroup, e: React.DragEvent) => {
     e.preventDefault();