refactor(td): 偿还 TD-21-C/24-B/24-C 与 clippy 存量清零（TD-22-A）

Author: Aparencia

app/src-tauri/src/ai_guardrails_tests.rs

@@ -21,9 +21,9 @@ fn quota_consumes_until_limit() {
 fn quota_resets_on_new_day() {
     // Arrange：配额 2，首日耗尽
     let mut quota = DailyQuota::new(2);
-    assert!(quota.try_consume(86_400 * 1));
-    assert!(quota.try_consume(86_400 * 1));
-    assert!(!quota.try_consume(86_400 * 1));
+    assert!(quota.try_consume(86_400));
+    assert!(quota.try_consume(86_400));
+    assert!(!quota.try_consume(86_400));
     // Act：次日
     assert!(quota.try_consume(86_400 * 2), "跨日应重置配额");
     assert_eq!(quota.usage(), (1, 2));

app/src-tauri/src/ai_note_enrich_tests.rs

@@ -36,5 +36,5 @@ fn kind_as_str_matches_kebab_case() {
 #[test]
 fn fallback_never_empty() {
     let p = NoteEnrichPrompt::fallback();
-    assert!(!p.build_system(&AiEnrichKind::all().to_vec()).is_empty());
+    assert!(!p.build_system(AiEnrichKind::all().as_ref()).is_empty());
 }

app/src-tauri/src/ai_settings_tests.rs

@@ -46,15 +46,16 @@ fn save_load_roundtrip() {
     // 持久化 roundtrip：enabled/authorized/端点/模型/阈值/记住选择全保真
     let path = tmp_settings_file("roundtrip.json");
     let _ = std::fs::remove_file(&path);
-    let mut s = AiSettings::default();
-    s.enabled = true;
-    s.authorized = true;
-    s.base_url = "https://example.com/v1".to_string();
-    s.model = "acme/model-1".to_string();
-    s.low_balance_threshold = 5.0;
-    s.remember_cost_choice = true;
-    // v0.12.0 M5：vision 画面理解默认关——持久化 roundtrip 保真
-    s.vision_refine_enabled = true;
+    let s = AiSettings {
+        enabled: true,
+        authorized: true,
+        base_url: "https://example.com/v1".to_string(),
+        model: "acme/model-1".to_string(),
+        low_balance_threshold: 5.0,
+        remember_cost_choice: true,
+        // v0.12.0 M5：vision 画面理解默认关——持久化 roundtrip 保真
+        vision_refine_enabled: true,
+    };
     s.save(&path).expect("保存成功");
     let loaded = AiSettings::load(&path);
     assert_eq!(loaded, s);

app/src-tauri/src/audio_event_filter_tests.rs

@@ -44,7 +44,7 @@ fn synth_speech(sample_rate: u32, dur_secs: f32, amp: f32) -> Vec<f32> {
         }
         i += blen;
         let glen = gap.min(n - i);
-        out.extend(std::iter::repeat(0.0f32).take(glen));
+        out.extend(std::iter::repeat_n(0.0f32, glen));
         i += glen;
     }
     out

app/src-tauri/src/commands_ai_enrich.rs

@@ -278,7 +278,7 @@ fn run_enrich_task(st: AppState, task_id: u64, note_id: i64, selected: Vec<AiEnr
         let client = AiClient::from_settings_with_store(
             &settings,
             crate::commands_ai_providers::resolve_default_provider_key(&st)
-                .map_err(|e| AiTaskFailure::Other(e))?,
+                .map_err(AiTaskFailure::Other)?,
             &store,
         );
         let adapter = AiNoteEnrichAdapter::new(client.clone());

app/src-tauri/src/commands_knowledge_core.rs

@@ -149,6 +149,9 @@ pub fn list_knowledge_models(state: State<'_, AppState>, system_id: i64) -> Resu
 ///              @side-effect v0.14 C3：成功后广播 knowledge:links-changed——跨页即时同步
 ///              （笔记页挂接 → 体系页引用区/图谱即时刷新，spec §3.3 refreshToken 机制）。
 #[tauri::command]
+// @ai-context: Tauri command 接口签名固定（注入 app/state + 8 个业务参数——
+//              clippy too_many_arguments 允许：接口契约不因 lint 改形参分拆）
+#[allow(clippy::too_many_arguments)]
 pub fn link_knowledge_target(
     app: AppHandle,
     state: State<'_, AppState>,

app/src-tauri/src/db_graph_tests.rs

@@ -325,6 +325,6 @@ fn combined_snapshot_mixes_all_edge_types() {
     assert_eq!(snap.edges.iter().filter(|e| e.edge_type == "link").count(), 1);
     assert_eq!(snap.edges.iter().filter(|e| e.edge_type == "trace").count(), 1);
     assert_eq!(snap.edges.iter().filter(|e| e.edge_type == "belong").count(), 2);
-    assert_eq!(snap.edges.iter().filter(|e| e.edge_type == "trace").next().expect("t").source, format!("note:{n1}"));
-    assert_eq!(snap.edges.iter().filter(|e| e.edge_type == "trace").next().expect("t2").target, format!("note:{n2}"));
+    assert_eq!(snap.edges.iter().find(|e| e.edge_type == "trace").expect("t").source, format!("note:{n1}"));
+    assert_eq!(snap.edges.iter().find(|e| e.edge_type == "trace").expect("t2").target, format!("note:{n2}"));
 }

app/src-tauri/src/db_session_events.rs

@@ -27,70 +27,72 @@ impl Db {
     ///              前台切换基线（低频、practice_segments 对齐锚点）不被
     ///              高频写放大误删（2h 会话 ≈ 数百条高频，远未触发守卫）。
     pub fn add_event(&self, new: &NewSessionEvent) -> Result<SessionEvent> {
-        let conn = self.conn.lock().expect("db lock poisoned");
-        conn.execute("BEGIN TRANSACTION", [])?;
-        let result = (|| -> Result<SessionEvent> {
-            // 容量守卫：超预算先删最旧（同一事务，防写放大无限增长）
-            if crate::session_events::over_budget(self.count_events_locked(&conn, new.session_id)?) {
-                // 优先删高频噪声事件（可重建信号；基线/行为事件保留）
-                let deleted = conn.execute(
-                    "DELETE FROM session_events WHERE id IN (
-                         SELECT id FROM session_events
-                         WHERE session_id = ?1
-                           AND kind IN ('frame_switch', 'long_silence', 'volume_surge')
-                         ORDER BY timestamp_ms ASC LIMIT 1
-                     )",
-                    params![new.session_id],
-                )?;
-                if deleted == 0 {
-                    // 无高频可删（异常会话全为基线/行为事件）→ 回退删最旧整体
-                    conn.execute(
+        self.with_conn(|conn| {
+            conn.execute("BEGIN TRANSACTION", [])?;
+            let result = (|| -> Result<SessionEvent> {
+                // 容量守卫：超预算先删最旧（同一事务，防写放大无限增长）
+                if crate::session_events::over_budget(self.count_events_locked(conn, new.session_id)?) {
+                    // 优先删高频噪声事件（可重建信号；基线/行为事件保留）
+                    let deleted = conn.execute(
                         "DELETE FROM session_events WHERE id IN (
-                             SELECT id FROM session_events WHERE session_id = ?1 ORDER BY timestamp_ms ASC LIMIT 1
+                             SELECT id FROM session_events
+                             WHERE session_id = ?1
+                               AND kind IN ('frame_switch', 'long_silence', 'volume_surge')
+                             ORDER BY timestamp_ms ASC LIMIT 1
                          )",
                         params![new.session_id],
                     )?;
+                    if deleted == 0 {
+                        // 无高频可删（异常会话全为基线/行为事件）→ 回退删最旧整体
+                        conn.execute(
+                            "DELETE FROM session_events WHERE id IN (
+                                 SELECT id FROM session_events WHERE session_id = ?1 ORDER BY timestamp_ms ASC LIMIT 1
+                             )",
+                            params![new.session_id],
+                        )?;
+                    }
+                }
+                conn.execute(
+                    "INSERT INTO session_events (session_id, kind, timestamp_ms, payload_json)
+                     VALUES (?1, ?2, ?3, ?4)",
+                    params![
+                        new.session_id,
+                        new.kind.as_str(),
+                        new.timestamp_ms as i64,
+                        new.payload.to_string(),
+                    ],
+                )?;
+                Ok(SessionEvent {
+                    id: conn.last_insert_rowid(),
+                    session_id: new.session_id,
+                    kind: new.kind,
+                    timestamp_ms: new.timestamp_ms,
+                    payload: new.payload.clone(),
+                })
+            })();
+            match result {
+                Ok(e) => {
+                    conn.execute("COMMIT", [])?;
+                    Ok(e)
+                }
+                Err(e) => {
+                    let _ = conn.execute("ROLLBACK", []);
+                    Err(e)
                 }
             }
-            conn.execute(
-                "INSERT INTO session_events (session_id, kind, timestamp_ms, payload_json)
-                 VALUES (?1, ?2, ?3, ?4)",
-                params![
-                    new.session_id,
-                    new.kind.as_str(),
-                    new.timestamp_ms as i64,
-                    new.payload.to_string(),
-                ],
-            )?;
-            Ok(SessionEvent {
-                id: conn.last_insert_rowid(),
-                session_id: new.session_id,
-                kind: new.kind,
-                timestamp_ms: new.timestamp_ms,
-                payload: new.payload.clone(),
-            })
-        })();
-        match result {
-            Ok(e) => {
-                conn.execute("COMMIT", [])?;
-                Ok(e)
-            }
-            Err(e) => {
-                let _ = conn.execute("ROLLBACK", []);
-                Err(e)
-            }
-        }
+        })
     }
 
     /// 列出会话全部信号事件（按时间轴升序；消费端过滤类型）。
     pub fn list_events(&self, session_id: i64) -> Result<Vec<SessionEvent>> {
-        let conn = self.conn.lock().expect("db lock poisoned");
-        let mut stmt = conn.prepare(
-            "SELECT id, session_id, kind, timestamp_ms, payload_json
-             FROM session_events WHERE session_id = ?1 ORDER BY timestamp_ms ASC",
-        )?;
-        let rows = stmt.query_map(params![session_id], row_to_event)?;
-        rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into)
+        self.with_conn(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT id, session_id, kind, timestamp_ms, payload_json
+                 FROM session_events WHERE session_id = ?1 ORDER BY timestamp_ms ASC",
+            )?;
+            let rows = stmt.query_map(params![session_id], row_to_event)?;
+            rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into)
+        })
     }
 
     /// 按类型列出事件（章节检测等消费端按需过滤）。
@@ -99,13 +101,14 @@ impl Db {
     ///              登记豁免 dead_code（V1.0 周报聚合同样需要）。
     #[allow(dead_code)]
     pub fn list_events_by_kind(&self, session_id: i64, kind: EventKind) -> Result<Vec<SessionEvent>> {
-        let conn = self.conn.lock().expect("db lock poisoned");
-        let mut stmt = conn.prepare(
-            "SELECT id, session_id, kind, timestamp_ms, payload_json
-             FROM session_events WHERE session_id = ?1 AND kind = ?2 ORDER BY timestamp_ms ASC",
-        )?;
-        let rows = stmt.query_map(params![session_id, kind.as_str()], row_to_event)?;
-        rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into)
+        self.with_conn(|conn| {
+            let mut stmt = conn.prepare(
+                "SELECT id, session_id, kind, timestamp_ms, payload_json
+                 FROM session_events WHERE session_id = ?1 AND kind = ?2 ORDER BY timestamp_ms ASC",
+            )?;
+            let rows = stmt.query_map(params![session_id, kind.as_str()], row_to_event)?;
+            rows.collect::<rusqlite::Result<Vec<_>>>().map_err(Into::into)
+        })
     }
 
     /// 会话事件计数（容量守卫内部用；锁已持有）。