fix(ai): 审查修复——URL 丢失 /v1 404/轮询泄漏/双跑分析/过期豁免/trim_tasks 边界

Author: Aparencia

app/src-tauri/src/ai_balance.rs

@@ -81,9 +81,11 @@ impl AiBalanceAdapter {
         if self.api_key.trim().is_empty() {
             return Err("未配置 API 密钥（设置页保存密钥或配置环境变量 SILICONFLOW_API_KEY）".to_string());
         }
+        // 审查修复（2026-08-21）：只修剪尾斜杠，不得 trim "/v1"（同 ai_client
+        // ——base_url 含 /v1 是 OpenAI 兼容端点约定，删掉会 404）
         let url = format!(
             "{}/user/balance",
-            self.base_url.trim_end_matches('/').trim_end_matches("/v1")
+            self.base_url.trim_end_matches('/')
         );
         let agent = ureq::AgentBuilder::new()
             .timeout(std::time::Duration::from_secs(self.timeout_secs.max(5)))

app/src-tauri/src/ai_client.rs

@@ -104,10 +104,7 @@ impl AiClient {
             return Err(AiClientError::Auth("未配置 API 密钥（设置页保存或配置环境变量）".to_string()));
         }
         let payload = build_chat_payload(&self.config.model, system, user);
-        let url = format!(
-            "{}/chat/completions",
-            self.config.base_url.trim_end_matches('/').trim_end_matches("/v1")
-        );
+        let url = chat_completions_url(&self.config.base_url);
         let agent = ureq::AgentBuilder::new()
             .timeout(std::time::Duration::from_secs(self.config.timeout_secs.max(5)))
             .build();
@@ -168,16 +165,24 @@ impl AiClient {
     ///
     /// @ai-context: 重试仅针对 429/5xx/传输错误（幂等读操作）；401/402/403
     ///              不重试直接归一错误；解析失败（非 JSON/结构非法）→ Parse。
-    /// @ai-context: M1 无消费方（M2 ai_note_refine/M3 ai_enrich 采用——
-    ///              chat_json = chat_text + parse_json_object 组合），
-    ///              登记豁免 dead_code（与 ai_guardrails V1.0 预留同模式）。
-    #[allow(dead_code)]
+    /// @ai-context: 由 M2 ai_note_refine / M3 ai_note_enrich 适配器消费
+    ///              （chat_json = chat_text + parse_json_object 组合）。
     pub fn chat_json(&self, system: &str, user: &str) -> Result<serde_json::Value, AiClientError> {
         let raw = self.chat_text(system, user)?;
         parse_json_object(&raw)
     }
 }
 
+/// chat/completions 端点 URL（纯函数可单测：只修剪尾斜杠）。
+///
+/// @ai-context: 审查修复（2026-08-21）：**不得** trim "/v1"——base_url 默认含
+///              /v1（OpenAI 兼容端点约定 https://api.siliconflow.cn/v1），
+///              trim_end_matches("/v1") 会把 /v1 一并删掉 → 请求打到缺 /v1
+///              的路径 404，测试连接/余额/复核/精修/补充全部网络调用失败。
+pub fn chat_completions_url(base_url: &str) -> String {
+    format!("{}/chat/completions", base_url.trim_end_matches('/'))
+}
+
 /// 构建 chat/completions payload（纯函数可单测；temperature=0 + json_object）。
 ///
 /// @ai-context: R1 系推理模型带 no_think=true 关闭思考标签（保 JSON 输出
@@ -212,8 +217,7 @@ pub fn extract_content(body: &str) -> Result<String, AiClientError> {
 ///
 /// @ai-context: 推理模型偶发用代码块包裹 JSON——先剥围栏再 parse；
 ///              解析失败 → Parse 错误（调用方回退本地结果，不丢不假）。
-/// @ai-context: M1 仅 chat_json 引用（M2/M3 消费），登记豁免 dead_code。
-#[allow(dead_code)]
+///              由 chat_json 消费（M2/M3 适配器链）。
 pub fn parse_json_object(raw: &str) -> Result<serde_json::Value, AiClientError> {
     let trimmed = raw.trim();
     let stripped = trimmed

app/src-tauri/src/ai_client_tests.rs

@@ -1,10 +1,33 @@
 //! ai_client.rs 单测（AAA 模式；payload/解析纯函数——网络路径不单测）。
 
 use crate::ai_client::{
-    build_chat_payload, extract_content, parse_json_object, AiClient, AiClientConfig, AiClientError,
+    build_chat_payload, chat_completions_url, extract_content, parse_json_object, AiClient,
+    AiClientConfig, AiClientError,
 };
 use crate::ai_settings::AiSettings;
 
+#[test]
+fn chat_url_preserves_v1_segment() {
+    // 审查回归（2026-08-21）：/v1 不得被 trim——默认端点 + 自定义端点均保留
+    assert_eq!(
+        chat_completions_url("https://api.siliconflow.cn/v1"),
+        "https://api.siliconflow.cn/v1/chat/completions"
+    );
+    assert_eq!(
+        chat_completions_url("https://api.siliconflow.cn/v1/"),
+        "https://api.siliconflow.cn/v1/chat/completions"
+    );
+    assert_eq!(
+        chat_completions_url("https://custom.example.com/v1"),
+        "https://custom.example.com/v1/chat/completions"
+    );
+    // 用户配置裸主机（无 /v1）时按原样拼接（端点兜底由设置页提示约束）
+    assert_eq!(
+        chat_completions_url("https://custom.example.com"),
+        "https://custom.example.com/chat/completions"
+    );
+}
+
 #[test]
 fn payload_has_expected_shape() {
     // temperature=0 + json_object + system/user 消息

app/src-tauri/src/ai_settings.rs

@@ -77,9 +77,7 @@ impl AiSettings {
     ///
     /// @ai-context: 失败文案携带引导（未开启→去设置页开开关；未授权→先同意
     ///              授权说明），供前端弹引导，不静默降级（REQ-140 验收：授权前
-    ///              任何 AI 调用不可达）。M1 无消费方（M2 精修/M3 补充采用），
-    ///              登记豁免 dead_code（与 ai_guardrails V1.0 预留同模式）。
-    #[allow(dead_code)]
+    ///              任何 AI 调用不可达）。由 M2 精修 / M3 补充命令消费。
     pub fn content_gate(&self) -> Result<(), String> {
         if !self.enabled {
             return Err("AI 功能未开启（设置页全局开关默认关闭）".to_string());
@@ -92,7 +90,8 @@ impl AiSettings {
 
     /// 非内容类 AI 调用门控（余额查询/测试连接：仅要求开关开启——避免关闭
     /// 状态下误以为功能可用；测试连接为配置验证操作不 gate，见 command 层）。
-    /// M1 无消费方（预留；与 content_gate 同登记豁免）。
+    /// 当前无消费方（预留——若未来余额查询/测试连接要求开启开关时启用），
+    /// 登记豁免 dead_code（与 ai_guardrails V1.0 预留同模式）。
     #[allow(dead_code)]
     pub fn enabled_gate(&self) -> Result<(), String> {
         if !self.enabled {

app/src-tauri/src/commands_ai_enrich.rs

@@ -59,7 +59,9 @@ pub fn ai_enrich_estimate(
 ) -> Result<RefineEstimateView, String> {
     let kinds = normalize_kinds(selected_kinds)?;
     let note = get_note(state.inner(), note_id)?;
-    let chars = note.content.chars().count() + kinds.len() * 80; // 子项提示词开销
+    // 预估 = 笔记正文 + 子项提示词开销（每子项约 80 字符的系统说明——
+    // 保守上界，与 ai_cost 字符→token 同口径）
+    let chars = note.content.chars().count() + kinds.len() * 80;
     let remember = state.ai_settings.lock().map(|s| s.remember_cost_choice).unwrap_or(false);
     Ok(RefineEstimateView { estimate: estimate_for_content(chars), remember_cost_choice: remember })
 }
@@ -190,7 +192,8 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
             .get_note(note_id)
             .map_err(|e| AiTaskFailure::Other(e.to_string()))?
             .ok_or_else(|| AiTaskFailure::Other("笔记不存在".to_string()))?;
-        // 档案：关联会话档案（无则空=提示词回退讲义式）
+        // 档案：关联会话档案（无则空=提示词回退讲义式）。DB 错误吞掉是有意
+        // 降级（补充不因档案缺失失败——档案只是提示词参考，非必需输入）
         let profile = match note.session_id {
             Some(sid) => st
                 .db

app/src-tauri/src/commands_ai_refine.rs

@@ -23,13 +23,12 @@ use crate::ai_mock::AiMockAdapter;
 use crate::ai_note_refine::AiNoteRefineAdapter;
 use crate::ai_refine_protocol::AiRefineRequest;
 use crate::ai_task::{slice_note, AiTaskFailure, AiTaskState, SLICE_MAX_CHARS};
-use crate::analysis::{analyze_session_opt, SessionAnalysis};
 use crate::commands::AppState;
-use crate::commands_session_note::build_rule_draft;
+use crate::commands_session_note::build_rule_draft_with_analysis;
 use crate::note_diff::{diff_markdown, diff_stats, DiffOp};
 use crate::note_filter::PurifyEnv;
 use crate::outline::{detect_outline_smart, OutlineConfig};
-use crate::types::{NewNote, Note, SessionDetail};
+use crate::types::{NewNote, Note};
 use crate::video_profile::ProfileKind;
 
 /// mock 模式 env 键（本地规则精修，不联网——测试/离线开发，ai_text_filter 先例）。
@@ -246,10 +245,12 @@ fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool) {
         corrections: st.ocr_corrections.clone(),
     };
     let outcome: Result<AiRefineResult, AiTaskFailure> = (|| {
-        // ① 规则草稿（单一管线三出口——AI 输入基线 = 规则版输出基线）
-        let draft = build_rule_draft(&st.db, &st.ui_junk, &env, &st.data_dir, session_id, None)
-            .map_err(AiTaskFailure::Other)?;
-        // ② 精修上下文（档案/章节/术语——与 apply_note_structure 同源分析）
+        // ① 规则草稿 + 结构分析一次完成（审查修复 2026-08-21：build_rule_draft_
+        //    with_analysis 返回 analysis——章节/术语直接复用，消除二次 analyze 双跑）
+        let (draft, analysis) =
+            build_rule_draft_with_analysis(&st.db, &st.ui_junk, &env, &st.data_dir, session_id, None)
+                .map_err(AiTaskFailure::Other)?;
+        // ② 精修上下文（档案/章节/术语——analysis 已含章节边界与术语表）
         let session = st
             .db
             .get_session(session_id)
@@ -260,16 +261,7 @@ fn run_refine_task(st: AppState, task_id: u64, session_id: i64, mock: bool) {
             .as_deref()
             .map(ProfileKind::parse)
             .unwrap_or(ProfileKind::Lecture);
-        let segments = st.db.list_segments(session_id).map_err(|e| AiTaskFailure::Other(e.to_string()))?;
         let ocr_blocks = st.db.list_ocr_blocks(session_id).map_err(|e| AiTaskFailure::Other(e.to_string()))?;
-        let detail = SessionDetail {
-            session: session.clone(),
-            segments,
-            ocr_blocks: ocr_blocks.clone(),
-            events: Vec::new(),
-            screens: Vec::new(),
-        };
-        let analysis: SessionAnalysis = analyze_session_opt(&detail, kind, &env.symbol);
         let outline = detect_outline_smart(&ocr_blocks, &draft.ocr_screens, &OutlineConfig::default());
         let chapters: Vec<String> = if outline.is_empty() {
             analysis
@@ -352,18 +344,23 @@ pub(crate) fn set_task(st: &AppState, task_id: u64, new_state: AiTaskState) {
 }
 
 /// 注册表容量守卫（超限丢弃最旧终态任务——防无界增长）。M3 补充任务复用。
+///
+/// @ai-context: 审查修复（2026-08-21）：原实现终态任务数 < excess 时删不完
+///              （并行 Running 占满时 len 持续 > CAP）——改为 while 循环，
+///              无终态可删时停止（Running 任务不可删——任务执行中）。
 pub(crate) fn trim_tasks(tasks: &mut HashMap<u64, AiTaskEntry>) {
-    if tasks.len() <= TASKS_CAP {
-        return;
-    }
-    let mut ids: Vec<u64> = tasks.iter().filter_map(|(id, t)| match t.state {
-        AiTaskState::Pending | AiTaskState::Running { .. } => None,
-        _ => Some(*id),
-    }).collect();
-    ids.sort_unstable();
-    let excess = tasks.len() - TASKS_CAP;
-    for id in ids.into_iter().take(excess) {
-        tasks.remove(&id);
+    while tasks.len() > TASKS_CAP {
+        let oldest_terminal = tasks
+            .iter()
+            .filter(|(_, t)| !matches!(t.state, AiTaskState::Pending | AiTaskState::Running { .. }))
+            .min_by_key(|(id, _)| **id)
+            .map(|(id, _)| *id);
+        match oldest_terminal {
+            Some(id) => {
+                tasks.remove(&id);
+            }
+            None => break,
+        }
     }
 }
 

app/src-tauri/src/commands_session_note.rs

@@ -16,7 +16,7 @@ use std::collections::HashSet;
 use tauri::State;
 
 use crate::ai_protocol::TextFilterDecision;
-use crate::analysis::analyze_session_opt;
+use crate::analysis::{analyze_session_opt, SessionAnalysis};
 use crate::commands::{normalize_title, AppState};
 use crate::db::Db;
 use crate::db_sessions::SESSION_STATUS_RECORDING;
@@ -53,25 +53,15 @@ fn load_note_material(
     Ok((session, segments, ocr_blocks))
 }
 
-/// 结构渲染接线（v0.7.6 REQ-177/178，预览/落库/AI 复核三出口共用）。
-///
-/// @ai-context: 在 refresh_screen_points 之后调用——净化/配图/警示行先落定，
-///              结构层在其上叠加章节标题与词汇表块；预览与落库同函数同口径
-///              （REQ-081 单一管线双出口契约）。
-/// @ai-context: 输入为会话原料（segments/ocr_blocks）——章节检测/大纲标题/
-///              术语表均为纯本地规则（analysis/outline/glossary 复用）——
-///              不依赖云端 AI（本地优先铁律）；失败不阻断转笔记主链路
-///              （分析失败按空结构处理，不抛错）。
-/// @ai-context: pub(crate)（v0.7.6 审查修复）：commands_ai.rs AI 复核出口
-///              复用——复核后预览与落库同含结构层（REQ-081 三出口一致）。
-pub(crate) fn apply_note_structure(
-    result: &mut NoteFilterResult,
+/// 结构渲染分析（纯本地：章节/术语——apply_note_structure 与
+/// build_rule_draft_with_analysis 共用，审查修复 2026-08-21：消除双跑）。
+fn analyze_for_structure(
     db: &Db,
     session: &Session,
     segments: &[SessionSegment],
     ocr_blocks: &[SessionOcrBlock],
     env: &PurifyEnv,
-) {
+) -> SessionAnalysis {
     // 档案驱动：章节检测/术语表按档案开关（网课开、口播关——analysis 内部门控）
     let kind = session
         .profile
@@ -94,7 +84,41 @@ pub(crate) fn apply_note_structure(
         events,
         screens: Vec::new(),
     };
-    let analysis = analyze_session_opt(&detail, kind, &env.symbol);
+    analyze_session_opt(&detail, kind, &env.symbol)
+}
+
+/// 结构渲染接线（v0.7.6 REQ-177/178，预览/落库/AI 复核三出口共用）。
+///
+/// @ai-context: 在 refresh_screen_points 之后调用——净化/配图/警示行先落定，
+///              结构层在其上叠加章节标题与词汇表块；预览与落库同函数同口径
+///              （REQ-081 单一管线双出口契约）。
+/// @ai-context: 输入为会话原料（segments/ocr_blocks）——章节检测/大纲标题/
+///              术语表均为纯本地规则（analysis/outline/glossary 复用）——
+///              不依赖云端 AI（本地优先铁律）；失败不阻断转笔记主链路
+///              （分析失败按空结构处理，不抛错）。
+/// @ai-context: pub(crate)（v0.7.6 审查修复）：commands_ai.rs AI 复核出口
+///              复用——复核后预览与落库同含结构层（REQ-081 三出口一致）。
+pub(crate) fn apply_note_structure(
+    result: &mut NoteFilterResult,
+    db: &Db,
+    session: &Session,
+    segments: &[SessionSegment],
+    ocr_blocks: &[SessionOcrBlock],
+    env: &PurifyEnv,
+) {
+    let analysis = analyze_for_structure(db, session, segments, ocr_blocks, env);
+    apply_note_structure_with_analysis(result, session, ocr_blocks, env, &analysis);
+}
+
+/// 结构渲染接线（复用外部分析结果——精修任务避免双跑 analyze，审查修复
+/// 2026-08-21：build_rule_draft_with_analysis 提供一次分析供结构层 + 任务共用）。
+pub(crate) fn apply_note_structure_with_analysis(
+    result: &mut NoteFilterResult,
+    _session: &Session,
+    ocr_blocks: &[SessionOcrBlock],
+    env: &PurifyEnv,
+    analysis: &SessionAnalysis,
+) {
     let outline = detect_outline_smart(ocr_blocks, &result.ocr_screens, &OutlineConfig::default());
     let _ = render_note_structure(
         result,
@@ -119,6 +143,19 @@ pub(crate) fn build_rule_draft(
     id: i64,
     title: Option<String>,
 ) -> Result<NoteFilterResult, String> {
+    Ok(build_rule_draft_with_analysis(db, ui_junk, env, data_dir, id, title)?.0)
+}
+
+/// 构建规则草稿 + 结构分析（审查修复 2026-08-21：分析与结构渲染一次完成并
+/// 返回 analysis——AI 精修任务直接复用章节/术语，消除二次 analyze 双跑）。
+pub(crate) fn build_rule_draft_with_analysis(
+    db: &Db,
+    ui_junk: &UiJunkList,
+    env: &PurifyEnv,
+    data_dir: &std::path::Path,
+    id: i64,
+    title: Option<String>,
+) -> Result<(NoteFilterResult, SessionAnalysis), String> {
     let (session, segments, ocr_blocks) = load_note_material(db, id)?;
     let fallback = format!("{}（会话）", session.title);
     let title = normalize_title(title.unwrap_or_default(), &fallback);
@@ -132,8 +169,9 @@ pub(crate) fn build_rule_draft(
     crate::note_filter::refresh_screen_points(&mut result);
     // v0.7.6（REQ-177/178）：结构渲染——章节标题 + 词汇表块（纯本地增强层；
     // 无结构数据/分析失败 → 原样输出不阻断，见 apply_note_structure）
-    apply_note_structure(&mut result, db, &session, &segments, &ocr_blocks, env);
-    Ok(result)
+    let analysis = analyze_for_structure(db, &session, &segments, &ocr_blocks, env);
+    apply_note_structure_with_analysis(&mut result, &session, &ocr_blocks, env, &analysis);
+    Ok((result, analysis))
 }
 
 /// 会话 → 笔记核心（v0.7.1 提取：单条与批量共用同一管线）。

app/src/components/AiRefineCard.tsx

@@ -72,6 +72,17 @@ export default function AiRefineCard({ sessionId, onApplied }: { sessionId: numb
     };
   }, [taskId]);
 
+  // 审查修复（2026-08-21）：组件卸载时停止轮询——否则 interval 持续 invoke
+  // 并对已卸载组件 setState（切会话/关面板后泄漏）
+  useEffect(() => {
+    return () => {
+      if (polling.current) {
+        clearInterval(polling.current);
+        polling.current = null;
+      }
+    };
+  }, []);
+
   useEffect(() => {
     void invoke<AiSettingsView>("ai_get_settings").then(setSettings).catch(() => undefined);
   }, []);