feat(session): 原子 batch_delete_sessions 批量删除（单事务全删）

批4 会话页交互矩阵：新增后端批量删除命令——单事务逐条 DELETE，中途失败整体回滚（与单条 delete_session 级联子表/笔记 SET NULL/域广播语义逐条一致）；空 ids 与超限报错、重复去重；返回实际删除数。替代前端逐条循环的半删路径。

Author: Aparencia

app/src-tauri/src/commands_session_delete.rs

@@ -0,0 +1,70 @@
+//! 会话批量删除 Tauri commands（批 4 会话页交互矩阵——用户问题 4 已授权彻底方案）。
+//!
+//! @ai-context: 会话页勾选批量删除原为前端逐条循环调 delete_session（部分失败
+//!              残留半删状态）；本模块提供单事务原子 batch_delete_sessions，
+//!              语义与单条 delete_session 完全一致——子表外键级联
+//!              （session_segments/session_ocr_blocks/artifact_blocks/
+//!              session_events）、notes.session_id SET NULL、域广播
+//!              （Sessions+Notes）均在命令层对等复刻。
+//! @ai-context: 本层只做参数校验、调用数据层、错误映射（AGENTS.md §6）；
+//!              DB 读写为快速操作直接调用，不额外 spawn_blocking（与
+//!              delete_session 同口径——连接内 Mutex 保护）。
+
+use tauri::State;
+
+use crate::commands::AppState;
+use crate::types::BatchSessionDeleteResult;
+
+/// 批量删除单次上限（= 列表单页上限，见 commands_session::LIST_LIMIT_MAX）。
+///
+/// @ai-context Why 有界：勾选集恒为当前可见列表子集（≤200），上限只是防御
+///              越界 payload；与批量转笔记 50 条上限同为批次护栏，但删除是
+///              原子全删，超限直接拒绝而非截断（防误删）。
+const BATCH_DELETE_LIMIT: usize = 200;
+
+/// 批量删除核心编排（仅测试基准——命令入口走同函数后补域广播）。
+///
+/// @ai-context: 校验顺序：空集 → 超限 → 非法 id（与单条 delete_session 对
+///              id<=0 直接报错的语义逐条一致）；重复 id 静默去重（同批量转
+///              笔记口径——同一会话只删一次，不影响返回计数）。
+pub fn run_batch_delete(db: &crate::db::Db, ids: Vec<i64>) -> Result<BatchSessionDeleteResult, String> {
+    if ids.is_empty() {
+        return Err("批量删除 ids 不能为空".to_string());
+    }
+    if ids.len() > BATCH_DELETE_LIMIT {
+        return Err(format!("批量删除上限 {} 条", BATCH_DELETE_LIMIT));
+    }
+    if let Some(&bad) = ids.iter().find(|&&id| id <= 0) {
+        return Err(format!("无效的会话 id: {}", bad));
+    }
+    let mut uniq: Vec<i64> = ids.clone();
+    uniq.sort_unstable();
+    uniq.dedup();
+    let deleted = db
+        .delete_sessions_batch(&uniq)
+        .map_err(|e| e.to_string())?;
+    Ok(BatchSessionDeleteResult { deleted })
+}
+
+/// 批量删除会话（批 4：单事务原子——全删或全不删，不再逐条半删）。
+///
+/// @ai-context: 域广播与单条 delete_session 完全一致：确有删除（deleted>0）
+///              才广播 sessions + notes 域（会话删除级联断笔记关联）；
+///              全不存在/全空结果不广播（无变化不打扰订阅端）。
+#[tauri::command]
+pub async fn batch_delete_sessions(
+    state: State<'_, AppState>,
+    ids: Vec<i64>,
+) -> Result<BatchSessionDeleteResult, String> {
+    let result = run_batch_delete(&state.db, ids)?;
+    if result.deleted > 0 {
+        crate::notify::emit_changed(&state.app, crate::notify::DataDomain::Sessions);
+        crate::notify::emit_changed(&state.app, crate::notify::DataDomain::Notes);
+    }
+    Ok(result)
+}
+
+/// 单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
+#[cfg(test)]
+#[path = "commands_session_delete_tests.rs"]
+mod delete_tests;

app/src-tauri/src/commands_session_delete_tests.rs

@@ -0,0 +1,199 @@
+//! 批量删除会话单测（批 4；AAA 模式 + :memory: 隔离库，绝不触碰真实数据）。
+//!
+//! @ai-context: 由 commands_session_delete.rs 以 #[cfg(test)] #[path] 引入；
+//!              被测对象 run_batch_delete 为命令核心（注入 Db，无 Tauri 态），
+//!              域广播在命令宏入口、不在此测试（与批量转笔记测试同构）。
+//! @ai-context: 原子性用 SQLite RAISE(ABORT) 触发器模拟中途失败——真实语句
+//!              失败难以在 :memory: 造出，触发器是 schema 层最接近的失败源。
+
+use crate::commands_session_delete::run_batch_delete;
+use crate::db::Db;
+use crate::types::{NewNote, NewSession, NewSessionSegment};
+
+fn mem_db() -> Db {
+    Db::open(":memory:").expect("open in-memory db")
+}
+
+/// 造一个已结束（finished）会话（带转写段 = 有内容）。
+fn finished_session(db: &Db, title: &str) -> i64 {
+    let s = db
+        .create_session(&NewSession {
+            title: title.into(),
+            source_window: None,
+            profile: None,
+            kind: None,
+        })
+        .expect("create session");
+    db.finish_session(s.id).expect("finish session");
+    db.add_segment(&NewSessionSegment {
+        session_id: s.id,
+        start_ms: 0,
+        end_ms: 1000,
+        text: format!("{} 的转写", title),
+        source: "asr".into(),
+        confidence: Some(0.9),
+        volume: None,
+        speech_rate: None,
+        pause_ms: None,
+        speaker: None,
+    })
+    .expect("add segment");
+    s.id
+}
+
+/// 直插子表行（转写段由 finished_session 已插一条；此处补 OCR 块/产物块/
+/// 信号事件各一——加段共四张表四行，验证删除外键级联全清）。
+fn seed_child_rows(db: &Db, session_id: i64) {
+    db.with_conn(|conn| {
+        conn.execute(
+            "INSERT INTO session_ocr_blocks (session_id, timestamp_ms, text, score, region)
+             VALUES (?1, 0, 'cascade ocr', 0.9, 'full')",
+            rusqlite::params![session_id],
+        )?;
+        conn.execute(
+            "INSERT INTO artifact_blocks (session_id, kind, payload_json, block_order)
+             VALUES (?1, 'chapter', '{}', 0)",
+            rusqlite::params![session_id],
+        )?;
+        conn.execute(
+            "INSERT INTO session_events (session_id, kind, timestamp_ms)
+             VALUES (?1, 'app_foreground', 0)",
+            rusqlite::params![session_id],
+        )?;
+        Ok(())
+    })
+    .expect("seed child rows");
+}
+
+/// 子表残留行数（>0 说明级联未生效）。
+fn child_row_count(db: &Db, session_id: i64) -> i64 {
+    db.with_conn(|conn| {
+        let mut count = 0i64;
+        for table in ["session_segments", "session_ocr_blocks", "artifact_blocks", "session_events"] {
+            let sql = format!("SELECT COUNT(*) FROM {} WHERE session_id = ?1", table);
+            count += conn.query_row(&sql, rusqlite::params![session_id], |row| {
+                row.get::<_, i64>(0)
+            })?;
+        }
+        Ok(count)
+    })
+    .expect("count child rows")
+}
+
+#[test]
+fn batch_delete_removes_all_and_cascades_children() {
+    // Arrange：三个会话（两个待删），各带四张子表行
+    let db = mem_db();
+    let a = finished_session(&db, "A课");
+    let b = finished_session(&db, "B课");
+    let keep = finished_session(&db, "保留课");
+    for id in [a, b, keep] {
+        seed_child_rows(&db, id);
+    }
+    assert_eq!(child_row_count(&db, a), 4);
+    // Act
+    let result = run_batch_delete(&db, vec![a, b]).expect("batch delete");
+    // Assert：计数精确；会话与子表全清；未选会话原样保留
+    assert_eq!(result.deleted, 2);
+    assert!(db.get_session(a).expect("db").is_none());
+    assert!(db.get_session(b).expect("db").is_none());
+    assert_eq!(child_row_count(&db, a), 0);
+    assert_eq!(child_row_count(&db, b), 0);
+    assert_eq!(child_row_count(&db, keep), 4);
+    assert!(db.get_session(keep).expect("db").is_some());
+}
+
+#[test]
+fn batch_delete_atomic_rollback_on_mid_failure() {
+    // Arrange：A 在触发器守卫之前、B 命中守卫——任何实现若逐条提交都会半删
+    let db = mem_db();
+    let a = finished_session(&db, "A课");
+    let b = finished_session(&db, "B课");
+    db.with_conn(|conn| {
+        // 触发器 DDL 不支持绑定变量——b 为刚由本库 create_session 生成的 i64，
+        // 非用户输入，直接内联安全（防御注释：杜绝字符串拼接的例外场景）
+        let sql = format!(
+            "CREATE TRIGGER guard_delete BEFORE DELETE ON sessions
+             WHEN OLD.id = {} BEGIN SELECT RAISE(ABORT, 'guard: session busy'); END",
+            b,
+        );
+        conn.execute_batch(&sql)?;
+        Ok(())
+    })
+    .expect("create guard trigger");
+    // Act
+    let err = run_batch_delete(&db, vec![a, b]).expect_err("must fail atomically");
+    // Assert：整体报错且 A 也未被删除（单事务回滚——无半删残留）
+    assert!(err.contains("guard: session busy"), "err={err}");
+    assert!(db.get_session(a).expect("db").is_some(), "A 应随事务回滚保留");
+    assert!(db.get_session(b).expect("db").is_some());
+}
+
+#[test]
+fn batch_delete_keeps_note_but_unbinds_session() {
+    // Arrange：已转笔记的会话（笔记是用户资产——删会话只断关联不删笔记）
+    let db = mem_db();
+    let id = finished_session(&db, "已转课");
+    let note = db
+        .create_note(&NewNote {
+            title: "转换笔记".into(),
+            content: "x".into(),
+            source: "classroom".into(),
+            session_id: Some(id),
+            rule_version: None,
+            purify_stats: None,
+            tags: None,
+            properties: None,
+            group_id: None,
+        })
+        .expect("create note");
+    // Act
+    run_batch_delete(&db, vec![id]).expect("batch delete");
+    // Assert：笔记保留且 session_id 已置空（外键 SET NULL 语义）
+    let kept = db.get_note(note.id).expect("db").expect("note kept");
+    assert_eq!(kept.session_id, None);
+    assert!(db.find_note_by_session(id).expect("db").is_none());
+}
+
+#[test]
+fn batch_delete_coexists_with_batch_convert() {
+    // Arrange：与批量转笔记同一编排链走一遍（先转后删——真实页面动线）
+    let db = mem_db();
+    let id = finished_session(&db, "先转后删课");
+    let converted = crate::commands_session_note::run_batch_conversion(
+        &db,
+        &crate::ui_junk::UiJunkList::defaults(),
+        &crate::note_filter::PurifyEnv::default(),
+        std::path::Path::new("."),
+        vec![id],
+    )
+    .expect("batch convert");
+    assert_eq!(converted.converted.len(), 1);
+    let note_id = converted.converted[0].note_id;
+    // Act：删除已转会话
+    run_batch_delete(&db, vec![id]).expect("batch delete");
+    // Assert：笔记留存且解绑；会话已删
+    let kept = db.get_note(note_id).expect("db").expect("note kept");
+    assert_eq!(kept.session_id, None);
+    assert!(db.get_session(id).expect("db").is_none());
+}
+
+#[test]
+fn batch_delete_validation_and_counting() {
+    let db = mem_db();
+    let a = finished_session(&db, "A课");
+    // 空 ids → 报错
+    let err = run_batch_delete(&db, vec![]).expect_err("empty must err");
+    assert!(err.contains("不能为空"), "err={err}");
+    // 非正 id → 报错（与单条 delete_session 同口径）
+    let err = run_batch_delete(&db, vec![0]).expect_err("invalid must err");
+    assert!(err.contains("无效的会话 id"), "err={err}");
+    // 超上限 → 报错（201 > 200）
+    let over: Vec<i64> = (1..=201).collect();
+    let err = run_batch_delete(&db, over).expect_err("over-limit must err");
+    assert!(err.contains("上限"), "err={err}");
+    // 重复 id 静默去重 + 不存在的 id 宽容（计 0，不报错——与单条一致）
+    let result = run_batch_delete(&db, vec![a, a, 99_999]).expect("dedupe & missing ok");
+    assert_eq!(result.deleted, 1);
+    assert!(db.get_session(a).expect("db").is_none());
+}

app/src-tauri/src/db_sessions.rs

@@ -131,6 +131,46 @@ impl Db {
         })
     }
 
+    /// 批量删除会话（批 4 会话页交互矩阵：后端原子 batch_delete_sessions）。
+    ///
+    /// @ai-context Why 单事务逐条 DELETE 而非一条 `WHERE id IN (...)`：本函数与
+    ///              单条 delete_session 走同一条 DELETE 语句（外键级联子表 +
+    ///              notes.session_id SET NULL 逐行生效），任一条中途失败（如
+    ///              外部触发器 RAISE）整体 ROLLBACK——批量=多次单条语义的原子版，
+    ///              绝不留半删状态（用户勾选多行后要的是"全删或全不删"）。
+    /// @ai-context: 返回实际删除行数（已不存在/重复 id 计 0，不报错——与单条
+    ///              delete_session 对不存在会话返回 Ok(false) 的宽容语义一致）；
+    ///              ids 去重由命令层负责，本层不假设输入形状。
+    pub fn delete_sessions_batch(&self, ids: &[i64]) -> Result<usize> {
+        if ids.is_empty() {
+            return Ok(0);
+        }
+        self.with_conn(|conn| {
+            conn.execute("BEGIN TRANSACTION", [])?;
+            let result = (|| -> rusqlite::Result<usize> {
+                let mut deleted = 0usize;
+                {
+                    let mut stmt = conn.prepare("DELETE FROM sessions WHERE id = ?1")?;
+                    for &id in ids {
+                        deleted += stmt.execute(params![id])?;
+                    }
+                }
+                Ok(deleted)
+            })();
+            match result {
+                Ok(n) => {
+                    conn.execute("COMMIT", [])?;
+                    Ok(n)
+                }
+                Err(e) => {
+                    let _ = conn.execute("ROLLBACK", []);
+                    Err(e)
+                }
+            }
+            .map_err(Into::into)
+        })
+    }
+
     // ── REQ-282（v0.19.6）：标题内容化 A 层 ──
 
     /// 近 N 天非失败会话的标题（同源去重候选；录制/已结束都算，失败排除）。

app/src-tauri/src/lib.rs

@@ -186,6 +186,8 @@ mod commands_refine_inner;
 mod commands_session;
 // v0.7.6 审查硬拆：会话 → 笔记转换管线（原料装载/结构渲染/单条转换/批量编排/预览）
 mod commands_session_note;
+// 批 4（会话页交互矩阵）：批量删除会话（单事务原子；语义/广播与单条一致）
+mod commands_session_delete;
 // v0.11.5（spec 8️⃣）：会话详情术语表——词汇表移出笔记后直供前端展示
 mod commands_session_glossary;
 // v0.7.7（REQ-182/183/184）：结构图命令层——批量捕获/手动框选/列表/删除
@@ -715,6 +717,8 @@ pub fn run() {
             commands_session::list_sessions,
             commands_session::get_session_detail,
             commands_session::delete_session,
+            // 批 4（会话页交互矩阵）：批量删除（单事务原子，替代前端逐条循环）
+            commands_session_delete::batch_delete_sessions,
             // REQ-282（v0.19.6）：会话改名（title_kind=manual 停止自动覆写）
             commands_session::update_session_title,
             commands_session::add_session_segment,

app/src-tauri/src/types.rs

@@ -548,6 +548,14 @@ pub struct BatchNoteResult {
     pub skipped: Vec<SkippedNote>,
 }
 
+/// 批量删除会话结果（批 4：原子全删语义——失败整体报错，无部分成功）。
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct BatchSessionDeleteResult {
+    /// 实际删除的会话行数（传入中已不存在的 id 不计入）。
+    pub deleted: usize,
+}
+
 /// 笔记列表排序模式（v0.10.0）。
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "kebab-case")]