fix(notes): 用户编排痕迹接管自动路由空组（写路径置位+谓词存量双闸）

批7 审查 P2-7：空组自动清理谓词原先只看 source/route_overridden，
改名/置色/置顶/手排等用户编排动作不置位 → 被接管空组被静默删除，
与 REQ-315 冲突。双保险：
- 写侧同权：rename_group/update_group_color/update_note_group_pin/
  save_group_order 与路由改判同权置 route_overridden=1（仅 route/series
  产物；单条 UPDATE 内 CASE / 快照同事务完成，Why：用户编排痕迹=接管，
  不再自动清理）；
- 谓词存量防护：额外要求 pin=0 ∧ color IS NULL ∧ 无 note_group_orders 行
  （兜底修复前已被编排但 override 仍 0 的存量行）；
测试固化反转：置顶/手排空组不再被清；存量痕迹直写 SQL 模拟仍挡；
改名仅留 flag 也挡；写路径置位断言覆盖。

Author: Aparencia

app/src-tauri/src/db_note_group_clean.rs

@@ -3,9 +3,12 @@
 //! @ai-context: 用户问题 8——自动路由产生的空组堆积在组侧栏（手动删组需两步
 //!              确认，空路由组无治理出口）。本模块提供「仅自动路由空组自动
 //!              删除」的共享判定与删除：
-//!              ① 谓词 = note_groups.source IN ('route','series')（自动路由/系列
-//!                 检测产物）且 route_overridden = 0（用户改判过=修改即记忆，
-//!                 REQ-198 永不自动删）；source='manual' 手动建组天然不在白名单。
+//!              ① 谓词 = 自动路由/系列产物（source IN ('route','series')）且零
+//!                 用户编排痕迹——主闸 route_overridden = 0（用户改判/改名/
+//!                 置色/置顶/手排后置 1，批 7 审查 P2-7 修复：用户编排=接管
+//!                 该组，REQ-198 永不自动删）；存量副闸 pin=0 ∧ color IS NULL
+//!                 ∧ 无 note_group_orders 行（兜底修复前已被编排但 override
+//!                 仍 0 的存量行）；source='manual' 手动建组天然不在白名单。
 //!              ② 残留全零 = notes + fragments + flashcards + settlements +
 //!                 contracts 五类计数（与 get_group_delete_impact 同口径——SQL
 //!                 单点在本模块 group_residue，手动删除影响面复用，防口径漂移）。
@@ -80,23 +83,41 @@ pub fn delete_group_row(conn: &Connection, group_id: i64) -> rusqlite::Result<bo
     Ok(affected > 0)
 }
 
-/// 自动路由产物谓词（组行单表可判——source 白名单 + 未改判）。
-fn is_auto_route_candidate(conn: &Connection, group_id: i64) -> rusqlite::Result<bool> {
+/// 自动清理候选谓词（组行单表 + 手排子表可判）。
+///
+/// @ai-context: 双闸防误删（批 7 审查修复 P2-7）——source 白名单只证明「自动
+///              产物」，不足以证明「从未被用户编排」：改名/置色/置顶/手排等
+///              元数据操作在修复前不置 route_overridden，会把被用户接管过的
+///              空组静默删掉（REQ-315 交互与 REQ-316 清理边界冲突）。
+///              主闸=route_overridden=0：修复后所有用户编排写路径同权置 1
+///              （db_note_groups::rename_group / update_group_color、
+///              db_note_group_orders::update_note_group_pin / save_group_order）；
+///              副闸=存量兜底（修复前已被编排但 override 仍 0 的行）：
+///              pin=0 ∧ color IS NULL ∧ 无 note_group_orders 行——任一编排
+///              痕迹存在即不删。
+fn is_clean_candidate(conn: &Connection, group_id: i64) -> rusqlite::Result<bool> {
     let count: i64 = conn.query_row(
-        "SELECT COUNT(*) FROM note_groups
-         WHERE id = ?1 AND source IN ('route', 'series') AND route_overridden = 0",
+        "SELECT COUNT(*) FROM note_groups g
+         WHERE g.id = ?1
+           AND g.source IN ('route', 'series')
+           AND g.route_overridden = 0
+           AND g.pin = 0
+           AND g.color IS NULL
+           AND NOT EXISTS (SELECT 1 FROM note_group_orders o WHERE o.group_id = g.id)",
         params![group_id],
         |row| row.get(0),
     )?;
     Ok(count > 0)
 }
 
 /// 空组自动清理（写事务提交前调用——对**本次写操作影响到的组**判定，防全表
-/// 扫描误删他组）：自动路由产物 + 残留全零 → 删组；返回实际清理的组。
+/// 扫描误删他组）：自动清理候选（谓词，见 is_clean_candidate）+ 残留全零 →
+/// 删组；返回实际清理的组。
 ///
-/// @ai-context: 边界（用户口径）——手动建组/改判组/有任意残留组绝不在本函数删除
-///              （谓词与残留双闸）；同一事务内检查与删除原子，无"检查后被并发
-///              写入"窗口（连接 Mutex 串行化）。重复 id 幂等安全（删除后不再出现）。
+/// @ai-context: 边界（用户口径）——手动建组/有任意编排痕迹/有任意残留组绝不
+///              在本函数删除（编排痕迹与残留双闸）；同一事务内检查与删除原子，
+///              无"检查后被并发写入"窗口（连接 Mutex 串行化）。重复 id 幂等
+///              安全（删除后不再出现）。
 pub fn auto_clean_empty_groups(
     conn: &Connection,
     affected_group_ids: &[i64],
@@ -106,7 +127,7 @@ pub fn auto_clean_empty_groups(
         if cleaned.iter().any(|c| c.id == *id) {
             continue; // 重复 id 幂等（同批多次命中只清一次）
         }
-        if !is_auto_route_candidate(conn, *id)? {
+        if !is_clean_candidate(conn, *id)? {
             continue;
         }
         let residue = group_residue(conn, *id)?;

app/src-tauri/src/db_note_group_clean_tests.rs

@@ -1,8 +1,10 @@
 //! db_note_group_clean 单测（REQ-316 批 7；内存库 AAA 模式）。
 //!
-//! @ai-context: 覆盖自动清理判定表——自动路由产物+五类残留全零才删；手动建组/
-//!              改判组/任一残留/影响面外组永不动；级联卫生（note_group_orders
-//!              行随删清）；写路径收敛（删除/移组/碎片删除/移组/升笔记触发点）。
+//! @ai-context: 覆盖自动清理判定表——自动路由产物+零编排痕迹+五类残留全零才删；
+//!              手动建组/改判组/任一编排痕迹（置顶/手排/置色——批 7 审查 P2-7
+//!              双保险）/任一残留/影响面外组永不动；写路径收敛（删除/移组/
+//!              碎片删除/升笔记触发点）。级联卫生（note_group_orders 行随删清）
+//!              由 db_note_group_orders_tests::delete_group_cascades_order_row 覆盖。
 
 use rusqlite::params;
 
@@ -213,22 +215,75 @@ fn groups_outside_affected_scope_untouched() {
 }
 
 #[test]
-fn cleanup_cascades_order_rows_and_pin_with_group() {
-    // Arrange：空路由组 + 置顶 + 分区手动序行（批 6 基建——组删随 FK CASCADE 清）
+fn pinned_or_hand_ordered_auto_group_is_never_auto_cleaned() {
+    // 批 7 审查修复（P2-7）：原测试固化「置顶/手排的空路由组照样被清」——与
+    // REQ-315 冲突（置顶/手排是用户编排动作，组删不得绕过用户交互），反转：
+    // 置顶组/手排组即使空也保留（写路径已同权置 route_overridden=1=主闸）。
+    // 级联卫生（随组删清 note_group_orders 行）由 db_note_group_orders_tests
+    // ::delete_group_cascades_order_row 覆盖（自动清理永不删有手排行的组）。
     let db = mem_db();
-    let g = db.create_group(&group("有序组", "route")).expect("g");
-    db.update_note_group_pin(g.id, 1).expect("pin");
-    db.save_group_order("standalone", &[g.id]).expect("order");
+    let pinned = db.create_group(&group("置顶组", "route")).expect("g");
+    db.update_note_group_pin(pinned.id, 1).expect("pin");
+    let ordered = db.create_group(&group("手排组", "route")).expect("g2");
+    db.save_group_order("standalone", &[ordered.id]).expect("order");
+    // Act
+    let guard = db_raw_conn(&db);
+    let cleaned = auto_clean_empty_groups(&guard, &[pinned.id, ordered.id]).expect("clean");
+    drop(guard);
+    // Assert：两组全存活（用户编排痕迹=接管该组——不再自动清理）
+    assert!(cleaned.is_empty());
+    assert!(db.get_group(pinned.id).expect("get").is_some());
+    assert!(db.get_group(ordered.id).expect("get").is_some());
+}
+
+#[test]
+fn legacy_pin_color_order_traces_block_cleanup_even_when_flag_zero() {
+    // 批 7 审查修复（P2-7 双保险·副闸=存量兜底）：修复前的存量行——用户已
+    // 置顶/置色/手排但旧写路径不置 route_overridden（仍 0）。直写 SQL 模拟
+    // 存量态（经 db 方法会连置位=主闸，单测副闸必须绕过）；任一编排痕迹
+    // 存在即不删——"仅 route 源+零编排+零残留才删"的存量侧护栏。
+    let db = mem_db();
+    let pinned = db.create_group(&group("旧置顶", "route")).expect("pinned");
+    let colored = db.create_group(&group("旧上色", "route")).expect("colored");
+    let ordered = db.create_group(&group("旧手排", "route")).expect("ordered");
+    db.with_conn(|conn| {
+        conn.execute("UPDATE note_groups SET pin = 1 WHERE id = ?1", params![pinned.id])?;
+        conn.execute("UPDATE note_groups SET color = 'pink' WHERE id = ?1", params![colored.id])?;
+        conn.execute(
+            "INSERT INTO note_group_orders (group_id, seq) VALUES (?1, 0)",
+            params![ordered.id],
+        )?;
+        Ok(())
+    })
+    .expect("seed legacy orchestration traces");
+    // Act：三个存量编排痕迹组全空、全在影响面内
+    let guard = db_raw_conn(&db);
+    let cleaned = auto_clean_empty_groups(&guard, &[pinned.id, colored.id, ordered.id]).expect("clean");
+    drop(guard);
+    // Assert：全部保留（存量兜底闸生效——修前数据不被静默误删）
+    assert!(cleaned.is_empty());
+    for gid in [pinned.id, colored.id, ordered.id] {
+        assert!(db.get_group(gid).expect("get").is_some(), "组 {gid} 有存量编排痕迹不得清");
+    }
+}
+
+#[test]
+fn user_rename_takes_over_auto_group_and_blocks_cleanup() {
+    // 批 7 审查修复（P2-7 双保险·主闸=写路径）：改名=用户编排痕迹——写路径与
+    // 路由改判同权置 route_overridden=1。仅改名的组无 pin/色/手排行（副闸
+    // 拦不住），必须靠主闸拦截——验证「新编排只留 flag 也删不掉」。
+    let db = mem_db();
+    let g = db.create_group(&group("路由产物", "route")).expect("g");
+    assert!(db.rename_group(g.id, "我自己改的名").expect("rename"));
     // Act
     let guard = db_raw_conn(&db);
     let cleaned = auto_clean_empty_groups(&guard, &[g.id]).expect("clean");
     drop(guard);
-    // Assert：组没了、序行/置顶残留零
-    assert_eq!(cleaned.len(), 1);
-    let orphan: i64 = db
-        .with_conn(|c| Ok(c.query_row("SELECT COUNT(*) FROM note_group_orders WHERE group_id = ?1", params![g.id], |r| r.get(0))?))
-        .expect("count");
-    assert_eq!(orphan, 0, "note_group_orders 随组删级联清行（无孤儿）");
+    // Assert：改名组即使空也保留（主闸：route_overridden=1）
+    assert!(cleaned.is_empty());
+    let fetched = db.get_group(g.id).expect("get").expect("exists");
+    assert_eq!(fetched.route_overridden, 1);
+    assert_eq!(fetched.name, "我自己改的名");
 }
 
 // ── 写路径集成（真实命令语义在 db 层事务内收敛的验证） ──

app/src-tauri/src/db_note_group_orders.rs

@@ -31,10 +31,16 @@ impl Db {
     ///
     /// @ai-context: updated_at 同步刷新：置顶动作把它推为置顶区内最新
     ///              （置顶区内部按更新时间降序，与取消置顶回落自动区的口径一致）。
+    /// @ai-context: 批 7 审查修复（P2-7 双保险·写侧）：置顶/取消置顶=用户在操作
+    ///              该组=编排痕迹——与路由改判同权置 route_overridden=1（仅
+    ///              route/series 自动产物；Why 见 db_note_groups::rename_group），
+    ///              空组自动清理不再误删被用户置过顶的组（REQ-315/REQ-316 边界）。
     pub fn update_note_group_pin(&self, id: i64, pin: i64) -> Result<bool> {
         self.with_conn(|conn| {
             let affected = conn.execute(
-                "UPDATE note_groups SET pin = ?1, updated_at = ?2 WHERE id = ?3",
+                "UPDATE note_groups SET pin = ?1,
+                 route_overridden = CASE WHEN source IN ('route', 'series') THEN 1 ELSE route_overridden END,
+                 updated_at = ?2 WHERE id = ?3",
                 params![pin, unix_seconds(), id],
             )?;
             Ok(affected > 0)
@@ -77,6 +83,28 @@ impl Db {
                 stmt.execute(params![*id, i as i64])?;
             }
         }
+        // 批 7 审查修复（P2-7 双保险·写侧）：手排保存=用户编排痕迹——快照内
+        // 全部组与路由改判同权置 route_overridden=1（仅 route/series 自动产物；
+        // Why 见 db_note_groups::rename_group），用户亲手排过位的空组不被自动
+        // 清理误删。同事务原子：快照回滚则编排标记一并回滚，无半态。
+        if !group_ids.is_empty() {
+            let mut sql = String::from(
+                "UPDATE note_groups SET route_overridden = 1
+                 WHERE source IN ('route', 'series') AND id IN (",
+            );
+            for (i, _) in group_ids.iter().enumerate() {
+                if i > 0 {
+                    sql.push(',');
+                }
+                sql.push_str(&format!("?{}", i + 1));
+            }
+            sql.push(')');
+            let mut ps: Vec<&dyn rusqlite::ToSql> = Vec::new();
+            for id in group_ids {
+                ps.push(id);
+            }
+            tx.execute(&sql, rusqlite::params_from_iter(ps))?;
+        }
         tx.commit()?;
         Ok(())
     }

app/src-tauri/src/db_note_group_orders_tests.rs

@@ -166,3 +166,26 @@ fn group_pin_roundtrip_and_updated_at_refresh() {
     // 不存在组 → false
     assert!(!db.update_note_group_pin(9999, 1).expect("missing"));
 }
+
+#[test]
+fn pin_and_manual_order_save_mark_user_orchestration() {
+    // 批 7 审查修复（P2-7 写侧单点）：置顶/手排=用户编排痕迹——route/series
+    // 自动产物置 route_overridden=1（空组自动清理谓词主闸），防空组被静默删；
+    // 手排标记与快照同事务（save_group_order 内一并 UPDATE，回滚同生共死）。
+    let db = mem_db();
+    let a = make(&db, "A", "course"); // source=route（helper 默认）
+    assert!(db.update_note_group_pin(a.id, 1).expect("pin"));
+    assert_eq!(
+        db.get_group(a.id).expect("get").expect("a").route_overridden,
+        1,
+        "置顶=接管该组"
+    );
+    // 手排快照覆盖：快照内（未置顶）组全部接管
+    let b = make(&db, "B", "course");
+    db.save_group_order("course", &[a.id, b.id]).expect("snapshot");
+    assert_eq!(db.get_group(b.id).expect("get").expect("b").route_overridden, 1);
+    // 分区复位（空 ids）不置位任何组（无快照成员——无对象可标记）
+    let c = make(&db, "C", "course");
+    db.save_group_order("course", &[]).expect("reset");
+    assert_eq!(db.get_group(c.id).expect("get").expect("c").route_overridden, 0);
+}

app/src-tauri/src/db_note_groups.rs

@@ -134,10 +134,18 @@ impl Db {
     }
 
     /// 重命名组（用户可改；updated_at 刷新）。
+    ///
+    /// @ai-context: 批 7 审查修复（P2-7 双保险·写侧）：改名=用户编排痕迹——与
+    ///              路由改判同权置 route_overridden=1（仅 route/series 自动产物；
+    ///              手动组天然不在清理白名单，无需置位），此后该组即使被删空
+    ///              也不再被自动清理（REQ-316 口径：只清从未被用户动过的路由
+    ///              空组）。Why 单条 UPDATE 内 CASE 完成：无跨语句窗口，原子。
     pub fn rename_group(&self, id: i64, name: &str) -> Result<bool> {
         self.with_conn(|conn| {
             let affected = conn.execute(
-                "UPDATE note_groups SET name = ?1, updated_at = ?2 WHERE id = ?3",
+                "UPDATE note_groups SET name = ?1,
+                 route_overridden = CASE WHEN source IN ('route', 'series') THEN 1 ELSE route_overridden END,
+                 updated_at = ?2 WHERE id = ?3",
                 params![name, unix_seconds(), id],
             )?;
             Ok(affected > 0)
@@ -179,10 +187,18 @@ impl Db {
     }
 
     /// v0.14 B（视觉系统）：组级颜色设置（色板 id；None=清除回默认灰）。
+    ///
+    /// @ai-context: 批 7 审查修复（P2-7 双保险·写侧）：置色/清色都是用户在操作
+    ///              该组=编排痕迹——与路由改判同权置 route_overridden=1
+    ///              （仅 route/series 自动产物；Why 见 rename_group 同款注释）。
+    ///              注：清色回默认灰不撤销接管——标志粘性（用户一旦动过该组
+    ///              即不再自动清理，无"撤销痕迹"通道，语义简单可预期）。
     pub fn update_group_color(&self, id: i64, color: Option<&str>) -> Result<bool> {
         self.with_conn(|conn| {
             let affected = conn.execute(
-                "UPDATE note_groups SET color = ?1, updated_at = ?2 WHERE id = ?3",
+                "UPDATE note_groups SET color = ?1,
+                 route_overridden = CASE WHEN source IN ('route', 'series') THEN 1 ELSE route_overridden END,
+                 updated_at = ?2 WHERE id = ?3",
                 params![color, unix_seconds(), id],
             )?;
             Ok(affected > 0)

app/src-tauri/src/db_note_groups_tests.rs

@@ -180,6 +180,44 @@ fn move_note_between_groups() {
     assert_eq!(db.get_note(note.id).expect("get").unwrap().group_id, None);
 }
 
+#[test]
+fn rename_marks_user_orchestration_on_auto_product_only() {
+    // 批 7 审查修复（P2-7 写侧单点）：改名=用户编排痕迹→接管自动路由产物——
+    // route/series 组置 route_overridden=1（空组自动清理谓词主闸）；手动组
+    // 天然无权自动清理，不置位（override 语义只对自动产物有意义，模型不污染）。
+    let db = mem_db();
+    let auto = db.create_group(&group("路由组")).expect("auto");
+    assert!(db.rename_group(auto.id, "更名后的路由组").expect("rename"));
+    let fetched = db.get_group(auto.id).expect("get").expect("exists");
+    assert_eq!(fetched.name, "更名后的路由组");
+    assert_eq!(fetched.route_overridden, 1, "改名=用户编排痕迹→接管该组");
+    // 手动组改名：名照改、不置位
+    let mut manual = group("手动组");
+    manual.source = "manual".to_string();
+    let m = db.create_group(&manual).expect("manual");
+    assert!(db.rename_group(m.id, "手动组新名").expect("rename"));
+    let mf = db.get_group(m.id).expect("get").expect("exists");
+    assert_eq!(mf.name, "手动组新名");
+    assert_eq!(mf.route_overridden, 0);
+}
+
+#[test]
+fn group_color_set_marks_user_orchestration_and_stays_sticky() {
+    // 批 7 审查修复（P2-7 写侧单点）：置色/清色=用户在操作该组=编排痕迹→
+    // route/series 产物接管（route_overridden=1）；清色回默认灰不撤销接管
+    // （标志粘性——用户动过即不再自动清理，无"撤销痕迹"通道）。
+    let db = mem_db();
+    let auto = db.create_group(&group("路由组")).expect("auto");
+    assert!(db.update_group_color(auto.id, Some("pink")).expect("set"));
+    let fetched = db.get_group(auto.id).expect("get").expect("exists");
+    assert_eq!(fetched.color.as_deref(), Some("pink"));
+    assert_eq!(fetched.route_overridden, 1);
+    assert!(db.update_group_color(auto.id, None).expect("clear"));
+    let cleared = db.get_group(auto.id).expect("get").expect("exists");
+    assert_eq!(cleared.color, None);
+    assert_eq!(cleared.route_overridden, 1, "清色不撤销接管（粘性）");
+}
+
 #[test]
 fn delete_group_keeps_notes() {
     // Arrange：删组只断关联不删笔记（笔记是用户资产）