@@ -11,6 +11,7 @@ use tauri::State;
 
 use crate::card_generate::{card_from_fragment, cards_from_note};
 use crate::commands::AppState;
+use crate::db::Db;
 use crate::db_flashcards::NewFlashcard;
 use crate::scheduler::{schedule, CardState, Rating};
 use crate::types::Flashcard;
@@ -162,21 +163,27 @@ pub fn count_due_cards(state: State<'_, AppState>, group_id: Option<i64>) -> Res
 }
 
 /// 复习评分（提取优先闭环：front→回忆→back→评分→调度推进）。
-///
-/// @ai-context: state_json 损坏 → 回退新卡状态重学（诚实降级不 panic）；
-///              card_reviewed 指标每次必记（北极星组成①的数据源）。
 #[tauri::command]
 pub fn review_card(
     state: State<'_, AppState>,
     card_id: i64,
     rating: String,
 ) -> Result<Flashcard, String> {
+    review_card_inner(&state.db, card_id, &rating)
+}
+
+/// 复习评分编排（inner——命令壳只解引用 State；仓内约定「inner 等价于测全命令」）。
+///
+/// @ai-context: state_json 损坏 → 回退新卡状态重学（诚实降级不 panic）；
+///              card_reviewed 指标每次必记（北极星组成①的数据源）。
+/// @ai-context: 返回体的 interval_days 必须**显式覆写**为当次调度的精确值——`..card`
+///              结构体更新语法会把 row_to_card 的旧值（整天粒度）漏出去。
+pub(crate) fn review_card_inner(db: &Db, card_id: i64, rating: &str) -> Result<Flashcard, String> {
     if card_id <= 0 {
         return Err("无效的卡片 id".to_string());
     }
-    let rating = Rating::parse(&rating).ok_or_else(|| format!("不支持的评分: {}", rating))?;
-    let card = state
-        .db
+    let rating = Rating::parse(rating).ok_or_else(|| format!("不支持的评分: {}", rating))?;
+    let card = db
         .get_card(card_id)
         .map_err(|e| e.to_string())?
         .ok_or_else(|| format!("卡片不存在: {}", card_id))?;
@@ -190,22 +197,19 @@ pub fn review_card(
         now,
     );
     let state_json = serde_json::to_string(&outcome.next).unwrap_or_default();
-    state
-        .db
-        .update_card_schedule(card_id, &state_json, outcome.due_at_ms as i64)
+    db.update_card_schedule(card_id, &state_json, outcome.due_at_ms as i64)
         .map_err(|e| e.to_string())?;
-    state
-        .db
-        .add_review_log(card_id, &rating.to_string_lower(), now as i64)
+    db.add_review_log(card_id, &rating.to_string_lower(), now as i64)
         .map_err(|e| e.to_string())?;
     // 北极星埋点（组有复习记录=组成①；payload 带组 id 供按组聚合）
     let payload =
         serde_json::json!({ "cardId": card_id, "groupId": card.group_id, "rating": rating.to_string_lower() })
             .to_string();
-    let _ = state.db.add_metric_event("card_reviewed", &payload);
+    let _ = db.add_metric_event("card_reviewed", &payload);
     Ok(Flashcard {
         state_json,
         due_at: outcome.due_at_ms as i64,
+        interval_days: outcome.interval_days,
         ..card
     })
 }
 
@@ -51,6 +51,7 @@ impl Db {
                 state_json: new.state_json.clone(),
                 due_at: new.due_at,
                 created_at: now,
+                interval_days: 0.0,
             })
         })
     }
@@ -283,8 +284,15 @@ fn row_to_card(row: &rusqlite::Row<'_>) -> rusqlite::Result<Flashcard> {
         state_json: row.get(7)?,
         due_at: row.get(8)?,
         created_at: row.get(9)?,
+        interval_days: interval_days_from(row.get(8)?, &row.get::<_, String>(7)?),
     })
 }
+/// 行派生间隔（整天粒度）：`due_at − stateJson.lastReviewMs` 反推；无复习记录/劣化输入 ⇒ 0.0。
+fn interval_days_from(due_at: i64, state_json: &str) -> f32 {
+    let s: crate::scheduler::CardState = serde_json::from_str(state_json).unwrap_or_default();
+    let days = (due_at.saturating_sub(s.last_review_ms as i64)) as f64 / 86_400_000.0;
+    if s.last_review_ms == 0 || days <= 0.0 { 0.0 } else { days.round().max(1.0) as f32 }
+}
 
 /// 单测独立文件。
 #[cfg(test)]
 
@@ -1,7 +1,9 @@
 //! db_flashcards 单测（内存库；AAA 模式）。
 
+use crate::commands_flashcards::review_card_inner;
 use crate::db::Db;
 use crate::db_flashcards::NewFlashcard;
+use crate::scheduler::{schedule, CardState, Rating};
 use crate::types::NewNoteGroup;
 
 /// 内存库。
@@ -224,3 +226,69 @@ fn update_card_back_roundtrip() {
     assert_eq!(fetched.back, new_back);
     assert!(!db.update_card_back(9999, "x").expect("miss"));
 }
+
+/// 复习过的卡状态 JSON（`reps=0` ⇒ `review_card` 内部按新卡态调度：间隔与 now 无关）。
+fn reviewed_state(last_review_ms: i64) -> String {
+    format!(
+        r#"{{"stability":0.0,"difficulty":0.0,"reps":0,"lapses":0,"lastReviewMs":{}}}"#,
+        last_review_ms
+    )
+}
+
+#[test]
+fn interval_days_new_card_is_zero_and_degraded_inputs_safe() {
+    // Arrange：新卡（state_json="{}" ⇒ lastReviewMs 缺键 ⇒ 0）
+    let db = mem_db();
+    let gid = make_group(&db);
+    // Act
+    let created = db.create_card(&card(gid, "新卡", 1000)).expect("create");
+    let fetched = db.get_card(created.id).expect("get").expect("exists");
+    // Assert：新卡无间隔——两路都 0.0（不发明 due_at/86400000 这类数字）
+    assert_eq!(created.interval_days, 0.0);
+    assert_eq!(fetched.interval_days, 0.0);
+    // Act/Assert（劣化输入）：lastReviewMs > due_at ⇒ 0.0；due_at 为负 ⇒ 0.0；均不 panic
+    db.update_card_schedule(created.id, &reviewed_state(9_000_000), 1000).expect("u1");
+    assert_eq!(db.get_card(created.id).expect("g1").expect("e1").interval_days, 0.0);
+    db.update_card_schedule(created.id, &reviewed_state(5000), -1).expect("u2");
+    assert_eq!(db.get_card(created.id).expect("g2").expect("e2").interval_days, 0.0);
+}
+
+#[test]
+fn interval_days_row_derived_is_whole_days() {
+    // Arrange：上次复习 T0、到期 T0+31 天（夹具构造；不读 stateJson 语义）
+    let db = mem_db();
+    let gid = make_group(&db);
+    let t0 = 1_700_000_000_000i64;
+    let mut new = card(gid, "极限", t0 + 31 * 86_400_000);
+    new.state_json = reviewed_state(t0);
+    db.create_card(&new).expect("create");
+    // Act：队列路径（5 个查询方法共用 row_to_card 供值）
+    let due = db.list_due_cards(None, i64::MAX, 10).expect("due");
+    // Assert：整天粒度 = round((due_at − lastReviewMs)/86400000).max(1)
+    assert_eq!(due.len(), 1);
+    assert_eq!(due[0].interval_days, 31.0);
+}
+
+#[test]
+fn review_card_returns_precise_interval_not_stale_row_value() {
+    // Arrange：行派生值刻意构造成 31 天（陈旧值）——本次评分必不等于它
+    let db = mem_db();
+    let gid = make_group(&db);
+    let t0 = 1_700_000_000_000i64;
+    let mut new = card(gid, "极限", t0 + 31 * 86_400_000);
+    new.state_json = reviewed_state(t0);
+    let id = db.create_card(&new).expect("create").id;
+    let stale = db.get_card(id).expect("get").expect("exists");
+    assert_eq!(stale.interval_days, 31.0, "②域：行派生整天粒度");
+    // Act：复习编排（命令壳只解引用 State ⇒ inner 等价于测全命令）
+    let returned = review_card_inner(&db, id, "good").expect("review");
+    // Assert：①域 = 当次 ScheduleOutcome.interval_days（reps=0 ⇒ 新卡态 ⇒ 与 now 无关）
+    assert_eq!(returned.interval_days, schedule(None, Rating::Good, 0).interval_days);
+    assert_ne!(returned.interval_days, stale.interval_days, "`..card` 不得漏出旧值");
+    // Assert：返回的间隔就是驱动 dueAt 的那一个（scheduler.rs:100 恒等式）
+    let next: CardState = serde_json::from_str(&returned.state_json).expect("next");
+    assert_eq!(
+        returned.due_at,
+        next.last_review_ms as i64 + (returned.interval_days.round() as i64).max(1) * 86_400_000
+    );
+}
@@ -31,7 +31,7 @@ fn contract_keys_and_order() {
     assert_wire!("MoveFragmentResult", MoveFragmentResult { moved: true, auto_cleaned_groups: vec!["g".into()] }, r#"{"moved":true,"autoCleanedGroups":["g"]}"#);
     assert_wire!("PromoteNoteResult", PromoteNoteResult { note: note(1), auto_cleaned_groups: vec!["g".into()] }, r#"{"note":{"id":1,"title":"t","content":"c","source":"manual","session_id":1,"rule_version":"r","purify_stats":"p","tags":"[]","properties":"{}","pin":1,"group_id":2,"created_at":3,"updated_at":4},"autoCleanedGroups":["g"]}"#);
     assert_wire!("Fragment", Fragment { id: 1, text: "t".into(), image_path: Some("p".into()), domain_tag: Some("d".into()), group_id: Some(2), source: "manual".into(), status: "active".into(), created_at: 3 }, r#"{"id":1,"text":"t","imagePath":"p","domainTag":"d","groupId":2,"source":"manual","status":"active","createdAt":3}"#);
-    assert_wire!("Flashcard", Flashcard { id: 1, group_id: 2, note_id: Some(3), fragment_id: Some(4), front: "f".into(), back: "b".into(), kind: "fact".into(), state_json: "{}".into(), due_at: 5, created_at: 6 }, r#"{"id":1,"groupId":2,"noteId":3,"fragmentId":4,"front":"f","back":"b","kind":"fact","stateJson":"{}","dueAt":5,"createdAt":6}"#);
+    assert_wire!("Flashcard", Flashcard { id: 1, group_id: 2, note_id: Some(3), fragment_id: Some(4), front: "f".into(), back: "b".into(), kind: "fact".into(), state_json: "{}".into(), due_at: 5, created_at: 6, interval_days: 1.5 }, r#"{"id":1,"groupId":2,"noteId":3,"fragmentId":4,"front":"f","back":"b","kind":"fact","stateJson":"{}","dueAt":5,"createdAt":6,"intervalDays":1.5}"#);
     assert_wire!("WeekContract", WeekContract { id: 1, group_id: 2, week_start: 3, target_days: 4, target_cards: 5, created_at: 6 }, r#"{"id":1,"groupId":2,"weekStart":3,"targetDays":4,"targetCards":5,"createdAt":6}"#);
     assert_wire!("NoteSortMode", NoteSortMode::UpdatedDesc, r#""updated-desc""#);
     assert_wire!("Session", Session { id: 1, title: "t".into(), source_window: Some("w".into()), started_at: 2, ended_at: Some(3), status: "finished".into(), profile: Some("p".into()), kind: Some("photo".into()) }, r#"{"id":1,"title":"t","source_window":"w","started_at":2,"ended_at":3,"status":"finished","profile":"p","kind":"photo"}"#);
 
@@ -244,6 +244,16 @@ pub struct Flashcard {
     /// 到期时刻（Unix 毫秒；due_at ≤ now 进复习队列）
     pub due_at: i64,
     pub created_at: i64,
+    /// 真实复习间隔天数（**只读**；前端唯一口径——不得用 dueAt 差值或字符数自造）。
+    ///
+    /// @ai-context: 两个精度域（PB2 裁决）：① `review_card` 返回体 = 当次调度的**精确值**
+    ///              （`ScheduleOutcome.interval_days` 当场显式覆写）；② 行派生路径
+    ///              （`row_to_card` 由 `due_at − stateJson.lastReviewMs` 反推，覆盖
+    ///              list_due_cards / get_card / card_by_fragment / list_cards_by_group /
+    ///              find_card_by_front）= **整天粒度**（DB 无 interval 列，f32 原值不可恢复）。
+    ///              新卡/无复习记录/劣化输入 ⇒ `0.0`（不发明数字）；确切时刻看 `dueAt`。
+    ///              契约不变：`stateJson` 仍是「后端调度契约，前端透传不解析」。
+    pub interval_days: f32,
 }
 
 /// 周契约（v0.11.4 REQ-200；弹性承诺呈现层——用户自设本周目标，非打卡 KPI）。