fix(live-session): 暂停边沿吸收 own_pending 并补发丢采样恢复沿

P2-2：上升沿同稳态先吸收 own_pending 的完成增量（delta_eff>0 才合成），
消除 manual <500ms 往返链上把本已可见暂停重复合成为 Pause/Resume 对。
P2-3：稳态真吸收 own 完成后，若完成区间 resume 晚于已发 Pause 事件时刻
（恢复沿丢采样），补发合成 Resume + flush_cut + 复位 pause_processed，
阻断暂停区间时长虚高与跨边界连句（路径 C）。
测试：+4 真值表用例（上升沿 own_pending delta 1/2、P2-3 分支与对照），
flap 稳态用例按新语义更新；全量 app_lib_tests 2327 通过。

Author: Aparencia

app/src-tauri/src/live_session_pause.rs

@@ -63,8 +63,9 @@ pub(crate) struct PauseEdgeView {
     /// 已消化的区间计数（delta = seq - view.seq 即待判定的漏检区间数）
     pub seq: u64,
     /// 当前可见暂停区间的完成增量(+1)尚未被吸收（loop 已见上升沿但恢复的
-    /// Start 尚未执行，或 loop 起点即在暂停中）——对应 +1 到达时吸收一次，
-    /// 防把"本已可见的暂停"重复合成为漏检区间
+    /// Start 尚未执行，或 loop 起点即在暂停中）——对应 +1 到达时在稳态/
+    /// 上升沿/下降沿任一观察吸收一次，防把"本已可见的暂停"重复合成为
+    /// 漏检区间
     pub own_pending: bool,
     /// 当前暂停的上升沿是否已处理（未处理=引擎可能未清流——恢复边沿防御 flush）
     pub pause_processed: bool,
@@ -124,13 +125,18 @@ fn push_synth(
 /// +1，**含 loop 已可见处理的暂停区间**——完成增量须按归属吸收）：
 /// - own_pending=当前可见暂停的完成增量未吸收：上升沿置真；下降沿 delta 0
 ///   （恢复抢跑，Start 未执行）保持真；下降沿 delta ≥ 1（自身完成已在
-///   delta 内）与稳态吸收（+1 到达）后置假。loop 起点即在暂停中 → new 即真。
-///   上升沿覆盖旧 own_pending（旧期物理未结束——完成增量并入新期下降沿吸收）。
+///   delta 内）与稳态/上升沿吸收（own_pending 的 +1 到达）后置假。loop
+///   起点即在暂停中 → new 即真。旧完成增量在上升沿未到（delta 0）→ 待吸收
+///   位并入新期（由新期稳态/下降沿吸收一次）。
 /// - 稳态（标志未变）：delta 0 → 无；先吸收 own_pending 的 +1，余下 delta 为
 ///   双沿都漏检的区间（稳态假=轮询窗内往返；稳态真=暂停期 flap）→ 合成事件
-///   对 + flush_cut（引擎可能跨漏区间连句）
-/// - 上升沿（→暂停）：可见暂停事件 + flush_cut（no-rescore 断句）；delta ≥ 1
-///   = 此前的漏检完整区间 → 先补合成对
+///   对 + flush_cut（引擎可能跨漏区间连句）；稳态真吸收 own 完成且无余量
+///   时，若完成区间 resume 晚于已发 Pause 事件时刻（可见暂停的恢复沿丢
+///   采样）→ 补发合成 Resume + flush_cut + 复位 pause_processed（P2-3，
+///   见分支注释）
+/// - 上升沿（→暂停）：可见暂停事件 + flush_cut（no-rescore 断句）；先吸收
+///   own_pending 的 +1（其恢复沿若已可见发出，不得重复合成），余下
+///   delta_eff ≥ 1 = 此前的真漏检完整区间 → 先补合成对
 /// - 下降沿（→恢复）：可见恢复事件；delta ≥ 1 吸收自身区间完成 +1，余下
 ///   k = delta-1 为暂停期 flap → 合成 + flush_cut；!pause_processed（loop
 ///   起点即在暂停中，引擎未清流）→ 防御 flush（边界保护）
@@ -166,12 +172,42 @@ pub(crate) fn plan_edge_observation(
         if delta_eff > 0 {
             push_synth(&mut out, &mut next, interval, reason, session_now);
             out.flush_cut = true;
+        } else if paused_now && view.own_pending {
+            // P2-3（审查修复）：吸收的 +1 = 本已可见暂停**自身**区间的完成——
+            // 物理恢复已发生但 loop 未采到恢复沿（恢复+再次暂停同落一个
+            // <500ms 未采样窗，该次恢复从未落库，暂停区间会并入下次可见
+            // 恢复造成时长虚高）。若完成区间 resume 晚于已发出的 Pause
+            // 事件时刻（存在未见过的恢复沿）→ 补发合成 Resume（时刻夹逼
+            // ≥ Pause 事件保 DB 单调）+ flush_cut（恢复后采到的内容跨该
+            // 边界不得与后续连句——路径 C 防护）+ 复位 pause_processed
+            // （当前暂停=恢复后的再次暂停，其上升沿从未处理——后续下降沿
+            // k=0 时不再静默放行，防御 flush 兜底）。resume 不晚于 Pause
+            // 事件时刻 = 更早一次**已见**恢复（抢跑下降沿已发可见 Resume）
+            // 的迟到完成增量 → 保持现状（静默吸收）。
+            if let Some((iv, last_p)) =
+                interval.zip(view.last_pause_ms).filter(|(iv, p)| iv.resume_ms > *p)
+            {
+                let r = iv.resume_ms.max(last_p);
+                out.events.push(PlanEvent {
+                    kind: PlanEventKind::Resume,
+                    source: iv.source,
+                    moment_ms: r,
+                });
+                out.flush_cut = true;
+                next.pause_processed = false;
+            }
         }
     } else if paused_now {
-        // 上升沿：可见暂停。delta ≥ 1 = 此前的漏检完整区间（先补合成对）；
-        // 旧 own_pending 丢弃（旧期物理未结束——完成增量并入新期下降沿吸收）
-        out.missed_count = delta as u32;
-        if delta > 0 {
+        // 上升沿：可见暂停。先吸收 own_pending 的完成增量（+1——它对应本已
+        // 可见暂停的物理完成，其恢复沿已按可见边沿发出事件；不吸收会把
+        // delta 全数当漏检，manual <500ms 往返链上把已见暂停重复合成为
+        // Pause/Resume 对——DB 序倒挂 + missed_count 误报 + 多余 flush），
+        // 余下 delta_eff ≥ 1 = 此前的真漏检完整区间（先补合成对）；delta 0
+        // = 旧完成增量未到——待吸收位并入新期（下方 own_pending 保持真，
+        // 由新期稳态/下降沿吸收一次）
+        let delta_eff = delta.saturating_sub(u64::from(view.own_pending));
+        out.missed_count = delta_eff as u32;
+        if delta_eff > 0 {
             push_synth(&mut out, &mut next, interval, reason, session_now);
         }
         let src = reason.unwrap_or(PauseSource::Manual);

app/src-tauri/src/live_session_pause_tests.rs

@@ -192,14 +192,22 @@ fn genuine_missed_interval_still_synthesized_after_absorb() {
 
 #[test]
 fn flap_during_paused_steady_state_synthesized_at_resume() {
-    // Arrange：loop 见暂停（处理过），暂停期内用户恢复又暂停（flap）——
-    // flag 稳态真，seq +1（flap 的 Start 已执行）
+    // Arrange：loop 见暂停 P1（Pause 事件 @3000，上升沿已处理），随后用户恢复
+    // +再次暂停都落在同一 <500ms 未采样窗（loop 只见稳态真）——P1 自身区间
+    // 完成（实测 resume @3500，晚于 Pause 事件时刻 = 恢复沿丢采样）
     let v = PauseEdgeView { own_pending: true, pause_processed: true, last_pause_ms: Some(3000), ..view(true, 0) };
-    // Act：稳态真 delta 1 = 自身完成（absorb 后无漏检）
+    // Act：稳态真 delta 1 = own 完成（吸收后 delta_eff=0）
     let (a1, n1) = plan_edge_observation(&v, true, 1, Some(PauseSource::Manual), Some(iv(3000, 3500, PauseSource::Manual)), 4000);
-    assert!(a1.events.is_empty(), "自身完成被吸收，不合成");
-    assert!(!a1.flush_cut);
-    // Act：第二个 flap 完成（delta 又 +1——真漏检）
+    // Assert：该次恢复从未落库 → P2-3 补发合成 Resume（实测恢复沿）+ 边界切断
+    assert_eq!(a1.events.len(), 1);
+    assert_eq!(a1.events[0].kind, PlanEventKind::Resume);
+    assert_eq!(a1.events[0].source, PauseSource::Manual);
+    assert_eq!(a1.events[0].moment_ms, 3500);
+    assert_eq!(a1.missed_count, 0, "own 完成吸收——非漏检区间，不误报");
+    assert!(a1.flush_cut, "恢复后采到的内容不得与后续连句——切断边界");
+    assert!(!n1.own_pending);
+    assert!(!n1.pause_processed, "再次暂停的上升沿未处理——防御 flush 重新武装");
+    // Act：暂停期再真漏检一个 flap（另一轮恢复+暂停，delta 又 +1——真漏检）
     let (a2, _n2) = plan_edge_observation(
         &n1,
         true,
@@ -208,9 +216,12 @@ fn flap_during_paused_steady_state_synthesized_at_resume() {
         Some(iv(4200, 4400, PauseSource::Media)),
         4500,
     );
+    // Assert：真漏检 flap 仍合成一对（合成 Resume 在前，事件时刻保持非降）
     assert_eq!(a2.events.len(), 2, "真漏检 flap 合成一对");
+    assert_eq!(a2.events[0].kind, PlanEventKind::Pause);
     assert_eq!(a2.events[0].moment_ms, 4200);
     assert!(a2.flush_cut, "flap 内容在引擎流里连句——恢复边沿需断句");
+    assert!(a2.events[0].moment_ms >= a1.events[0].moment_ms, "DB 序单调");
 }
 
 #[test]
@@ -284,3 +295,101 @@ fn init_view_snapshots_paused_state_with_pending_absorption() {
     assert!(!v2.flag);
     assert!(!v2.own_pending);
 }
+
+#[test]
+fn rising_absorbs_own_pending_instead_of_duplicate_synth() {
+    // Arrange（P2-2）：上一可见暂停的恢复抢跑（下降沿 delta 0 已发可见
+    // Resume，own_pending 保持真），其 Start 完成增量直到下一次可见暂停的
+    // 上升沿才到达（manual <500ms 往返链形态）——delta 1 全数 = own 增量
+    let v = PauseEdgeView { own_pending: true, pause_processed: true, last_pause_ms: Some(4000), ..view(false, 0) };
+    // Act：上升沿 + delta 1（槽=own 区间的实测时刻）
+    let (action, next) = plan_edge_observation(
+        &v,
+        true,
+        1,
+        Some(PauseSource::Manual),
+        Some(iv(3000, 4050, PauseSource::Manual)),
+        6000,
+    );
+    // Assert：own 增量被吸收——不得把本已可见的暂停重复合成为 Pause/Resume
+    // 对（DB 序倒挂 + missed_count 误报 + 多余 flush）；只发可见 Pause
+    assert_eq!(action.events.len(), 1);
+    assert_eq!(action.events[0].kind, PlanEventKind::Pause);
+    assert_eq!(action.events[0].moment_ms, 6000);
+    assert_eq!(action.missed_count, 0, "own 完成增量吸收——不再误报漏检");
+    assert!(action.flush_cut, "可见暂停上升沿照常断句");
+    assert_eq!(next.last_pause_ms, Some(6000));
+    assert!(next.own_pending, "新可见暂停的完成增量待吸收");
+    assert_eq!(next.seq, 1);
+}
+
+#[test]
+fn rising_absorbs_own_pending_then_synths_only_extra_missed() {
+    // Arrange（P2-2 delta 2 语义）：own 完成增量与一个真漏检 flap 的完成
+    // 增量同落一次上升沿观察——吸收 own +1 后余 1 为真漏检（槽只保最近
+    // 完成区间 = flap，先于可见暂停补合成对）
+    let v = PauseEdgeView { own_pending: true, pause_processed: true, last_pause_ms: Some(4000), ..view(false, 0) };
+    // Act
+    let (action, next) = plan_edge_observation(
+        &v,
+        true,
+        2,
+        Some(PauseSource::Manual),
+        Some(iv(5000, 5200, PauseSource::Media)),
+        9000,
+    );
+    // Assert：合成对（真漏检 flap，时刻取槽）+ 可见 Pause；missed_count=1
+    assert_eq!(action.events.len(), 3);
+    assert_eq!(action.events[0].kind, PlanEventKind::Pause);
+    assert_eq!(action.events[0].moment_ms, 5000);
+    assert_eq!(action.events[0].source, PauseSource::Media);
+    assert_eq!(action.events[1].kind, PlanEventKind::Resume);
+    assert_eq!(action.events[1].moment_ms, 5200);
+    assert_eq!(action.events[2].kind, PlanEventKind::Pause);
+    assert_eq!(action.events[2].moment_ms, 9000);
+    assert_eq!(action.missed_count, 1);
+    assert!(action.flush_cut);
+    assert!(next.pause_processed);
+    assert!(next.own_pending);
+    assert_eq!(next.last_pause_ms, Some(9000));
+}
+
+#[test]
+fn steady_true_absorb_of_unseen_recovery_synthesizes_resume_and_cuts() {
+    // Arrange（P2-3 分支）：可见暂停的 Pause 事件 @3000 已发出，随后其物理
+    // 恢复（resume 实测 @3500，晚于 Pause 事件时刻）+再次暂停都落在同一
+    // <500ms 未采样窗——恢复沿从未被 loop 采到、从未落库
+    let v = PauseEdgeView { own_pending: true, pause_processed: true, last_pause_ms: Some(3000), ..view(true, 0) };
+    // Act：稳态真 delta 1 = own 完成（吸收后 delta_eff=0）
+    let (action, next) = plan_edge_observation(&v, true, 1, Some(PauseSource::Manual), Some(iv(3000, 3500, PauseSource::Media)), 4000);
+    // Assert：补发合成 Resume（时刻=实测恢复沿，≥ Pause 事件保单调）+ 边界
+    // 切断（恢复后采到的内容不得与后续连句）+ 防御 flush 重新武装
+    assert_eq!(action.events.len(), 1);
+    assert_eq!(action.events[0].kind, PlanEventKind::Resume);
+    assert_eq!(action.events[0].source, PauseSource::Media);
+    assert_eq!(action.events[0].moment_ms, 3500);
+    assert!(action.flush_cut);
+    assert_eq!(action.missed_count, 0, "own 恢复非漏检——不误报");
+    assert!(!next.own_pending);
+    assert!(!next.pause_processed, "再次暂停的上升沿未处理——恢复边沿防御 flush 兜底");
+    assert_eq!(next.seq, 1);
+}
+
+#[test]
+fn steady_true_absorb_without_unseen_recovery_stays_silent() {
+    // Arrange（P2-3 对照——"无未见恢复沿"）：own 完成增量是**更早一次已见
+    // 恢复**（抢跑下降沿已发可见 Resume）的迟到完成：其 Start 在下一可见
+    // 暂停期间才执行，完成区间 resume（@5000）不晚于已发出的 Pause 事件
+    // 时刻（@6000 = 下一可见暂停的上升沿）
+    let v = PauseEdgeView { own_pending: true, pause_processed: true, last_pause_ms: Some(6000), ..view(true, 0) };
+    // Act：稳态真吸收 own 完成（delta_eff=0）
+    let (action, next) = plan_edge_observation(&v, true, 1, Some(PauseSource::Manual), Some(iv(4000, 5000, PauseSource::Manual)), 7000);
+    // Assert：静默吸收——不补 Resume 不 flush（对应恢复已按可见沿发出，
+    // 补发即重复）；防御 flush 状态保持现状
+    assert!(action.events.is_empty(), "已见恢复的迟到完成增量静默吸收");
+    assert!(!action.flush_cut);
+    assert_eq!(action.missed_count, 0);
+    assert!(!next.own_pending);
+    assert!(next.pause_processed, "无未见恢复沿——防御 flush 不重新武装");
+    assert_eq!(next.seq, 1);
+}