fix(tasks): proofread 任务 id 认领并入各族统一单调分配（去 +1 偏移）

Author: Aparencia

app/src-tauri/src/commands_ai_refine.rs

@@ -205,8 +205,10 @@ pub async fn ai_refine_start(
         }
         drop(guards);
     }
-    // ③ 注册任务 + 后台执行（spawn_blocking——网络/分析不阻塞异步运行时）
-    let task_id = st.ai_task_seq.fetch_add(1, Ordering::Relaxed);
+    // ③ 注册任务 + 后台执行（spawn_blocking——网络/分析不阻塞异步运行时）；
+    // 任务 id 走全任务族统一认领封装（claim_task_id——见其 Why：proofread
+    // 原 +1 偏移与各族口径冲突，相邻认领撞 id 会被 INSERT OR REPLACE 顶替）
+    let task_id = claim_task_id(&st.ai_task_seq);
     {
         let mut tasks = st.ai_tasks.lock().map_err(|e| format!("任务注册表锁中毒: {}", e))?;
         tasks.insert(task_id, AiTaskEntry { state: AiTaskState::Pending, result: None, target_id: session_id });
@@ -616,6 +618,24 @@ pub fn task_seq_lower_bound(current: u64, db_max_task_id: u64) -> u64 {
     current.max(db_max_task_id.saturating_add(1))
 }
 
+/// 认领下一个 AI 任务 id（全任务族唯一分配点——proofread/refine/enrich/
+/// note_refine/goal_plan 共用的单调序列，返回值即 task_id，推进量=认领量）。
+///
+/// @ai-context Why（2026-09-09 批 2 审查修复）：proofread 原写作
+///              fetch_add(1, SeqCst) + 1（+1 存量来源 1904c2c7——按「0 起
+///              序列」直觉，但 task_seq() 初值 1 且其余族均以 fetch_add
+///              返回值直接作 id）。fetch_add(1)+1 只把计数器推进 1 却领走
+///              后值：紧邻的下一次认领（任意其他族）恰好拿到同一 id →
+///              insert_ai_task 的 INSERT OR REPLACE 运行期顶替先落库行
+///              （running 记账/结果/成本丢行）。统一本函数分配：认领严格
+///              单调、相邻认领永不相交。Relaxed 即足——唯一性由 fetch_add
+///              原子读-改-写保证，无需跨线程同步排序（与启动序列下限
+///              fetch_update 及 enrich/note_refine/goal_plan 现场同式内联
+///              的 Relaxed 同档，口径一致）。
+pub fn claim_task_id(seq: &AtomicU64) -> u64 {
+    seq.fetch_add(1, Ordering::Relaxed)
+}
+
 /// 任务注册表（AppState 装配）。
 pub fn task_registry() -> Arc<Mutex<HashMap<u64, AiTaskEntry>>> {
     Arc::new(Mutex::new(HashMap::new()))

app/src-tauri/src/commands_proofread.rs

@@ -158,7 +158,12 @@ pub async fn proofread_run(
     let expected: Vec<&str> = flat.iter().take(take).map(|(_, s)| *s).collect();
     let chars: usize = expected.iter().map(|s| s.chars().count()).sum();
 
-    let task_id = st.ai_task_seq.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + 1;
+    // 任务 id 认领走全任务族统一封装（claim_task_id——见其 Why：proofread
+    // 原 fetch_add(1, SeqCst) + 1（+1 存量来源 1904c2c7）与 refine/enrich/
+    // note_refine/goal_plan 的裸 fetch_add 口径冲突——fetch_add 只推进 1 却
+    // 领走后值，跨任务族紧邻认领会撞同 id，被 insert_ai_task 的 INSERT OR
+    // REPLACE 运行期顶替；修复：去掉 +1，与其他族同一单调分配）
+    let task_id = crate::commands_ai_refine::claim_task_id(&st.ai_task_seq);
     let created_at = crate::db::unix_seconds();
     let _ = db.insert_ai_task(&crate::db_ai_tasks::AiTaskRecord {
         task_id,
@@ -372,3 +377,7 @@ pub fn proofread_list(
         items,
     })
 }
+
+#[cfg(test)]
+#[path = "commands_proofread_tests.rs"]
+mod tests;

app/src-tauri/src/commands_proofread_tests.rs

@@ -0,0 +1,54 @@
+//! commands_proofread.rs 单测（AAA 模式；内存态原子——不触库/网络）。
+//!
+//! @ai-context: 覆盖任务 id 认领语义——proofread 族与其余任务族（refine/
+//!              enrich/note_refine/goal_plan）共用 AppState.ai_task_seq 同一
+//!              单调序列（P2-1 审查修复回归，见 claim_task_id Why）。
+
+use crate::commands_ai_refine::{claim_task_id, task_seq};
+
+/// AAA（P2-1 回归）：proofread 认领 N 后任意其他族紧邻认领 ≠ N——
+/// 相邻认领不相交。修复前 proofread 为 fetch_add(1)+1（1904c2c7 引入）：
+/// 计数器 1→2 却领走 2，其他族紧邻 fetch_add 恰好也返回 2——跨任务族
+/// 同 id，insert_ai_task 的 INSERT OR REPLACE 会顶替先落库的 proofread 行
+/// （running 记账/结果/成本丢行）。
+#[test]
+fn proofread_claim_then_adjacent_family_claim_do_not_collide() {
+    // Arrange：与装配等价的序列起点（task_seq() 初值 1——app_setup 即以此
+    // 装配 AppState.ai_task_seq；proofread_run 现与 refine 同一封装认领）
+    let seq = task_seq();
+    // Act：proofread 族先认领 N，任意其他族紧邻认领（生产同一代码路径）
+    let proofread_id = claim_task_id(&seq);
+    let other_family_id = claim_task_id(&seq);
+    // Assert：相邻认领不相交（修复前两者都 = 2）
+    assert_ne!(
+        proofread_id, other_family_id,
+        "proofread 与相邻认领不得撞 id（撞 id 会被 INSERT OR REPLACE 顶替）"
+    );
+    // 序列语义回归：初值 1 起逐号分配；认领后计数器越过所领 id（修复前
+    // proofread 认领后计数器仍停在所领 id 上——同一破绽的另一面）
+    assert_eq!(proofread_id, 1, "首个 id 应为 1（task_seq 初值语义）");
+    assert_eq!(other_family_id, 2, "紧邻认领应为下一号");
+    assert_eq!(seq.load(std::sync::atomic::Ordering::Relaxed), 3);
+}
+
+/// AAA：认领与启动序列下限的衔接——DB 最大 id 为 41 时（含历史行），重启后
+/// proofread 首个认领必须 ≥42（防复用历史 task_id 顶替已采纳行——与批 1
+/// task_seq_lower_bound 语义闭合，proofread 无特殊偏移）。
+#[test]
+fn proofread_claim_after_startup_lower_bound_never_reuses_db_rows() {
+    // Arrange：启动序列按 DB 全表最大 id 41 推进（app_setup fetch_update）
+    let seq = task_seq();
+    let _ = seq.fetch_update(
+        std::sync::atomic::Ordering::Relaxed,
+        std::sync::atomic::Ordering::Relaxed,
+        |cur| Some(crate::commands_ai_refine::task_seq_lower_bound(cur, 41)),
+    );
+    // Act：proofread 族认领 + 紧邻其他族认领
+    let proofread_id = claim_task_id(&seq);
+    let other_family_id = claim_task_id(&seq);
+    // Assert：从 42 起且互不相交（修复前 proofread fetch_add(1)+1 在计数器
+    // 42 处领走 43，紧邻族 fetch_add 返回 43——同 id 相撞，同上顶替风险）
+    assert_eq!(proofread_id, 42, "proofread 首个认领须越过 DB 最大 id");
+    assert_eq!(other_family_id, 43);
+    assert_ne!(proofread_id, other_family_id);
+}