fix(ai): 修复精修工作台采纳前右侧恒空与精修线路优化

refine_workbench 仅按已落库笔记取精修版导致采纳前右侧恒空（且事件先于 DB 落库存在竞态）。修复：三级数据源（refineResult 参数 > 未采纳成功任务 > 已落库笔记）+ Db::find_latest_unadopted_refine 持久化兜底；线路优化：完成即自动打开工作台、采纳落库回传 taskId（标记 adopted+成本回填，堵重复采纳）、重新生成接入父级管线。新增 Rust 2 项 + 前端 4 项回归测试；v0.12.5 版本文档/CHANGELOG/版本号。

Author: Aparencia

CHANGELOG.md

@@ -5,6 +5,14 @@
 
 ## [Unreleased] - 2026-08-23
 
+### v0.12.5 AI 精修线路修复：工作台采纳前右侧恒空 + 精修流程优化（2026-08-23 交付，详见 [docs/versions/v0.12.5.md](docs/versions/v0.12.5.md)）
+
+- **P0 采纳前工作台右侧恒空（用户报告）**：精修成功 → 「打开工作台」→ 左侧规则版有内容、右侧精修版空（"尚未精修"占位）。根因：`refine_workbench` 的精修版只按**已落库笔记**取（`find_note_by_session`），采纳前笔记不存在 → `None`；前端持有的 `AiRefineResult` 未进入数据源；且任务成功事件先于 DB 落库（竞态）。修复：`refine_workbench` 新增可选 `refine_result` 参数（调用方内存结果，消除竞态）→ 新增 `Db::find_latest_unadopted_refine`（`ai_tasks` 未采纳成功任务按会话取最新——重启后仍可回显）→ 已落库笔记最新版本，三级数据源；前端 `RefineWorkbench` 携带 `taskResult` 时回传 `refineResult`；采纳前成本不虚假回填
+- **线路优化：完成即自动打开工作台**：任务 Succeeded → 直开工作台（工作台内含 采纳落库/放弃/重新生成 三出口，消除"打开工作台/放弃"中间步）；关闭后卡片保留重开按钮
+- **P1 采纳落库回传真实 taskId**：原来恒传 `null` → 任务不标记 adopted、成本不回填 → 重启后任务中心仍可恢复该结果并再次采纳（**重复建笔记风险**）；现回传并服务端标记 + 成本回填（与任务中心采纳路径收敛）
+- **P1 重新生成接入父级管线**：工作台 `onRegenerate` 复用卡片 start（running 态 + 轮询/事件 + 卡住检测）；原实现直连 `ai_refine_start` → 卡片停留旧结果 done 态、新任务无进度（状态残留）
+- 验证：Rust 新增 2 项单测（find_latest_unadopted_refine_by_session / stats_from 统计口径）全量通过（既有基线失败项与本版无关）；`tsc --noEmit` 零错误 / vitest 全绿（新增 `RefineWorkbench.test.tsx` 4 项：refineResult 契约 / null 兜底 / 采纳 taskId / null 占位不崩）
+
 ### v0.12.4 视频会话画面要点纯图落地 + 笔记预览时间戳锚点 chip 化（2026-08-23 交付，详见 [docs/versions/v0.12.4.md](docs/versions/v0.12.4.md)）
 
 - **P0 视频画面要点残留 OCR 文字（用户 0.12.1 复测）**：v0.12.0 M5（ADR-023）帧侧只删了全帧 OCR 兜底与明文路径，残留两条仍产 OCR 文字的分支——直播路径 `!is_subtitle` 布局分析后仍调 `region_ocr_blocks`（`region=full` 入库），导入路径关键帧不归档图片 + 中区域 OCR。修复：直播 `else` 纯关键帧归档（零 OCR）；导入关键帧无条件纯图归档（`rgb_to_bgra`），仅字幕 OCR 门控保留，删中区域 OCR；展示层 `build_view_screens` 按 kind 分派（photo 保留 ADR-021 OCR 文本屏不变，video 走 `build_keyframe_screens` 纯图屏）；`get_session_detail`/`preview_session_note`/`manual_capture_inner` 三处接入

app/package.json

@@ -1,7 +1,7 @@
 {
   "name": "app",
   "private": true,
-  "version": "0.12.4",
+  "version": "0.12.5",
   "type": "module",
   "scripts": {
     "dev": "vite",

app/src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "entropydecrease"
-version = "0.12.4"
+version = "0.12.5"
 description = "熵减 - 视频知识提取与持久化（本地优先）"
 authors = ["Aparencia"]
 edition = "2021"

app/src-tauri/Cargo.toml

@@ -371,12 +371,18 @@ pub struct WorkbenchData {
 
 /// 工作台数据接口：规则草稿 + 精修结果 + 章节分组 diff 一次取全。
 ///
-/// refined_markdown 为 None → 尚未精修；否则包含最新笔记精修版内容
-/// 与章节 diff。
+/// refined_markdown 为 None → 尚未精修；否则包含最新精修版内容与章节 diff。
+///
+/// @ai-context: 精修版三级数据源（修复：原实现只查已落库笔记——采纳前打开
+///              工作台右侧恒空；且任务成功事件先于 DB 落库，存在竞态）：
+///              ① refine_result 参数（调用方内存结果——采纳前刚完成的任务，
+///                 消除竞态）② 最新未采纳成功任务（DB 持久化——重启后恢复）
+///              ③ 已落库笔记最新版本（采纳后）。
 #[tauri::command]
 pub async fn refine_workbench(
     state: State<'_, AppState>,
     session_id: i64,
+    refine_result: Option<AiRefineResult>,
 ) -> Result<WorkbenchData, String> {
     if session_id <= 0 {
         return Err("无效的会话 id".to_string());
@@ -398,25 +404,42 @@ pub async fn refine_workbench(
     .map_err(|e| e.to_string())?;
     let rule_md = strip_anchors(&draft.markdown);
 
-    // ② 查已落库精修笔记（有无精修结果）
+    // ② 精修版数据源：内存结果（优先）＞ 未采纳成功任务（DB 兜底）＞ 已落库笔记
+    let unadopted = state
+        .db
+        .find_latest_unadopted_refine(session_id)
+        .map_err(|e| e.to_string())?;
+    let pending_result: Option<AiRefineResult> = match (refine_result, unadopted) {
+        (Some(r), _) => Some(r),
+        // 解析失败降级（日志可观测——不影响工作台打开，可经任务中心重取）
+        (None, Some(task)) => task.result_json.as_deref().and_then(|j| {
+            serde_json::from_str::<AiRefineResult>(j)
+                .map_err(|e| eprintln!("[refine-workbench] 未采纳任务 {} 结果解析失败: {}", task.task_id, e))
+                .ok()
+        }),
+        (None, None) => None,
+    };
+
     let note = state.db.find_note_by_session(session_id).map_err(|e| e.to_string())?;
-    let (refined_md, sections, stats, meta) = if let Some(ref note) = note {
+    let (refined_md, sections, stats, meta) = if let Some(result) = pending_result {
+        let secs = diff_sections(&rule_md, &result.refined_markdown);
+        let st = stats_from(&secs);
+        // 未落库：成本按模型单价在 apply 时核算——此处不做虚假回填
+        let m = VersionMeta {
+            cost_yuan: None,
+            model: Some(result.model.clone()),
+            slices: Some(result.slices),
+            merged_from: None,
+        };
+        (Some(result.refined_markdown), secs, st, Some(m))
+    } else if let Some(ref note) = note {
         // 取最新版本内容作为精修版
         let versions = state.db.list_versions(note.id).map_err(|e| e.to_string())?;
         let latest = versions.last()
             .map(|v| v.content.clone())
             .unwrap_or_else(|| note.content.clone());
         let secs = diff_sections(&rule_md, &latest);
-        let total_added: usize = secs.iter().map(|s| s.added_lines.len()).sum();
-        let total_removed: usize = secs.iter().map(|s| s.removed_lines.len()).sum();
-        let total_unchanged: usize = secs.iter()
-            .filter(|s| s.status == crate::note_diff::DiffStatus::Unchanged)
-            .count();
-        let st = DiffStats {
-            added: total_added,
-            removed: total_removed,
-            unchanged: total_unchanged,
-        };
+        let st = stats_from(&secs);
         // 取最新版本 meta
         let m = versions.last().map(|v| VersionMeta {
             cost_yuan: v.meta.cost_yuan,
@@ -438,6 +461,17 @@ pub async fn refine_workbench(
     })
 }
 
+/// 章节分组 diff 统计（新增/删除/未变行数——与 diff_sections 同口径）。
+fn stats_from(secs: &[SectionDiff]) -> DiffStats {
+    DiffStats {
+        added: secs.iter().map(|s| s.added_lines.len()).sum(),
+        removed: secs.iter().map(|s| s.removed_lines.len()).sum(),
+        unchanged: secs.iter()
+            .filter(|s| s.status == crate::note_diff::DiffStatus::Unchanged)
+            .count(),
+    }
+}
+
 /// 更新任务状态并推送事件（短锁内完成即释放）。M3 补充任务复用（pub(crate)）。
 pub(crate) fn set_task(st: &AppState, task_id: u64, new_state: AiTaskState) {
     if let Ok(mut tasks) = st.ai_tasks.lock() {
@@ -570,4 +604,20 @@ mod tests {
         assert!(sec.get("added_lines").is_some());
         assert_eq!(sec["status"], "modified");
     }
+
+    /// stats_from：按 diff_sections 分组行数统计（工作台头部 新增/删除/未变 徽标）。
+    #[test]
+    fn stats_from_aggregates_section_lines() {
+        use crate::note_diff::{DiffStatus, SectionDiff};
+        let secs = vec![
+            SectionDiff { heading: "A".into(), status: DiffStatus::Modified, removed_lines: vec!["a".into()], added_lines: vec!["A".into(), "B".into()] },
+            SectionDiff { heading: "B".into(), status: DiffStatus::Unchanged, removed_lines: vec![], added_lines: vec![] },
+            SectionDiff { heading: "C".into(), status: DiffStatus::Added, removed_lines: vec![], added_lines: vec!["c".into()] },
+            SectionDiff { heading: "D".into(), status: DiffStatus::Removed, removed_lines: vec!["d".into()], added_lines: vec![] },
+        ];
+        let s = stats_from(&secs);
+        assert_eq!(s.added, 3);
+        assert_eq!(s.removed, 2);
+        assert_eq!(s.unchanged, 1);
+    }
 }

app/src-tauri/src/commands_ai_refine.rs

@@ -165,6 +165,29 @@ impl Db {
         rows.collect::<std::result::Result<Vec<_>, _>>().map_err(|e| e.into())
     }
 
+    /// 会话最新未采纳的成功精修任务（精修工作台数据源——采纳前/重启后回显）。
+    ///
+    /// @ai-context: 精修结果在任务成功时已落库（finish_ai_task），但采纳前
+    ///              笔记未建——refine_workbench 原只查已采纳笔记导致工作台
+    ///              右侧恒空；本方法取回那条"待决策"结果（重启后同样可用，
+    ///              与 list_restorable_succeeded 同数据面，粒度按会话）。
+    pub fn find_latest_unadopted_refine(&self, ref_id: i64) -> Result<Option<AiTaskRecord>> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let mut stmt = conn.prepare(
+            "SELECT task_id, op_type, ref_id, state, result_json, cost_yuan, elapsed_ms,
+                    model, error, slices, created_at, finished_at, adopted
+             FROM ai_tasks
+             WHERE op_type='refine' AND ref_id=?1 AND state='succeeded'
+                   AND adopted=0 AND result_json IS NOT NULL
+             ORDER BY created_at DESC LIMIT 1",
+        )?;
+        let mut rows = stmt.query_map(params![ref_id], map_record)?;
+        match rows.next() {
+            Some(r) => Ok(Some(r?)),
+            None => Ok(None),
+        }
+    }
+
     /// 任务历史（任务面板数据源；op_type 过滤 + 时间倒序 + 上限）。
     pub fn list_ai_tasks(&self, op_type: &str, limit: usize) -> Result<Vec<AiTaskRecord>> {
         let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());

app/src-tauri/src/db_ai_tasks.rs

@@ -121,6 +121,22 @@ fn cost_backfill_updates_record() {
     assert_eq!(list[0].cost_yuan, Some(0.5));
 }
 
+#[test]
+fn find_latest_unadopted_refine_by_session() {
+    let db = open_mem();
+    // Arrange：同会话两条成功任务（旧+新）+ 他会话已采纳任务 + 他类任务
+    db.insert_ai_task(&rec(10, "refine", 5, "succeeded")).unwrap();
+    db.insert_ai_task(&rec(20, "refine", 5, "succeeded")).unwrap();
+    db.insert_ai_task(&rec(30, "refine", 6, "succeeded")).unwrap();
+    db.mark_ai_task_adopted(30).unwrap();
+    db.insert_ai_task(&rec(40, "enrich", 5, "succeeded")).unwrap();
+    // Act + Assert：取最新未采纳（created_at=20）；已采纳/他类/不存在 → None
+    let found = db.find_latest_unadopted_refine(5).unwrap();
+    assert_eq!(found.as_ref().map(|t| t.task_id), Some(20), "应取同会话最新未采纳成功任务");
+    assert!(db.find_latest_unadopted_refine(6).unwrap().is_none(), "已采纳任务不返回");
+    assert!(db.find_latest_unadopted_refine(999).unwrap().is_none(), "无任务不返回");
+}
+
 #[test]
 fn adopted_query_true_after_mark_false_otherwise() {
     let db = open_mem();

app/src-tauri/src/db_ai_tasks_tests.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Entropydecrease",
-  "version": "0.12.4",
+  "version": "0.12.5",
   "identifier": "com.entropydecrease.app",
   "build": {
     "beforeDevCommand": "npm run dev",

app/src-tauri/tauri.conf.json

@@ -51,6 +51,9 @@ export default function AiRefineCard({ sessionId, onApplied }: { sessionId: numb
       if (r) {
         setResult(r);
         setPhase("done");
+        // 线路优化：完成即自动打开工作台（对比+采纳/放弃/重新生成一体——
+        // 原"打开工作台/放弃"中间步冗余，工作台内本就有这两个出口）
+        setShowWorkbench(true);
       }
     } else if (typeof st === "object" && st !== null && "Failed" in st) {
       setFailure(st.Failed.reason as AiTaskFailureLike);
@@ -241,13 +244,19 @@ export default function AiRefineCard({ sessionId, onApplied }: { sessionId: numb
         </div>
       )}
 
-      {/* 精修完成 → 打开工作台（替代内嵌 diff） */}
+      {/* 精修完成 → 工作台（完成即自动打开；关闭后可经下方按钮重开） */}
       {phase === "done" && result && (
         <div>
           {showWorkbench ? (
             <RefineWorkbench
               sessionId={sessionId}
               taskResult={result}
+              // 采纳落库回传真实 taskId——标记 adopted + 成本回填（防重启后
+              // 任务中心重复采纳产生重复笔记；原实现恒传 null 丢失该保障）
+              taskId={taskIdRef.current}
+              // 重新生成走父级任务管线（running 态 + 轮询/事件 + 卡住检测）——
+              // 原工作台直连 ai_refine_start 导致卡片状态残留（旧结果+无进度）
+              onRegenerate={async () => { await start(); }}
               onClose={() => setShowWorkbench(false)}
               onApplied={(id) => { reset(); onApplied?.(id); }}
             />

app/src/components/AiRefineCard.tsx

@@ -0,0 +1,107 @@
+// @vitest-environment jsdom
+/**
+ * RefineWorkbench.test.tsx — 精修工作台数据源回归测试（Bug#：采纳前右侧恒空）。
+ *
+ * @ai-context: 工作台在采纳前打开，笔记尚未落库——refine_workbench 必须收到
+ *              调用方内存结果（refineResult 参数）才能回显精修版；采纳落库须
+ *              回传 taskId（标记 adopted 防重启重复采纳、成本回填）。invoke
+ *              全 mock（不触碰真实后端），断言命令参数契约与双栏渲染。
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import type { AiRefineResult, WorkbenchData } from "../types";
+
+const { invokeMock } = vi.hoisted(() => ({ invokeMock: vi.fn() }));
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: invokeMock,
+}));
+
+import RefineWorkbench from "./RefineWorkbench";
+
+/** 最小精修结果桩（camelCase 契约） */
+const resultStub: AiRefineResult = {
+  title: "测试精修",
+  baseMarkdown: "# 标题\n规则内容",
+  refinedMarkdown: "# 标题\n精修内容",
+  diff: [],
+  addedLines: 1,
+  removedLines: 1,
+  slices: 1,
+  failedSlices: 0,
+  model: "test-model",
+};
+
+/** 后端工作台数据桩（含章节 diff——右侧带徽标） */
+const wbStub: WorkbenchData = {
+  ruleMarkdown: "# 标题\n规则内容",
+  refinedMarkdown: "# 标题\n精修内容",
+  sections: [{ heading: "标题", status: "modified", removed_lines: ["规则内容"], added_lines: ["精修内容"] }],
+  stats: { added: 1, removed: 1, unchanged: 0 },
+  meta: { costYuan: null, model: "test-model", slices: 1, mergedFrom: null },
+};
+
+beforeEach(() => {
+  invokeMock.mockReset();
+  invokeMock.mockImplementation(async (_cmd: string) => wbStub);
+});
+
+afterEach(() => cleanup());
+
+describe("RefineWorkbench 采纳前数据源（Bug# 回归）", () => {
+  it("带 taskResult 打开：refine_workbench 收到 refineResult，右侧渲染精修版", async () => {
+    // Arrange/Act
+    render(<RefineWorkbench sessionId={1} onClose={vi.fn()} taskResult={resultStub} taskId={7} />);
+    // Assert：命令契约——内存结果必须回传（原实现未传 → 后端取不到未落库笔记 → 右侧恒空）
+    await waitFor(() => {
+      expect(invokeMock).toHaveBeenCalledWith("refine_workbench", { sessionId: 1, refineResult: resultStub });
+    });
+    expect(await screen.findByText(/精修内容/)).toBeTruthy();
+    expect(screen.getByText(/规则内容/)).toBeTruthy();
+    // 右侧不再出现"尚未精修"占位（原 Bug 表象）
+    expect(screen.queryByText(/尚未精修/)).toBeNull();
+  });
+
+  it("无 taskResult（重启/恢复路径）：refineResult 传 null，后端兜底未采纳任务", async () => {
+    // Arrange/Act
+    render(<RefineWorkbench sessionId={2} onClose={vi.fn()} />);
+    // Assert
+    await waitFor(() => {
+      expect(invokeMock).toHaveBeenCalledWith("refine_workbench", { sessionId: 2, refineResult: null });
+    });
+  });
+
+  it("采纳落库回传真实 taskId（标记 adopted + 成本回填——防重启重复采纳）", async () => {
+    // Arrange：工作台数据 + apply 返回笔记 id
+    invokeMock.mockImplementation(async (cmd: string) => (cmd === "ai_refine_apply" ? { id: 42 } : wbStub));
+    // Act
+    const onApplied = vi.fn();
+    const onClose = vi.fn();
+    render(<RefineWorkbench sessionId={1} onClose={onClose} taskResult={resultStub} taskId={7} onApplied={onApplied} />);
+    fireEvent.click(await screen.findByRole("button", { name: /采纳落库/ }));
+    // Assert
+    await waitFor(() => {
+      expect(invokeMock).toHaveBeenCalledWith("ai_refine_apply", {
+        sessionId: 1,
+        result: resultStub,
+        taskId: 7,
+      });
+    });
+    expect(onApplied).toHaveBeenCalledWith(42);
+    expect(onClose).toHaveBeenCalled();
+  });
+
+  it("后端返回 refinedMarkdown=null（无任何精修来源）→ 显示占位而非空白", async () => {
+    // Arrange：后端兜底也拿不到精修版
+    invokeMock.mockImplementation(async (_cmd: string) => ({
+      ...wbStub,
+      refinedMarkdown: null,
+      sections: [],
+      stats: { added: 0, removed: 0, unchanged: 0 },
+    }));
+    // Act
+    render(<RefineWorkbench sessionId={3} onClose={vi.fn()} />);
+    // Assert：占位提示可见，右栏不崩
+    expect(await screen.findByText(/尚未精修/)).toBeTruthy();
+    expect(screen.getByText(/规则内容/)).toBeTruthy();
+  });
+});