feat(ai): 任务中心持久化——ai_tasks 表/启动恢复/采纳标记/历史查询 (F2-B1/B2)

Author: Aparencia

app/src-tauri/src/app_setup.rs

@@ -153,6 +153,40 @@ 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 冲突覆盖）
+    {
+        let restored = db
+            .list_restorable_succeeded(100)
+            .unwrap_or_else(|e| {
+                eprintln!("[ai-tasks] 恢复失败（注册表空启动）: {}", e);
+                Vec::new()
+            });
+        if let Ok(mut tasks) = ai_tasks.lock() {
+            let mut max_id = 0u64;
+            for rec in &restored {
+                let result = rec
+                    .result_json
+                    .as_deref()
+                    .and_then(|s| serde_json::from_str(s).ok());
+                tasks.insert(
+                    rec.task_id,
+                    crate::commands_ai_refine::AiTaskEntry {
+                        state: crate::ai_task::AiTaskState::Succeeded,
+                        result,
+                    },
+                );
+                max_id = max_id.max(rec.task_id);
+            }
+            // id 序列越过恢复的最大 id——新任务不复用旧 id（防覆盖已恢复结果）
+            let _ = ai_task_seq.fetch_update(
+                std::sync::atomic::Ordering::Relaxed,
+                std::sync::atomic::Ordering::Relaxed,
+                |cur| Some(cur.max(max_id + 1)),
+            );
+            eprintln!("[ai-tasks] 启动恢复 {} 条未采纳任务", restored.len());
+        }
+    }
     app.manage(AppState {
         db,
         engines,

app/src-tauri/src/commands_ai_enrich.rs

@@ -122,6 +122,22 @@ pub async fn ai_enrich_start(
         tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None });
         trim_tasks(&mut tasks);
     }
+    // F2 任务中心（2026-08-21）：任务记录落库（写库失败不阻断 AI 调用）
+    let _ = st.db.insert_ai_task(&crate::db_ai_tasks::AiTaskRecord {
+        task_id,
+        op_type: "enrich".to_string(),
+        ref_id: note_id,
+        state: "pending".to_string(),
+        result_json: None,
+        cost_yuan: None,
+        elapsed_ms: None,
+        model: None,
+        error: None,
+        slices: None,
+        created_at: crate::db_sessions_rows::unix_seconds(),
+        finished_at: None,
+        adopted: false,
+    });
     let st2 = st.clone();
     tauri::async_runtime::spawn_blocking(move || run_enrich_task(st2, task_id, note_id, kinds, mock));
     Ok(AiTaskHandle { task_id, state: AiTaskState::Pending })
@@ -143,11 +159,14 @@ pub fn ai_enrich_result(state: State<'_, AppState>, task_id: u64) -> Result<AiEn
 
 /// 采纳落库（v0.8.0 M4 版本化写路径：新版本 ai-enrich + 成本 meta +
 /// note_ai_usage 落库——"重新生成"从覆盖变为新版本）。
+/// @ai-context: F2（2026-08-21）：task_id 可选——传入时标记任务已采纳
+///              （防重启后从任务中心重复采纳）。
 #[tauri::command]
 pub fn ai_enrich_apply(
     state: State<'_, AppState>,
     note_id: i64,
     result: AiEnrichResult,
+    task_id: Option<u64>,
 ) -> Result<Note, String> {
     // 存在性校验（versioned_save 内部也会校验——提前失败给明确错误）
     get_note(state.inner(), note_id)?;
@@ -184,6 +203,11 @@ pub fn ai_enrich_apply(
             },
         )
         .map_err(|e| e.to_string())?;
+    // F2 任务中心：标记采纳 + 成本回填（task_id 可选；防重启后重复采纳）
+    if let Some(tid) = task_id {
+        let _ = state.db.mark_ai_task_adopted(tid);
+        let _ = state.db.update_ai_task_cost(tid, cost);
+    }
     get_note(state.inner(), note_id)
 }
 
@@ -213,6 +237,7 @@ pub fn ai_enrich_revert(
 
 /// 后台补充任务：读笔记 → 切片 → 逐片批量补充（mock/云端）→ 合并 → 混合落位。
 fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnrichKind>, mock: bool) {
+    let started = std::time::Instant::now();
     let outcome: Result<AiEnrichResult, AiTaskFailure> = (|| {
         let note = st
             .db
@@ -277,6 +302,7 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
             model: client.config.model,
         })
     })();
+    let elapsed_ms = started.elapsed().as_millis() as i64;
     match outcome {
         Ok(result) => {
             {
@@ -288,10 +314,26 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
             set_task(&st, task_id, AiTaskState::Succeeded);
             // F1 修复（2026-08-21）：补充调用上审计（REQ-140 轨迹可见化）
             push_enrich_audit(&st, note_id, "ok", Some(&result.model));
+            // F2 任务中心：终态落库（写库失败不阻断——H2 设计）
+            let result_json = serde_json::to_string(&result).ok();
+            let _ = st.db.finish_ai_task(
+                task_id,
+                "succeeded",
+                result_json.as_deref(),
+                None,
+                elapsed_ms,
+            );
         }
         Err(reason) => {
-            set_task(&st, task_id, AiTaskState::Failed { reason });
+            set_task(&st, task_id, AiTaskState::Failed { reason: reason.clone() });
             push_enrich_audit(&st, note_id, "error", None);
+            let _ = st.db.finish_ai_task(
+                task_id,
+                "failed",
+                None,
+                Some(&format!("{}: {}", reason.kind(), reason.message())),
+                elapsed_ms,
+            );
         }
     }
 }

app/src-tauri/src/commands_ai_refine.rs

@@ -162,6 +162,23 @@ pub async fn ai_refine_start(
         tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None });
         trim_tasks(&mut tasks);
     }
+    // F2 任务中心（2026-08-21）：任务记录落库（pending 起步；终态在
+    // run_refine_task 回写——写库失败不阻断 AI 调用，H2 设计）
+    let _ = st.db.insert_ai_task(&crate::db_ai_tasks::AiTaskRecord {
+        task_id,
+        op_type: "refine".to_string(),
+        ref_id: session_id,
+        state: "pending".to_string(),
+        result_json: None,
+        cost_yuan: None,
+        elapsed_ms: None,
+        model: None,
+        error: None,
+        slices: None,
+        created_at: crate::db_sessions_rows::unix_seconds(),
+        finished_at: None,
+        adopted: false,
+    });
     let st2 = st.clone();
     tauri::async_runtime::spawn_blocking(move || run_refine_task(st2, task_id, session_id, mock));
     Ok(AiTaskHandle { task_id, state: AiTaskState::Pending })
@@ -195,14 +212,33 @@ pub fn ai_refine_result(state: State<'_, AppState>, task_id: u64) -> Result<AiRe
     }
 }
 
+/// 任务历史（F2 任务中心：前端面板数据源——按类型列最近任务）。
+#[tauri::command]
+pub fn ai_task_history(
+    state: State<'_, AppState>,
+    op_type: String,
+    limit: Option<usize>,
+) -> Result<Vec<crate::db_ai_tasks::AiTaskRecord>, String> {
+    if op_type != "refine" && op_type != "enrich" {
+        return Err("无效的任务类型（refine|enrich）".to_string());
+    }
+    state
+        .db
+        .list_ai_tasks(&op_type, limit.unwrap_or(50).min(200))
+        .map_err(|e| e.to_string())
+}
+
 /// 采纳落库（REQ-141：diff 预览后用户采纳；v0.8.0 M4 版本化写路径——
 /// ① 以规则基线建笔记（首快照）→ ② 精修版 = 新版本（ai-refine，含成本
 /// meta）→ ③ 成本落库 note_ai_usage）。
+/// @ai-context: F2（2026-08-21）：task_id 可选——传入时标记任务已采纳
+///              （防重启后从任务中心重复采纳产生重复笔记）。
 #[tauri::command]
 pub fn ai_refine_apply(
     state: State<'_, AppState>,
     session_id: i64,
     result: AiRefineResult,
+    task_id: Option<u64>,
 ) -> Result<Note, String> {
     if session_id <= 0 {
         return Err("无效的会话 id".to_string());
@@ -259,6 +295,12 @@ pub fn ai_refine_apply(
             },
         )
         .map_err(|e| e.to_string())?;
+    // F2 任务中心：标记采纳 + 成本回填（task_id 可选——旧前端调用不传则跳过；
+    // 防重启后从任务中心重复采纳产生重复笔记）
+    if let Some(tid) = task_id {
+        let _ = state.db.mark_ai_task_adopted(tid);
+        let _ = state.db.update_ai_task_cost(tid, cost);
+    }
     state
         .db
         .get_note(note.id)
@@ -279,6 +321,7 @@ pub fn ai_refine_apply(
 fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool) {
     // 诊断日志（2026-08-21 真机"排队中"排查）：tauri dev 终端可见各阶段进度
     eprintln!("[refine-task] task={} start session={} mock={}", task_id, session_id, mock);
+    let started = std::time::Instant::now();
     let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
         run_refine_task_inner(&st, task_id, session_id, mock)
     }))
@@ -287,6 +330,7 @@ fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool) {
             "精修任务内部错误（panic）——请重试；若复现请反馈".to_string(),
         ))
     });
+    let elapsed_ms = started.elapsed().as_millis() as i64;
     match outcome {
         Ok(result) => {
             eprintln!(
@@ -305,6 +349,15 @@ fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool) {
             // F1 修复（2026-08-21）：精修调用上审计——REQ-140 轨迹可见化
             // （此前只有余额/测试连接/复核有记录，精修补充零审计）
             push_refine_audit(&st, session_id, "ok", Some(&result.model));
+            // F2 任务中心：终态落库（写库失败不阻断——H2 设计）
+            let result_json = serde_json::to_string(&result).ok();
+            let _ = st.db.finish_ai_task(
+                task_id,
+                "succeeded",
+                result_json.as_deref(),
+                None,
+                elapsed_ms,
+            );
         }
         Err(reason) => {
             // 打印具体 message——区分"未配置密钥"vs"密钥无效(401/403)"（真机排查）
@@ -314,8 +367,15 @@ fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool) {
                 reason.kind(),
                 reason.message()
             );
-            set_task(&st, task_id, AiTaskState::Failed { reason });
+            set_task(&st, task_id, AiTaskState::Failed { reason: reason.clone() });
             push_refine_audit(&st, session_id, "error", None);
+            let _ = st.db.finish_ai_task(
+                task_id,
+                "failed",
+                None,
+                Some(&format!("{}: {}", reason.kind(), reason.message())),
+                elapsed_ms,
+            );
         }
     }
 }

app/src-tauri/src/db.rs

@@ -178,7 +178,10 @@ impl Db {
         // v0.8.0 M4（REQ-144）：笔记版本快照链 + AI 成本记录（幂等建表）
         crate::db_notes_versions::init(&conn)?;
         crate::db_ai_usage::init(&conn)?;
-        Ok(Self { conn: Arc::new(Mutex::new(conn)) })
+        // v0.8.0 F2（2026-08-21）：AI 任务中心持久化（任务记录/恢复/保留）
+        let db = Self { conn: Arc::new(Mutex::new(conn)) };
+        db.init_ai_tasks()?;
+        Ok(db)
     }
 
     /// 新建笔记，返回含 id 与时间戳的完整记录。