fix(ai): 审查修复——去重按目标粒度/余额先于配额/采纳幂等/成本模型感知 (P1)

Author: Aparencia

app/src-tauri/src/ai_cost.rs

@@ -120,10 +120,18 @@ pub fn estimate_for_content(chars: usize) -> CostEstimate {
 
 /// 成本记录费用（纯函数：输入+输出 token × 当前单价——与预估同口径，
 /// M4 落库 note_ai_usage 用）。
+#[allow(dead_code)] // 兼容 API：测试 + 旧调用方（新代码走 _model 版）
 pub fn usage_cost(tokens_in: usize, tokens_out: usize) -> f64 {
     estimate_cost(tokens_in.saturating_add(tokens_out), price_per_1m())
 }
 
+/// 成本记录费用（模型感知——审查修复 2026-08-21：落库成本必须与预估同
+/// 口径（模型映射单价），否则付费模型预估 ¥X 但落库记 ¥0，成本报表失真）。
+pub fn usage_cost_for_model(tokens_in: usize, tokens_out: usize, model: &str) -> f64 {
+    let (price, _) = price_for_model(model);
+    estimate_cost(tokens_in.saturating_add(tokens_out), price)
+}
+
 /// 未知模型警告文案（确认弹窗拼接用）。
 #[allow(dead_code)] // 文案单一来源（前端经 priceKnown 自行渲染同文案）
 pub fn unknown_model_warning() -> &'static str {

app/src-tauri/src/ai_cost_tests.rs

@@ -5,7 +5,7 @@ use std::sync::Mutex;
 
 use crate::ai_cost::{
     estimate_cost, estimate_for_content, estimate_for_content_model, estimate_tokens,
-    price_for_model, price_per_1m, DEFAULT_PRICE_PER_1M,
+    price_for_model, price_per_1m, usage_cost_for_model, DEFAULT_PRICE_PER_1M,
 };
 
 /// env 操作互斥（防并行测试互相覆盖 SILICONFLOW_PRICE_PER_1M_TOKENS）。
@@ -113,3 +113,20 @@ fn estimate_for_content_model_respects_mapping() {
         assert_eq!(unknown.est_cost_yuan, 0.0);
     });
 }
+
+/// 审查修复（2026-08-21）：落库成本按模型感知单价（与预估同口径——
+/// 免费档 ¥0；未知模型 ¥0；env 覆盖生效）。
+#[test]
+fn usage_cost_for_model_uses_model_price() {
+    with_env_locked(|| {
+        std::env::remove_var("SILICONFLOW_PRICE_PER_1M_TOKENS");
+        // 免费档模型 → 0
+        assert_eq!(usage_cost_for_model(1000, 500, "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B"), 0.0);
+        // 未知模型 → 0（单价未登记，保守不记成本）
+        assert_eq!(usage_cost_for_model(1000, 500, "unknown/model"), 0.0);
+        // env 覆盖整体生效（开发路径）
+        std::env::set_var("SILICONFLOW_PRICE_PER_1M_TOKENS", "10");
+        let cost = usage_cost_for_model(1000, 500, "unknown/model");
+        assert!((cost - 0.015).abs() < 1e-9, "1500 token × ¥10/1M = ¥0.015，实得 {}", cost);
+    });
+}

app/src-tauri/src/ai_refine_task.rs

@@ -88,7 +88,9 @@ pub 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 设计）
+            // F2 任务中心：终态落库（写库失败不阻断——H2 设计）+ 保留策略
+            // 裁剪（审查修复：trim 原只在启动时跑，运行期终态任务会累积——
+            // 每次终态后清理超限旧终态，防表膨胀）
             let result_json = serde_json::to_string(&result).ok();
             let _ = st.db.finish_ai_task(
                 task_id,
@@ -97,6 +99,7 @@ pub fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool)
                 None,
                 elapsed_ms,
             );
+            let _ = st.db.trim_ai_tasks();
         }
         Err(reason) => {
             // 打印具体 message——区分"未配置密钥"vs"密钥无效(401/403)"（真机排查）
@@ -115,6 +118,7 @@ pub fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool)
                 Some(&format!("{}: {}", reason.kind(), reason.message())),
                 elapsed_ms,
             );
+            let _ = st.db.trim_ai_tasks();
         }
     }
 }

app/src-tauri/src/app_setup.rs

@@ -176,6 +176,8 @@ pub fn setup_app_state(app: &mut tauri::App) -> Result<(), String> {
                     crate::commands_ai_refine::AiTaskEntry {
                         state: crate::ai_task::AiTaskState::Succeeded,
                         result,
+                        // 目标 id（精修=ref_id 即会话 id；补充=笔记 id——去重粒度）
+                        target_id: rec.ref_id,
                     },
                 );
                 max_id = max_id.max(rec.task_id);

app/src-tauri/src/commands_ai_enrich.rs

@@ -90,23 +90,30 @@ pub async fn ai_enrich_start(
             return Err("未配置 API 密钥（设置页保存密钥或配置环境变量 SILICONFLOW_API_KEY）".to_string());
         }
     }
-    // F1 修复（2026-08-21）：任务去重——同笔记存在进行中任务时拒绝重复启动
+    // F1 修复（2026-08-21）+ 审查修复（2026-08-21）：任务去重——按
+    // **目标笔记**粒度检查（防同笔记重复扣费；不同笔记互不阻塞）
     {
         let tasks = st.ai_tasks.lock().map_err(|e| format!("任务注册表锁中毒: {}", e))?;
         let active = tasks.values().any(|t| {
-            matches!(t.state, crate::ai_task::AiTaskState::Pending | crate::ai_task::AiTaskState::Running { .. })
+            t.target_id == note_id
+                && matches!(t.state, crate::ai_task::AiTaskState::Pending | crate::ai_task::AiTaskState::Running { .. })
         });
         if active {
             return Err("该笔记已有进行中的 AI 任务——请等待完成或到任务中心查看进度（防重复扣费）".to_string());
         }
     }
-    // F1 修复（2026-08-21）：每日配额接入——按预估片数消耗（启动前拦截）
+    // F1/F3-D 修复（2026-08-21）：成本硬拦截 + 每日配额接入。
+    // 顺序铁律（审查修复）：先余额拦截（失败不消耗配额），后消耗配额。
     if !mock {
         let note = get_note(&st, note_id)?;
         let chars = note.content.chars().count();
-        let slices = chars.saturating_add(crate::ai_task::SLICE_MAX_CHARS - 1)
-            / crate::ai_task::SLICE_MAX_CHARS
-            + 1;
+        let model = st.ai_settings.lock().map(|s| s.model.clone()).unwrap_or_default();
+        crate::commands_ai_refine::ensure_balance_for(&st, chars, &model)?;
+        let slices = if chars == 0 {
+            0
+        } else {
+            chars.saturating_add(crate::ai_task::SLICE_MAX_CHARS - 1) / crate::ai_task::SLICE_MAX_CHARS
+        };
         let now = crate::db_sessions_rows::unix_seconds();
         let mut guards = st.ai_guardrails.lock().map_err(|e| format!("护栏状态锁中毒: {}", e))?;
         for _ in 0..slices {
@@ -115,15 +122,11 @@ pub async fn ai_enrich_start(
             }
         }
         drop(guards);
-        // F3-D 修复（2026-08-21）：成本硬拦截——启动前校验余额（精修共用
-        // ensure_balance_for：免费档放行、余额不足拒绝、查询失败宽容放行）
-        let model = st.ai_settings.lock().map(|s| s.model.clone()).unwrap_or_default();
-        crate::commands_ai_refine::ensure_balance_for(&st, chars, &model)?;
     }
     let task_id = st.ai_task_seq.fetch_add(1, Ordering::Relaxed);
     {
         let mut tasks = st.ai_tasks.lock().map_err(|e| format!("任务注册表锁中毒: {}", e))?;
-        tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None });
+        tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None, target_id: note_id });
         trim_tasks(&mut tasks);
     }
     // F2 任务中心（2026-08-21）：任务记录落库（写库失败不阻断 AI 调用）
@@ -174,9 +177,11 @@ pub fn ai_enrich_apply(
 ) -> Result<Note, String> {
     // 存在性校验（versioned_save 内部也会校验——提前失败给明确错误）
     get_note(state.inner(), note_id)?;
-    let cost = crate::ai_cost::usage_cost(
+    // 审查修复（2026-08-21）：落库成本用模型感知单价（与预估同口径）
+    let cost = crate::ai_cost::usage_cost_for_model(
         result.base_markdown.chars().count(),
         result.enriched_markdown.chars().count(),
+        &result.model,
     );
     let meta = crate::note_version::VersionMeta {
         cost_yuan: Some(cost),
@@ -207,8 +212,13 @@ pub fn ai_enrich_apply(
             },
         )
         .map_err(|e| e.to_string())?;
-    // F2 任务中心：标记采纳 + 成本回填（task_id 可选；防重启后重复采纳）
+    // F2 任务中心：标记采纳 + 成本回填（task_id 可选；防重启后重复采纳）。
+    // 审查修复（2026-08-21）：服务端前置校验已采纳状态（前端禁用 + 服务端
+    // 兜底双保险——防异常调用重复建笔记）。
     if let Some(tid) = task_id {
+        if state.db.is_ai_task_adopted(tid) {
+            return Err("该任务结果已采纳落库——请勿重复采纳（可到笔记页查看）".to_string());
+        }
         let _ = state.db.mark_ai_task_adopted(tid);
         let _ = state.db.update_ai_task_cost(tid, cost);
     }
@@ -275,11 +285,24 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
                 selected_kinds: selected.clone(),
                 profile: profile.clone(),
             };
-            let resp: AiEnrichResponse = if mock {
-                mock_adapter.enrich(&req, &selected)
-            } else {
-                adapter.enrich(&req, &selected).map_err(AiTaskFailure::from)?
-            };
+            // 单片重试 1 次（审查修复 2026-08-21：与精修 SLICE_RETRY 对齐——
+            // 网络抖动瞬态失败直接重试，避免整任务失败浪费已成功的片）
+            let mut resp: Option<AiEnrichResponse> = None;
+            for attempt in 0..=1 {
+                let r = if mock {
+                    Ok(mock_adapter.enrich(&req, &selected))
+                } else {
+                    adapter.enrich(&req, &selected).map_err(AiTaskFailure::from)
+                };
+                match r {
+                    Ok(v) => { resp = Some(v); break; }
+                    Err(e) if attempt < 1 => {
+                        eprintln!("[enrich-task] task={} 片 {} 第{}次失败，重试: {}", task_id, i + 1, attempt + 1, e.message());
+                    }
+                    Err(e) => return Err(e),
+                }
+            }
+            let resp = resp.expect("重试循环必然产出结果或返回");
             all_blocks.extend(resp.blocks);
             set_task(
                 &st,
@@ -318,7 +341,8 @@ 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 设计）
+            // F2 任务中心：终态落库（写库失败不阻断——H2 设计）+ 保留策略
+            // 裁剪（审查修复：运行期终态后清理超限旧终态，防表膨胀）
             let result_json = serde_json::to_string(&result).ok();
             let _ = st.db.finish_ai_task(
                 task_id,
@@ -327,6 +351,7 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
                 None,
                 elapsed_ms,
             );
+            let _ = st.db.trim_ai_tasks();
         }
         Err(reason) => {
             set_task(&st, task_id, AiTaskState::Failed { reason: reason.clone() });
@@ -338,6 +363,7 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
                 Some(&format!("{}: {}", reason.kind(), reason.message())),
                 elapsed_ms,
             );
+            let _ = st.db.trim_ai_tasks();
         }
     }
 }

app/src-tauri/src/commands_ai_refine.rs

@@ -36,6 +36,9 @@ const TASKS_CAP: usize = 100;
 pub struct AiTaskEntry {
     pub state: AiTaskState,
     pub result: Option<serde_json::Value>,
+    /// 任务目标（去重粒度：精修=session_id、补充=note_id——审查修复
+    /// 2026-08-21：原实现按全表 any 检查，会话 A 精修中时会话 B 也被拒）
+    pub target_id: i64,
 }
 
 /// 精修成功载荷（前端 diff 预览 + 采纳落库数据源）。
@@ -118,28 +121,36 @@ pub async fn ai_refine_start(
             return Err("未配置 API 密钥（设置页保存密钥或配置环境变量 SILICONFLOW_API_KEY）".to_string());
         }
     }
-    // ②b F1 修复（2026-08-21）：任务去重——同一会话存在进行中任务时拒绝
-    // 重复启动（防双击/重进/多窗口重复扣费；终态任务不阻塞重试）
+    // ②b F1 修复（2026-08-21）+ 审查修复（2026-08-21）：任务去重——按
+    // **目标会话**粒度检查进行中任务（防双击/重进/多窗口对同一会话重复
+    // 扣费；不同会话的任务互不阻塞——原实现全表 any 会误伤其他会话）
     {
         let tasks = st.ai_tasks.lock().map_err(|e| format!("任务注册表锁中毒: {}", e))?;
         let active = tasks.values().any(|t| {
-            matches!(t.state, AiTaskState::Pending | AiTaskState::Running { .. })
+            t.target_id == session_id
+                && matches!(t.state, AiTaskState::Pending | AiTaskState::Running { .. })
         });
         if active {
             return Err("该会话已有进行中的 AI 任务——请等待完成或到任务中心查看进度（防重复扣费）".to_string());
         }
     }
-    // ②c F1 修复（2026-08-21）：每日配额接入——按预估片数消耗（启动前
-    // 拦截而非失败后引导；耗尽 → 明确提示明日再试，REQ-145 配额出口）
+    // ②c F1/F3-D 修复（2026-08-21）：成本硬拦截 + 每日配额接入。
+    // 顺序铁律（审查修复）：先余额拦截（失败不消耗配额），后消耗配额——
+    // 否则余额不足被拒时配额已扣（浪费每日额度）。
     if !mock {
         let segments = st.db.list_segments(session_id).map_err(|e| e.to_string())?;
         let ocr = st.db.list_ocr_blocks(session_id).map_err(|e| e.to_string())?;
         let chars = segments.iter().map(|s| s.text.chars().count()).sum::<usize>()
             + ocr.iter().map(|b| b.text.chars().count()).sum::<usize>();
-        // 片数估算（与 ai_task::slice_note 同口径的保守上界：字符数 / 单片上限 + 1）
-        let slices = chars.saturating_add(crate::ai_task::SLICE_MAX_CHARS - 1)
-            / crate::ai_task::SLICE_MAX_CHARS
-            + 1;
+        // 成本硬拦截（免费档 ¥0 预估 → 余额 0 也放行；查询失败宽容放行）
+        ensure_balance_for(&st, chars, &settings.model)?;
+        // 片数估算（与 ai_task::slice_note 同口径的保守上界：向上取整，
+        // 空内容 0 片不消耗配额——审查修复：原公式 +1 导致空会话也扣 1）
+        let slices = if chars == 0 {
+            0
+        } else {
+            chars.saturating_add(crate::ai_task::SLICE_MAX_CHARS - 1) / crate::ai_task::SLICE_MAX_CHARS
+        };
         let now = crate::db_sessions_rows::unix_seconds();
         let mut guards = st.ai_guardrails.lock().map_err(|e| format!("护栏状态锁中毒: {}", e))?;
         for _ in 0..slices {
@@ -148,16 +159,12 @@ pub async fn ai_refine_start(
             }
         }
         drop(guards);
-        // ②d F3-D 修复（2026-08-21）：成本硬拦截——启动前校验余额
-        // （余额 < 预估×安全系数 → 拒绝启动 + 三出口引导；不产生"跑完
-        // 才 402 失败"的浪费；免费档 ¥0 预估 → 余额 0 也放行）
-        ensure_balance_for(&st, chars, &settings.model)?;
     }
     // ③ 注册任务 + 后台执行（spawn_blocking——网络/分析不阻塞异步运行时）
     let task_id = st.ai_task_seq.fetch_add(1, Ordering::Relaxed);
     {
         let mut tasks = st.ai_tasks.lock().map_err(|e| format!("任务注册表锁中毒: {}", e))?;
-        tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None });
+        tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None, target_id: session_id });
         trim_tasks(&mut tasks);
     }
     // F2 任务中心（2026-08-21）：任务记录落库（pending 起步；终态在
@@ -259,9 +266,12 @@ pub fn ai_refine_apply(
     };
     let note = state.db.create_note(&new).map_err(|e| e.to_string())?;
     // ② 精修版落库（新版本 ai-refine + 成本 meta）
-    let cost = crate::ai_cost::usage_cost(
+    // 审查修复（2026-08-21）：落库成本用模型感知单价（与预估同口径——
+    // 付费模型预估 ¥X 不再记 ¥0）
+    let cost = crate::ai_cost::usage_cost_for_model(
         result.base_markdown.chars().count(),
         result.refined_markdown.chars().count(),
+        &result.model,
     );
     let meta = crate::note_version::VersionMeta {
         cost_yuan: Some(cost),
@@ -294,8 +304,13 @@ pub fn ai_refine_apply(
         )
         .map_err(|e| e.to_string())?;
     // F2 任务中心：标记采纳 + 成本回填（task_id 可选——旧前端调用不传则跳过；
-    // 防重启后从任务中心重复采纳产生重复笔记）
+    // 防重启后从任务中心重复采纳产生重复笔记）。
+    // 审查修复（2026-08-21）：服务端前置校验已采纳状态——防异常/重复调用
+    // 绕过前端 UI 直接重复建笔记（前端禁用 + 服务端兜底双保险）。
     if let Some(tid) = task_id {
+        if state.db.is_ai_task_adopted(tid) {
+            return Err("该任务结果已采纳落库——请勿重复采纳（可到笔记页查看）".to_string());
+        }
         let _ = state.db.mark_ai_task_adopted(tid);
         let _ = state.db.update_ai_task_cost(tid, cost);
     }

app/src-tauri/src/db_ai_tasks.rs

@@ -125,6 +125,22 @@ impl Db {
         Ok(())
     }
 
+    /// 查询任务是否已采纳（apply 前置校验——服务端防重复采纳兜底；
+    /// 任务不存在/查询失败视为未采纳——旧任务无记录时放行，防御方向保守）。
+    pub fn is_ai_task_adopted(&self, task_id: u64) -> bool {
+        let conn = match self.conn.lock() {
+            Ok(c) => c,
+            Err(e) => e.into_inner(),
+        };
+        conn.query_row(
+            "SELECT adopted FROM ai_tasks WHERE task_id=?1",
+            params![task_id as i64],
+            |row| row.get::<_, i64>(0),
+        )
+        .map(|v| v != 0)
+        .unwrap_or(false)
+    }
+
     /// 回填成本（apply 落库成本后；task_id 由前端回传——result 携带）。
     pub fn update_ai_task_cost(&self, task_id: u64, cost_yuan: f64) -> Result<()> {
         let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());

app/src-tauri/src/db_ai_tasks_tests.rs

@@ -120,3 +120,16 @@ fn cost_backfill_updates_record() {
     let list = db.list_ai_tasks("refine", 10).unwrap();
     assert_eq!(list[0].cost_yuan, Some(0.5));
 }
+
+#[test]
+fn adopted_query_true_after_mark_false_otherwise() {
+    let db = open_mem();
+    db.insert_ai_task(&rec(8, "refine", 4, "succeeded")).unwrap();
+    // 未采纳 → false
+    assert!(!db.is_ai_task_adopted(8));
+    // 标记后 → true
+    db.mark_ai_task_adopted(8).unwrap();
+    assert!(db.is_ai_task_adopted(8));
+    // 不存在的任务 → false（防御方向保守——旧任务无记录放行）
+    assert!(!db.is_ai_task_adopted(999));
+}