fix(tasks): AI 任务 id 序列以 DB 全表最大 id 为基准防重启复用顶替历史行

启动恢复仅按「succeeded 且未采纳」恢复集越过 id 序列，已采纳/failed/
proofread/goal_plan 等 id 更大的历史行被漏掉——重启后新任务复用旧
task_id，insert_ai_task 的 INSERT OR REPLACE 静默顶替历史行（含已采纳
的结果/成本/轨迹）。基准改查 ai_tasks 全表 MAX（max_ai_task_id，空表
NULL→0），推进下限为纯函数 task_seq_lower_bound（saturating 防溢出，
序列只前进不回退）；查询失败降级旧恢复集口径不放大风险。新增单测：
全状态行 max（回归形状 80/95/120→120）、空表 0、序列下限边界。

Author: Aparencia

app/src-tauri/src/app_setup.rs

@@ -196,8 +196,11 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
     // 执行，前端轮询/事件双通道——禁止同步阻塞 30s+ 长会话精修）
     let ai_tasks = crate::commands_ai_refine::task_registry();
     let ai_task_seq = crate::commands_ai_refine::task_seq();
-    // v0.8.0 F2（2026-08-21）：任务中心——启动恢复未采纳的成功结果
-    // （重启不丢；注册表 + id 序列以恢复结果为基准，防 id 冲突覆盖）
+    // v0.8.0 F2（2026-08-21）：任务中心——启动恢复未采纳的成功结果（重启
+    // 不丢；注册表以恢复集为准）。id 序列以 **DB 全表最大 id** 为基准防冲突
+    // （2026-09-09 批 1 修复：旧口径只按恢复集 max+1，会漏掉已采纳/failed/
+    // proofread/goal_plan 等 id 更大的历史行——重启后新任务复用旧 task_id，
+    // insert_ai_task 的 INSERT OR REPLACE 静默顶替历史行含已采纳，见下）
     {
         // 保留策略先行（清理超限旧终态——防表膨胀）
         let _ = db.trim_ai_tasks();
@@ -207,8 +210,13 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
                 eprintln!("[ai-tasks] 恢复失败（注册表空启动）: {}", e);
                 Vec::new()
             });
+        // 序列基准 = DB 全表 max（覆盖所有状态行）；查询失败降级为恢复集
+        // 口径（旧行为——DB 不可读时新任务也难落库，风险不放大）
+        let db_max_task_id = db.max_ai_task_id().unwrap_or_else(|e| {
+            eprintln!("[ai-tasks] 查询任务表最大 id 失败（按恢复集口径推进序列）: {}", e);
+            restored.iter().map(|r| r.task_id).max().unwrap_or(0)
+        });
         if let Ok(mut tasks) = ai_tasks.lock() {
-            let mut max_id = 0u64;
             for rec in &restored {
                 let result = rec
                     .result_json
@@ -223,13 +231,13 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
                         target_id: rec.ref_id,
                     },
                 );
-                max_id = max_id.max(rec.task_id);
             }
-            // id 序列越过恢复的最大 id——新任务不复用旧 id（防覆盖已恢复结果）
+            // id 序列越过 DB 最大 id——新任务不复用任何历史行 id
+            // （防 INSERT OR REPLACE 顶替已采纳/失败等历史行）
             let _ = ai_task_seq.fetch_update(
                 std::sync::atomic::Ordering::Relaxed,
                 std::sync::atomic::Ordering::Relaxed,
-                |cur| Some(cur.max(max_id + 1)),
+                |cur| Some(crate::commands_ai_refine::task_seq_lower_bound(cur, db_max_task_id)),
             );
             eprintln!("[ai-tasks] 启动恢复 {} 条未采纳任务", restored.len());
         }

app/src-tauri/src/commands_ai_refine.rs

@@ -604,6 +604,18 @@ pub fn task_seq() -> Arc<AtomicU64> {
     Arc::new(AtomicU64::new(1))
 }
 
+/// id 序列下限（纯函数）：取「当前值」与「DB 最大 task_id + 1」之大。
+///
+/// @ai-context Why（2026-09-09 批 1 修复）：启动恢复后序列必须越过 **DB
+///              全表** 最大 id——恢复集只含未采纳成功任务，已采纳/failed/
+///              proofread/goal_plan 行 id 更大时，若只按恢复集推进，新任务
+///              将复用历史 task_id 并被 insert_ai_task 的 INSERT OR REPLACE
+///              静默顶替（历史行含已采纳——数据丢失）。saturating 防极端 id
+///              溢出；序列只前进不回退（当前值更大时保持）。
+pub fn task_seq_lower_bound(current: u64, db_max_task_id: u64) -> u64 {
+    current.max(db_max_task_id.saturating_add(1))
+}
+
 /// 任务注册表（AppState 装配）。
 pub fn task_registry() -> Arc<Mutex<HashMap<u64, AiTaskEntry>>> {
     Arc::new(Mutex::new(HashMap::new()))

app/src-tauri/src/db_ai_tasks.rs

@@ -204,6 +204,24 @@ impl Db {
         .map_err(Into::into)
     }
 
+    /// 表内当前最大 task_id（应用启动时 id 序列基准；空表 → 0）。
+    ///
+    /// @ai-context Why（2026-09-09 批 1 修复）：恢复列表只含「succeeded 且
+    ///              未采纳」行，而已采纳/failed/proofread/goal_plan 等行的
+    ///              id 往往更大——启动序列若只越过恢复集 max，重启后新任务
+    ///              会复用历史 task_id，insert_ai_task 的 INSERT OR REPLACE
+    ///              静默顶替历史行（含已采纳的结果/成本/轨迹——数据丢失）。
+    ///              基准改查全表 max：覆盖全部状态的行，序列只前进不回退。
+    pub fn max_ai_task_id(&self) -> Result<u64> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        // 空表时 MAX() 返回单行 NULL——须 Option<i64> 读取（rusqlite 严格类型，
+        // 教训同 get_ai_task_trajectory 的 NULL 列修复），再拍平为 0
+        let max: Option<Option<i64>> = conn
+            .query_row("SELECT MAX(task_id) FROM ai_tasks", [], |r| r.get(0))
+            .optional()?;
+        Ok(max.flatten().unwrap_or(0).max(0) as u64)
+    }
+
     /// 恢复未采纳的成功结果（应用启动时；供任务面板 + 结果重取）。
     pub fn list_restorable_succeeded(&self, limit: usize) -> Result<Vec<AiTaskRecord>> {
         let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());

app/src-tauri/src/db_ai_tasks_tests.rs

@@ -2,7 +2,10 @@
 //!
 //! @ai-context: 覆盖：插入/终态更新/采纳标记/成本回填/恢复（未采纳成功
 //!              结果）/历史列表/保留策略（每类型 50 条上限清理最旧）。
+//! @ai-context 2026-09-09 批 1：任务表最大 id 查询 + 启动序列下限纯函数
+//!              （防重启后新任务复用历史 task_id 顶替历史行——含已采纳）。
 
+use crate::commands_ai_refine::task_seq_lower_bound;
 use crate::db::Db;
 use crate::db_ai_tasks::{AiTaskRecord, TASKS_KEEP_PER_TYPE};
 
@@ -150,3 +153,33 @@ fn adopted_query_true_after_mark_false_otherwise() {
     // 不存在的任务 → false（防御方向保守——旧任务无记录放行）
     assert!(!db.is_ai_task_adopted(999));
 }
+
+#[test]
+fn max_task_id_spans_all_states_not_only_restorable() {
+    // Arrange（2026-09-09 批 1 回归形状）：id 更大的已采纳/failed/running
+    // 行均不在启动恢复集——旧实现按恢复集越序列会漏掉它们，重启后新任务
+    // 复用这些 task_id 并 REPLACE 顶替（含已采纳——数据丢失）
+    let db = open_mem();
+    let mut adopted = rec(80, "refine", 1, "succeeded");
+    adopted.adopted = true;
+    db.insert_ai_task(&adopted).unwrap();
+    db.insert_ai_task(&rec(120, "refine", 2, "failed")).unwrap();
+    db.insert_ai_task(&rec(95, "enrich", 3, "running")).unwrap();
+    // Act + Assert：全表最大 id = 120（不被恢复集 80 封顶）
+    assert_eq!(db.max_ai_task_id().unwrap(), 120);
+    // 空表 → 0（序列下限不后退，起点维持 1）
+    assert_eq!(open_mem().max_ai_task_id().unwrap(), 0);
+}
+
+#[test]
+fn seq_lower_bound_never_reuses_existing_row_ids() {
+    // 空表（db_max=0）→ 至少 1（与 task_seq 初始值一致）
+    assert_eq!(task_seq_lower_bound(1, 0), 1);
+    // DB 最大 id 41（如已采纳历史行）→ 下限 42：新任务不复用 1..=41
+    assert_eq!(task_seq_lower_bound(1, 41), 42);
+    assert_eq!(task_seq_lower_bound(10, 41), 42);
+    // 当前值已更大 → 只前进不回退
+    assert_eq!(task_seq_lower_bound(300, 41), 300);
+    // 极端：u64::MAX 不 panic（saturating_add）且不前进
+    assert_eq!(task_seq_lower_bound(u64::MAX, u64::MAX), u64::MAX);
+}