fix(review): 批决议载荷复核/任务索引元数据保留/保存收口钩子/快照净化

Author: Aparencia

app/src-tauri/src/commands_after.rs

@@ -98,12 +98,22 @@ pub(crate) fn weekly_resolve_core(
     db: &Db,
     decisions: &[WeeklyDecision],
 ) -> Result<WeeklyResolveView, String> {
-    // 预读：行 → (note_id, line_no, text, 是否 abandon) + 事件载荷
-    let mut by_note: std::collections::HashMap<i64, Vec<(i64, String)>> = Default::default();
+    // 校验并预读任务行（失效/非法显式记 failed——不静默）
+    struct Pending {
+        note_id: i64,
+        line_no: i64,
+        payload: String,
+        reason: Option<String>,
+        abandon: bool,
+    }
     let mut view = WeeklyResolveView { done: 0, abandoned: 0, failed: Vec::new() };
-    let mut events: Vec<(String, Option<String>, i64)> = Vec::new(); // (text, reason, note_id)
-    let mut items: Vec<(i64, i64, String)> = Vec::new(); // (note_id, line_no, action)
+    let mut pendings: Vec<Pending> = Vec::new();
     for d in decisions {
+        let action = d.action.clone();
+        if !matches!(action.as_str(), "done" | "abandon") {
+            view.failed.push(format!("行 {} 非法动作 {}", d.row_id, action));
+            continue;
+        }
         let row = match db.get_task_row(d.row_id) {
             Ok(Some(r)) => r,
             Ok(None) => {
@@ -115,45 +125,71 @@ pub(crate) fn weekly_resolve_core(
                 continue;
             }
         };
-        let action = d.action.clone();
-        if !matches!(action.as_str(), "done" | "abandon") {
-            view.failed.push(format!("行 {} 非法动作 {}", row.id, action));
-            continue;
-        }
-        items.push((row.note_id, row.line_no, action.clone()));
-        by_note.entry(row.note_id).or_default().push((row.line_no, row.task_text.clone()));
-        if action == "abandon" {
-            events.push((row.task_text.clone(), d.reason.clone(), row.note_id));
-        } else {
-            events.push((row.task_text.clone(), None, row.note_id));
-        }
-        if action == "abandon" {
-            view.abandoned += 1;
-        } else {
-            view.done += 1;
-        }
+        pendings.push(Pending {
+            note_id: row.note_id,
+            line_no: row.line_no,
+            payload: row.task_text,
+            reason: d.reason.clone(),
+            abandon: action == "abandon",
+        });
     }
-    if items.is_empty() {
+    if pendings.is_empty() {
         return Ok(view);
     }
-    // 每笔记单次读正文 + 行变换（字符级迁移）——事务外只读
-    let mut contents: std::collections::HashMap<i64, (String, String)> = Default::default(); // note_id -> (title, content)
-    for (note_id, lines) in &by_note {
+    // 按笔记分组（保持批内顺序——正文行独立迁移互不影响）
+    let mut by_note: std::collections::HashMap<i64, Vec<usize>> = Default::default();
+    for (i, p) in pendings.iter().enumerate() {
+        by_note.entry(p.note_id).or_default().push(i);
+    }
+    // 事务外只读+校验+字符级迁移；审查高-3：目标行必须是同一任务
+    // （parse 载荷完全吻合），失效行记 failed 剔除——计数/史/正文一致推进
+    let mut contents: std::collections::HashMap<i64, (String, String)> = Default::default();
+    let mut kept_events: Vec<(String, Option<String>, i64)> = Vec::new();
+    for (note_id, indices) in &by_note {
         let note = db
             .get_note(*note_id)
             .map_err(|e| e.to_string())?
             .ok_or_else(|| format!("笔记 {} 不存在", note_id))?;
         let mut body_lines: Vec<String> = note.content.split('\n').map(|s| s.to_string()).collect();
-        for (line_no, _) in lines {
-            if let Some(line) = body_lines.get_mut(*line_no as usize) {
-                if let Some(next) = migrate_status(line, TaskStatus::Done) {
-                    *line = next;
+        let mut changed = false;
+        for &i in indices {
+            let p = &pendings[i];
+            let line = match body_lines.get(p.line_no as usize) {
+                Some(l) => l.clone(),
+                None => {
+                    view.failed.push(format!("行 {} 已越界（正文变化请刷新后重试）", p.line_no));
+                    continue;
+                }
+            };
+            let Some(parsed) = crate::tasks_core::parse_task_line(&line) else {
+                view.failed.push(format!("行 {} 已非任务行（任务“{}”失效）", p.line_no, p.payload));
+                continue;
+            };
+            if parsed.payload != p.payload {
+                view.failed.push(format!("行 {} 内容已变化（任务“{}”失效，请刷新）", p.line_no, p.payload));
+                continue;
+            }
+            if let Some(next) = crate::tasks_core::migrate_status(&line, TaskStatus::Done) {
+                if next != line {
+                    body_lines[p.line_no as usize] = next;
+                    changed = true;
                 }
             }
+            kept_events.push((p.payload.clone(), p.reason.clone(), *note_id));
+            if p.abandon {
+                view.abandoned += 1;
+            } else {
+                view.done += 1;
+            }
+        }
+        if changed {
+            contents.insert(*note_id, (note.title.clone(), body_lines.join("\n")));
         }
-        contents.insert(*note_id, (note.title.clone(), body_lines.join("\n")));
     }
-    // 单事务提交：正文/索引/完成史原子
+    if kept_events.is_empty() {
+        return Ok(view);
+    }
+    // 单事务提交：正文/索引（kb+task）/完成史原子（任一步失败整体回滚）
     let now = crate::db::unix_seconds();
     let tx: crate::error::Result<()> = db.with_conn(|conn| {
         conn.execute("BEGIN TRANSACTION", [])?;
@@ -163,7 +199,7 @@ pub(crate) fn weekly_resolve_core(
                 for (note_id, (_title, content)) in &contents {
                     stmt.execute(params![content, now, note_id])?;
                     // 派生索引同事务重建（kb 影子表——与 db_notes::update_note 同钩子；
-                    // 绕过高层 update_note 的直写路径必须在此补齐，防 kb 陈旧）
+                    // 绕过高层 update_note 的直写路径必须在此补齐，防 kb/队列陈旧）
                     crate::kb_index::soft_rebuild_note(conn, *note_id, content);
                     crate::db_task_index::rebuild_note_tasks(conn, *note_id, content);
                 }
@@ -173,7 +209,7 @@ pub(crate) fn weekly_resolve_core(
                     "INSERT INTO completion_history (ts, event_type, source_type, source_id, note_id, text, note)
                      VALUES (?1, ?2, 'task_line', NULL, ?3, ?4, ?5)",
                 )?;
-                for (text, reason, note_id) in &events {
+                for (text, reason, note_id) in &kept_events {
                     let event_type = if reason.is_some() { "abandoned" } else { "done" };
                     stmt.execute(params![now, event_type, note_id, text, reason])?;
                 }

app/src-tauri/src/db_fragments.rs

@@ -249,6 +249,8 @@ impl Db {
         // 则在此建笔记分支索引最终正文——事务内软失败记录不阻断）
         if !content.trim().is_empty() {
             crate::kb_index::soft_rebuild_note(&tx, note_id, &content);
+            // v0.20.3（REQ-292）保存收口钩子补齐：升笔记直写路径任务索引同事务
+            crate::db_task_index::rebuild_note_tasks(&tx, note_id, &content);
         }
         tx.commit()?;
         // ⑤ 组装返回（与库内一致）

app/src-tauri/src/db_notes_versions.rs

@@ -141,6 +141,9 @@ impl Db {
         // 单笔记毫秒级）；失败软记录进 kb_meta，主链路（保存）不反悔
         if cur != content {
             crate::kb_index::soft_rebuild_note(&tx, note_id, content);
+            // v0.20.3（REQ-292）保存收口钩子补齐：versioned_save 统一写路径
+            // （显式保存/AI 采纳/回滚/补充）正文变化同事务重扫任务索引
+            crate::db_task_index::rebuild_note_tasks(&tx, note_id, content);
         }
         tx.commit()?;
         Ok(NoteVersion {

app/src-tauri/src/db_task_index.rs

@@ -66,23 +66,51 @@ pub fn rebuild_note_tasks(conn: &Connection, note_id: i64, content: &str) {
 
 fn rebuild_inner(conn: &Connection, note_id: i64, content: &str) -> Result<()> {
     let now = crate::db::unix_seconds();
+    // 重扫前读取旧行元数据（plan_date/disposition/created_at）——行号漂移由
+    // (note_id,line_no) 键吸收；改期/纠偏为索引列元数据，不得被每次正文保存
+    // 的重扫抹除（审查高-1：先删后插必须回填，否则计划分区/徽标失真）
+    let mut meta: std::collections::HashMap<i64, (Option<i64>, Option<String>, i64)> = Default::default();
+    {
+        let mut stmt = conn.prepare(
+            "SELECT line_no, plan_date, disposition, created_at FROM task_index WHERE note_id = ?1",
+        )?;
+        let mapped = stmt.query_map(params![note_id], |r| {
+            Ok((
+                r.get::<_, i64>(0)?,
+                r.get::<_, Option<i64>>(1)?,
+                r.get::<_, Option<String>>(2)?,
+                r.get::<_, i64>(3)?,
+            ))
+        })?;
+        for row in mapped {
+            let (line_no, plan_date, disposition, created_at) = row?;
+            meta.insert(line_no, (plan_date, disposition, created_at));
+        }
+    }
     conn.execute("DELETE FROM task_index WHERE note_id = ?1", params![note_id])?;
     let mut stmt = conn.prepare(
-        "INSERT INTO task_index (note_id, line_no, task_text, status, unrefined, created_at, updated_at)
-         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?6)",
+        "INSERT INTO task_index (note_id, line_no, task_text, status, unrefined, plan_date, disposition, created_at, updated_at)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)",
     )?;
     for (line_no, line) in content.split('\n').enumerate() {
         if let Some(p) = parse_task_line(line) {
             let status = match p.status {
                 TaskStatus::Todo => "todo",
                 TaskStatus::Done => "done",
             };
+            let (plan_date, disposition, created_at) = match meta.get(&(line_no as i64)) {
+                Some((pd, dp, ca)) => (*pd, dp.clone(), *ca),
+                None => (None, None, now),
+            };
             stmt.execute(params![
                 note_id,
                 line_no as i64,
                 p.payload,
                 status,
                 p.unrefined as i64,
+                plan_date,
+                disposition,
+                created_at,
                 now
             ])?;
         }