feat(#1591): surface pending-login + crashing-agent banner warnings

hive-c0re/src/coordinator.rs

@@ -114,6 +114,14 @@ pub struct Coordinator {
     /// watcher consults both this and the active map before declaring
     /// a stop deliberate.
     recent_transient: Mutex<HashMap<String, (TransientKind, std::time::Instant)>>,
+    /// Timestamps of recent unexpected container crashes, keyed by agent.
+    /// Fed by `crash_watch` each time it classifies a stop as a crash (so
+    /// a crash-looping container — which `Restart=on-failure` flips back
+    /// to running between polls — accumulates one entry per down-transition,
+    /// not just whatever its point-in-time state happens to be). Read by
+    /// the dashboard's `agents_crashing` banner warning via
+    /// `recent_crash_counts`, which prunes entries older than its window.
+    recent_crashes: Mutex<HashMap<String, Vec<std::time::Instant>>>,
     /// Unified wire-facing event channel feeding the dashboard SSE
     /// stream. Carries broker messages (mirrored from `broker.subscribe`
     /// by the forwarder task in `main.rs`) and dashboard-only mutation
@@ -430,6 +438,7 @@ impl Coordinator {
             agents: Mutex::new(HashMap::new()),
             transient: Mutex::new(HashMap::new()),
             recent_transient: Mutex::new(HashMap::new()),
+            recent_crashes: Mutex::new(HashMap::new()),
             dashboard_events,
             event_seq: AtomicU64::new(0),
             meta_updates_active: AtomicU64::new(0),
@@ -1075,6 +1084,33 @@ impl Coordinator {
             .collect()
     }
 
+    /// Record an unexpected crash for `agent`. Called by the crash
+    /// watcher whenever it classifies a container stop as a crash (not an
+    /// operator action). Append-only here; pruning happens lazily on read
+    /// in `recent_crash_counts`.
+    pub fn record_crash(&self, agent: &str) {
+        self.recent_crashes
+            .lock()
+            .unwrap()
+            .entry(agent.to_owned())
+            .or_default()
+            .push(std::time::Instant::now());
+    }
+
+    /// Per-agent count of crashes within the last `window`. Lazily reaps
+    /// older timestamps and drops agents with none left, so the map stays
+    /// bounded and only lists agents actively crashing. Powers the
+    /// dashboard's `agents_crashing` banner warning.
+    pub fn recent_crash_counts(&self, window: std::time::Duration) -> HashMap<String, usize> {
+        let now = std::time::Instant::now();
+        let mut map = self.recent_crashes.lock().unwrap();
+        map.retain(|_, times| {
+            times.retain(|ts| now.duration_since(*ts) <= window);
+            !times.is_empty()
+        });
+        map.iter().map(|(k, v)| (k.clone(), v.len())).collect()
+    }
+
     /// Set a transient state and return a guard that clears it on drop.
     /// Use this from any path where the surrounding future could be
     /// cancelled or panic between set and clear (HTTP handlers, spawned