feat: surface ecc2 recovery events

ecc2/src/session/store.rs

@@ -46,6 +46,22 @@ impl DaemonActivity {
     pub fn dispatch_cooloff_active(&self) -> bool {
         self.prefers_rebalance_first() && self.last_dispatch_deferred >= 2
     }
+
+    pub fn chronic_saturation_cleared_at(
+        &self,
+    ) -> Option<&chrono::DateTime<chrono::Utc>> {
+        if self.prefers_rebalance_first() {
+            return None;
+        }
+
+        match (
+            self.last_dispatch_at.as_ref(),
+            self.last_recovery_dispatch_at.as_ref(),
+        ) {
+            (Some(dispatch_at), Some(recovery_at)) if recovery_at > dispatch_at => Some(recovery_at),
+            _ => None,
+        }
+    }
 }
 
 impl StateStore {
@@ -1068,6 +1084,7 @@ mod tests {
         let clear = DaemonActivity::default();
         assert!(!clear.prefers_rebalance_first());
         assert!(!clear.dispatch_cooloff_active());
+        assert!(clear.chronic_saturation_cleared_at().is_none());
 
         let unresolved = DaemonActivity {
             last_dispatch_at: Some(now),
@@ -1083,6 +1100,7 @@ mod tests {
         };
         assert!(unresolved.prefers_rebalance_first());
         assert!(unresolved.dispatch_cooloff_active());
+        assert!(unresolved.chronic_saturation_cleared_at().is_none());
 
         let recovered = DaemonActivity {
             last_recovery_dispatch_at: Some(now + chrono::Duration::seconds(1)),
@@ -1091,5 +1109,9 @@ mod tests {
         };
         assert!(!recovered.prefers_rebalance_first());
         assert!(!recovered.dispatch_cooloff_active());
+        assert_eq!(
+            recovered.chronic_saturation_cleared_at(),
+            recovered.last_recovery_dispatch_at.as_ref()
+        );
     }
 }