fix(infinity-daemon): reconcile persisted session statuses at startup

After a crash or `kill -9`, sessions persisted mid-flight in
`sessions.json` (`idle: false, shut_down: false`) loaded as `Running`
forever: the web UI showed green "running" dots for sessions with no live
driver (4 of 56 sessions on a real store).

* `SessionStore::reconcile_cold_start()` marks those entries idle right
  after load, before any client can connect, and the result is persisted.
  Stopped and archived entries are untouched; persisted pending choices
  still surface as `WaitingForChoice`, which ranks above `idle`.
* Test: `restart_reconciles_stale_sessions` (stale running -> Idle and
  written back to disk, stopped stays Stopped).

Author: akainth015

crates/infinity-daemon/src/session/mod.rs

@@ -156,10 +156,16 @@ impl SessionManager {
         let sessions_path = state_dir.join("sessions.json");
         let (change_tx, mut change_rx) = mpsc::unbounded_channel::<ThreadId>();
         let change_tx_for_conv = change_tx.clone();
-        let session_store = Arc::new(tokio::sync::Mutex::new(session_store::SessionStore::load(
-            &sessions_path.to_string_lossy(),
-            change_tx,
-        )));
+        let session_store = {
+            let mut store =
+                session_store::SessionStore::load(&sessions_path.to_string_lossy(), change_tx);
+            if store.reconcile_cold_start()
+                && let Err(e) = store.save()
+            {
+                tracing::error!("failed to persist reconciled session statuses: {e}");
+            }
+            Arc::new(tokio::sync::Mutex::new(store))
+        };
         let broadcast_clients: Arc<std::sync::Mutex<Vec<mpsc::UnboundedSender<DaemonMessage>>>> =
             Arc::new(std::sync::Mutex::new(Vec::new()));
 

crates/infinity-daemon/src/session/tests.rs

@@ -778,3 +778,60 @@ async fn shut_down_session_events_do_not_wake_threads() {
         })
         .await;
 }
+
+/// A session persisted as running by a daemon that died mid-completion must
+/// come back Idle (and stay so on disk), not Running forever; an explicitly
+/// stopped session stays Stopped.
+#[tokio::test(flavor = "current_thread")]
+async fn restart_reconciles_stale_sessions() {
+    let local = tokio::task::LocalSet::new();
+    local
+        .run_until(async {
+            let (model, _ctrl) = mock_model();
+            let entry = ModelEntry {
+                model_id: "model1".to_owned(),
+                display_name: "model1".to_owned(),
+                context_window: 100_000,
+                max_output_tokens: None,
+                supports_image_input: false,
+            };
+            let state_dir = tempfile::tempdir().expect("create daemon state dir");
+            let sessions_path = state_dir.path().join("sessions.json");
+            let sessions = serde_json::json!({ "sessions": {
+                "killed": { "cwd": "/tmp", "shut_down": false, "idle": false },
+                "stopped": { "cwd": "/tmp", "shut_down": true, "idle": false },
+            }});
+            std::fs::write(&sessions_path, sessions.to_string()).expect("write sessions.json");
+
+            let manager = SessionManager::with_providers(
+                SessionManagerConfig {
+                    state_dir: state_dir.path().to_path_buf(),
+                    callback_url: "http://127.0.0.1:0".to_owned(),
+                    user_rap_config: None,
+                    id_source: Arc::new(SequentialIdSource::new()),
+                },
+                vec![(
+                    "provider1".to_owned(),
+                    Arc::new(SingleModelProvider::new(entry, model)) as Arc<dyn ModelProvider>,
+                )],
+                vec![],
+            )
+            .await
+            .expect("build session manager");
+
+            let sessions = manager.list_sessions(None).await;
+            let status = |id: &str| {
+                sessions[&infinity_protocol::ThreadRef::local(ThreadId::from_ref(id).to_owned())]
+                    .status
+                    .clone()
+            };
+            assert_eq!(status("killed"), SessionStatus::Idle);
+            assert_eq!(status("stopped"), SessionStatus::Stopped);
+            let persisted: serde_json::Value = serde_json::from_str(
+                &std::fs::read_to_string(&sessions_path).expect("read sessions.json"),
+            )
+            .expect("parse sessions.json");
+            assert_eq!(persisted["sessions"]["killed"]["idle"], true);
+        })
+        .await;
+}

crates/infinity-daemon/src/session_store.rs

@@ -97,6 +97,22 @@ impl SessionStore {
         Ok(())
     }
 
+    /// At cold start no drivers exist, so entries persisted as running
+    /// (`!idle && !shut_down`, e.g. after a crash) are stale: mark them idle.
+    /// Returns whether any entry changed. Does not `notify`, since no client
+    /// is connected yet.
+    pub fn reconcile_cold_start(&mut self) -> bool {
+        let mut changed = false;
+        for (id, entry) in &mut self.sessions {
+            if !entry.idle && !entry.shut_down {
+                tracing::info!("session {id} was persisted as running; marking it idle");
+                entry.idle = true;
+                changed = true;
+            }
+        }
+        changed
+    }
+
     pub fn notify(&self, session_id: &ThreadId<str>) {
         if let Some(ref tx) = self.change_tx {
             let _ = tx.send(session_id.to_owned());