@@ -206,27 +206,35 @@ pub fn delete_note_group(state: State<'_, AppState>, id: i64) -> Result<bool, St
     delete_note_group_inner(&state.db, id)
 }
 
-pub(crate) fn get_group_delete_impact_inner(
-    db: &crate::db::Db,
-    id: i64,
-) -> Result<GroupDeleteImpact, String> {
+/// 组存在性校验（R-低3：get_group_delete_impact/delete_note_group 共用——
+/// 防校验规则演进时口径漂移；风格与 commands_knowledge::require_id 一致）。
+fn require_group(db: &crate::db::Db, id: i64) -> Result<(), String> {
     if id <= 0 {
         return Err("无效的组 id".to_string());
     }
     if db.get_group(id).map_err(|e| e.to_string())?.is_none() {
         return Err(format!("笔记组不存在: {}", id));
     }
+    Ok(())
+}
+
+pub(crate) fn get_group_delete_impact_inner(
+    db: &crate::db::Db,
+    id: i64,
+) -> Result<GroupDeleteImpact, String> {
+    require_group(db, id)?;
     db.group_delete_impact(id).map_err(|e| e.to_string())
 }
 
 pub(crate) fn delete_note_group_inner(db: &crate::db::Db, id: i64) -> Result<bool, String> {
-    if id <= 0 {
-        return Err("无效的组 id".to_string());
-    }
-    if db.get_group(id).map_err(|e| e.to_string())?.is_none() {
+    require_group(db, id)?;
+    // R-低2：存在性检查与删除之间仍可能有并发删除窗口——Ok(false) 显式转错误，
+    // 使"组不存在 → 错误"的文档承诺成立（前端不误判为成功）
+    let deleted = db.delete_group(id).map_err(|e| e.to_string())?;
+    if !deleted {
         return Err(format!("笔记组不存在: {}", id));
     }
-    db.delete_group(id).map_err(|e| e.to_string())
+    Ok(true)
 }
 
 /// 命令层单测独立文件（保持本文件 ≤300 行，AGENTS.md §3）。
 
@@ -1,4 +1,4 @@
-//! 知识体系画布命令层（v0.13.8 系统层；4 命令）。
+//! 知识体系画布命令层（v0.13.8 系统层；v0.14.1：6 命令）。
 //!
 //! @ai-context: 本层只做参数校验、调用数据层、错误映射（AGENTS.md §6）；编排逻辑
 //!              `fn xxx_inner(db, ...)` 为纯函数（:memory: 可测），薄 `#[tauri::command]`
@@ -10,6 +10,9 @@
 //! @ai-context: 设计规格 §4.6 列 3 条命令；规格同时要求"切回画布视口恢复"，
 //!              恢复需要读路径——补 `get_canvas_viewport`（第 4 条）补齐读写闭环，
 //!              已在版本文档 v0.13.8 交付记录登记（规格增补，非契约变更）。
+//! @ai-context: v0.14.1 增 2 条（第 5/6 条）——get_canvas_prefs/save_canvas_prefs：
+//!              连线样式与布局算法按体系持久化，枚举白名单前后端同口径
+//!              （EDGE_STYLES/LAYOUT_ALGORITHMS 未知值拒绝，防任意字符串入库）。
 
 use tauri::State;
 
@@ -169,13 +172,23 @@ pub(crate) fn get_canvas_viewport_inner(
         .map_err(|e| e.to_string())
 }
 
-/// 读取体系画布偏好（v0.14.1；从未保存 → None——前端回落默认值）。
+/// 体系存在性校验（R-低3：偏好读写 inner 共用；风格与 require_id 一致）。
+fn require_system(db: &Db, system_id: i64) -> Result<(), String> {
+    require_id(system_id)?;
+    if db.get_knowledge_system(system_id).map_err(|e| e.to_string())?.is_none() {
+        return Err(format!("体系不存在: {}", system_id));
+    }
+    Ok(())
+}
+
+/// 读取体系画布偏好（v0.14.1；从未保存 → None——前端回落默认值，与迁移
+/// DEFAULT smoothstep/radial/无箭头同口径）。
 #[tauri::command]
 pub fn get_canvas_prefs(state: State<'_, AppState>, system_id: i64) -> Result<Option<CanvasPrefs>, String> {
     get_canvas_prefs_inner(&state.db, system_id)
 }
 
-/// 保存体系画布偏好（upsert；枚举白名单校验）。
+/// 保存体系画布偏好（upsert——只改偏好列不碰视口；枚举白名单校验）。
 #[tauri::command]
 pub fn save_canvas_prefs(
     state: State<'_, AppState>,
@@ -188,10 +201,7 @@ pub fn save_canvas_prefs(
 }
 
 pub(crate) fn get_canvas_prefs_inner(db: &Db, system_id: i64) -> Result<Option<CanvasPrefs>, String> {
-    require_id(system_id)?;
-    if db.get_knowledge_system(system_id).map_err(|e| e.to_string())?.is_none() {
-        return Err(format!("体系不存在: {}", system_id));
-    }
+    require_system(db, system_id)?;
     db.get_canvas_prefs(system_id).map_err(|e| e.to_string())
 }
 
@@ -202,10 +212,7 @@ pub(crate) fn save_canvas_prefs_inner(
     edge_arrows: bool,
     layout_algorithm: &str,
 ) -> Result<bool, String> {
-    require_id(system_id)?;
-    if db.get_knowledge_system(system_id).map_err(|e| e.to_string())?.is_none() {
-        return Err(format!("体系不存在: {}", system_id));
-    }
+    require_system(db, system_id)?;
     if !EDGE_STYLES.contains(&edge_style) {
         return Err(format!(
             "不支持的连线样式: {}（支持: {}）",
 
@@ -113,3 +113,37 @@ fn viewport_and_prefs_do_not_clobber_each_other() {
     assert!(p.edge_arrows);
     assert_eq!(p.layout_algorithm, "fishbone");
 }
+
+#[test]
+fn migration_adds_pref_columns_to_legacy_states() {
+    // Arrange：手工造 v0.13.8 旧 schema（canvas_states 仅视口三列 + 一行旧视口）
+    //（R-低7：ALTER 迁移分支此前无覆盖——新库走 CREATE TABLE 含三列，旧库
+    //  ensure_column 分支从未被执行验证；本用例按 db_notes_tests 旧库造法）
+    let path = std::env::temp_dir().join(format!("entropy_mig_canvas_{}.db", std::process::id()));
+    let _ = std::fs::remove_file(&path);
+    {
+        let conn = rusqlite::Connection::open(&path).expect("open old db");
+        conn.execute_batch(
+            "CREATE TABLE knowledge_canvas_states (
+                system_id INTEGER PRIMARY KEY,
+                viewport_x REAL DEFAULT 0,
+                viewport_y REAL DEFAULT 0,
+                zoom REAL DEFAULT 1.0
+            );
+            INSERT INTO knowledge_canvas_states (system_id, viewport_x, viewport_y, zoom)
+                VALUES (1, 10, 20, 1.5);",
+        )
+        .expect("create old schema");
+    }
+    // Act：以新代码打开旧库（ensure_column 补齐三列；旧表无 FK 子句——不依赖表关联）
+    let db = Db::open(path.to_str().unwrap()).expect("open migrated db");
+    // Assert：旧行落 DEFAULT（smoothstep / 无箭头 / radial，与前端缺省同口径）；
+    //         视口列未被迁移触碰
+    let p = db.get_canvas_prefs(1).expect("读").expect("有");
+    assert_eq!(p.edge_style, "smoothstep");
+    assert!(!p.edge_arrows);
+    assert_eq!(p.layout_algorithm, "radial");
+    let (x, y, z) = db.get_canvas_viewport(1).expect("读").expect("有");
+    assert_eq!((x, y, z), (10.0, 20.0, 1.5));
+    let _ = std::fs::remove_file(&path);
+}
@@ -195,7 +195,10 @@ impl Db {
                 settlements: count("SELECT COUNT(*) FROM settlements WHERE group_id = ?1")?,
                 contracts: count("SELECT COUNT(*) FROM contracts WHERE group_id = ?1")?,
                 system_refs: count(
-                    "SELECT COUNT(*) FROM knowledge_links WHERE target_type = 'note_group' AND target_id = ?1",
+                    "SELECT COUNT(*) FROM knowledge_links WHERE
+                       (target_type = 'note_group' AND target_id = ?1)
+                       OR (target_type = 'flashcard'
+                           AND target_id IN (SELECT id FROM flashcards WHERE group_id = ?1))",
                 )?,
             })
         })
@@ -205,16 +208,30 @@ impl Db {
     ///
     /// @ai-context: knowledge_links 无 FK 到 note_groups（target_type/target_id
     ///              泛化目标，白名单校验在命令层），必须显式清理——否则体系页
-    ///              引用区出现悬空反查。PRAGMA foreign_keys=ON 每连接开启（db.rs），
+    ///              引用区出现悬空反查。两类引用都在本事务清理且**先于删组**：
+    ///              note_group 直引 + flashcard 间接引（组闪卡经 FK CASCADE 删除
+    ///              后其引用同样悬空——审查 R-中1 补漏；子查询必须在级联删行
+    ///              之前执行）。PRAGMA foreign_keys=ON 每连接开启（db.rs），
     ///              notes/fragments SET NULL 与 flashcards/settlements/contracts
     ///              CASCADE 由建表契约自动生效；组不存在 → false（命令层转错误）。
     pub fn delete_group(&self, id: i64) -> Result<bool> {
+        // @ai-context: 事务需要 &mut Connection，with_conn 只给 &Connection——
+        //              同 db_knowledge_canvas::set_node_canvas_positions 手法：
+        //              直接锁 + conn.transaction()（显式事务；毒锁恢复后的孤儿
+        //              事务由 SQLite 对未提交事务隐式回滚兜住，与 with_conn
+        //              恢复路径语义一致）。
         let mut conn = self.conn.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
         let tx = conn.transaction()?;
         tx.execute(
             "DELETE FROM knowledge_links WHERE target_type = 'note_group' AND target_id = ?1",
             params![id],
         )?;
+        // flashcard 间接引用清理（先于级联删行——子查询须在行存在时执行）
+        tx.execute(
+            "DELETE FROM knowledge_links WHERE target_type = 'flashcard'
+             AND target_id IN (SELECT id FROM flashcards WHERE group_id = ?1)",
+            params![id],
+        )?;
         let affected = tx.execute("DELETE FROM note_groups WHERE id = ?1", params![id])?;
         tx.commit()?;
         Ok(affected > 0)
 
@@ -198,20 +198,18 @@ fn delete_group_keeps_notes() {
             group_id: Some(g.id),
         })
         .expect("note");
-    // Act
-    db.with_conn(|conn| {
-        conn.execute("DELETE FROM note_groups WHERE id = ?1", rusqlite::params![g.id])
-            .map_err(Into::into)
-    })
-    .expect("delete");
+    // Act：走新 API（R-低8：原裸 SQL 直删与 delete_group_cascades 重叠——
+    // 改经被测代码的真实删除路径，SET NULL 断言覆盖新 API）
+    assert!(db.delete_group(g.id).expect("delete"));
     // Assert：笔记存活且 group_id 置空（ON DELETE SET NULL）
     let fetched = db.get_note(note.id).expect("get").expect("exists");
     assert_eq!(fetched.group_id, None);
 }
 
 #[test]
 fn group_delete_impact_counts_six_dimensions() {
-    // Arrange：组内挂 2 笔记 + 1 碎片 + 1 卡 + 1 结算 + 1 契约；体系引用 2 条
+    // Arrange：组内挂 2 笔记 + 1 碎片 + 1 卡 + 1 结算 + 1 契约；
+    //         体系引用 2 条（note_group 直引）+ 1 条 flashcard 间接引（R-中1）
     let db = mem_db();
     let g = db.create_group(&group("将删")).expect("create");
     for title in ["A", "B"] {
@@ -236,17 +234,18 @@ fn group_delete_impact_counts_six_dimensions() {
         source: "manual".to_string(),
     })
     .expect("frag");
-    db.create_card(&NewFlashcard {
-        group_id: g.id,
-        note_id: None,
-        fragment_id: None,
-        front: "f".to_string(),
-        back: "b".to_string(),
-        kind: "fact".to_string(),
-        state_json: "{}".to_string(),
-        due_at: 0,
-    })
-    .expect("card");
+    let card = db
+        .create_card(&NewFlashcard {
+            group_id: g.id,
+            note_id: None,
+            fragment_id: None,
+            front: "f".to_string(),
+            back: "b".to_string(),
+            kind: "fact".to_string(),
+            state_json: "{}".to_string(),
+            due_at: 0,
+        })
+        .expect("card");
     db.create_settlement(g.id, "{}").expect("settlement");
     db.upsert_week_contract(g.id, 1, 3, 5).expect("contract");
     let sys = db
@@ -268,20 +267,30 @@ fn group_delete_impact_counts_six_dimensions() {
         })
         .expect("link");
     }
+    db.add_knowledge_link(&NewKnowledgeLink {
+        system_id: sys.id,
+        node_id: None,
+        concept_id: None,
+        model_id: None,
+        target_type: "flashcard".to_string(),
+        target_id: card.id,
+    })
+    .expect("link");
     // Act
     let impact = db.group_delete_impact(g.id).expect("impact");
-    // Assert：六项计数如实（确认弹窗数据源口径）
+    // Assert：六项计数如实（确认弹窗数据源口径；system_refs 含两类引用）
     assert_eq!(impact.notes, 2);
     assert_eq!(impact.fragments, 1);
     assert_eq!(impact.cards, 1);
     assert_eq!(impact.settlements, 1);
     assert_eq!(impact.contracts, 1);
-    assert_eq!(impact.system_refs, 2);
+    assert_eq!(impact.system_refs, 3);
 }
 
 #[test]
 fn delete_group_cascades_and_clears_links() {
-    // Arrange：1 笔记 + 1 碎片 + 1 卡 + 1 契约 + 1 体系引用（级联影响面最小集）
+    // Arrange：1 笔记 + 1 碎片 + 1 卡 + 1 契约 + note_group/fashcard 引用各 1
+    //（级联影响面最小集；R-中1：flashcard 间接引用必须一并清理）
     let db = mem_db();
     let g = db.create_group(&group("将删")).expect("create");
     let note = db
@@ -305,17 +314,18 @@ fn delete_group_cascades_and_clears_links() {
         source: "manual".to_string(),
     })
     .expect("frag");
-    db.create_card(&NewFlashcard {
-        group_id: g.id,
-        note_id: None,
-        fragment_id: None,
-        front: "f".to_string(),
-        back: "b".to_string(),
-        kind: "fact".to_string(),
-        state_json: "{}".to_string(),
-        due_at: 0,
-    })
-    .expect("card");
+    let card = db
+        .create_card(&NewFlashcard {
+            group_id: g.id,
+            note_id: None,
+            fragment_id: None,
+            front: "f".to_string(),
+            back: "b".to_string(),
+            kind: "fact".to_string(),
+            state_json: "{}".to_string(),
+            due_at: 0,
+        })
+        .expect("card");
     db.upsert_week_contract(g.id, 1, 3, 5).expect("contract");
     let sys = db
         .create_knowledge_system(&NewKnowledgeSystem {
@@ -333,10 +343,19 @@ fn delete_group_cascades_and_clears_links() {
         target_type: "note_group".to_string(),
         target_id: g.id,
     })
-    .expect("link");
+    .expect("group link");
+    db.add_knowledge_link(&NewKnowledgeLink {
+        system_id: sys.id,
+        node_id: None,
+        concept_id: None,
+        model_id: None,
+        target_type: "flashcard".to_string(),
+        target_id: card.id,
+    })
+    .expect("card link");
     // Act
     let ok = db.delete_group(g.id).expect("delete");
-    // Assert：组消失；笔记/碎片 SET NULL 存活；卡/契约 CASCADE 归零；引用清理
+    // Assert：组消失；笔记/碎片 SET NULL 存活；卡/契约 CASCADE 归零；两类引用清理
     assert!(ok);
     assert!(db.get_group(g.id).expect("get").is_none());
     assert_eq!(db.get_note(note.id).expect("get").expect("note").group_id, None);
@@ -355,6 +374,7 @@ fn delete_group_cascades_and_clears_links() {
         .expect("counts");
     assert_eq!(counts, (0, 0, 0));
     assert!(db.list_links_by_target("note_group", g.id).expect("links").is_empty());
+    assert!(db.list_links_by_target("flashcard", card.id).expect("card links").is_empty());
 }
 
 #[test]