fix: share session watcher ongoing status with picker via AppState

The session watcher has the most accurate ongoing detection (full chunk
analysis + subagent tracking). Store its verdict in AppState so that
discover_sessions and picker-refresh events always return correct
is_ongoing values. This eliminates the frontend syncOngoing effect and
the one-render-delay flicker after refreshing the project tree.

- Add watched_session_ongoing field to AppState
- Session watcher updates AppState after computing ongoing
- discover_sessions and picker watcher apply the override
- Remove frontend syncOngoing from usePicker and App

Entire-Checkpoint: b84cce8c97ad

Author: delexw

src-tauri/Cargo.lock

@@ -13,7 +13,11 @@ pub async fn discover_sessions(
     state: State<'_, AppState>,
 ) -> Result<Vec<SessionInfo>, String> {
     let cache = state.session_cache.lock().map_err(|e| e.to_string())?;
-    cache.discover_all_project_sessions(&project_dirs)
+    let mut sessions = cache.discover_all_project_sessions(&project_dirs)?;
+    // The session watcher has the most accurate ongoing detection, so apply
+    // its verdict over the picker's lightweight metadata scan.
+    state.apply_watched_ongoing(&mut sessions);
+    Ok(sessions)
 }
 
 /// Start watching project directories for new/changed sessions.

src-tauri/src/commands/picker.rs

@@ -11,7 +11,7 @@ use crate::watcher::start_session_watcher;
 
 /// Load a session file and return display messages.
 #[tauri::command]
-pub async fn load_session(path: String) -> Result<LoadResult, String> {
+pub async fn load_session(path: String, state: State<'_, AppState>) -> Result<LoadResult, String> {
     if path.is_empty() {
         return Err("no session path provided".to_string());
     }
@@ -27,6 +27,9 @@ pub async fn load_session(path: String) -> Result<LoadResult, String> {
 
     let ongoing = OngoingChecker::new(&chunks, &all_procs, &path).is_ongoing();
 
+    // Set initial ongoing status so picker has it immediately.
+    state.set_watched_ongoing(path.clone(), ongoing);
+
     let teams = reconstruct_teams(&chunks, &all_procs);
     let messages = chunks_to_messages(&chunks, &all_procs, &color_map);
     let meta = extract_session_meta(&path);
@@ -109,5 +112,6 @@ pub async fn get_project_dirs(state: State<'_, AppState>) -> Result<Vec<String>,
 /// Stop watching the current session.
 #[tauri::command]
 pub async fn unwatch_session(state: State<'_, AppState>) -> Result<(), String> {
+    state.clear_watched_ongoing();
     state.stop_session_watcher()
 }

src-tauri/src/commands/session.rs

@@ -10,6 +10,9 @@ pub struct AppState {
     pub picker_watcher: Mutex<Option<WatcherHandle>>,
     pub session_cache: Mutex<SessionCache>,
     pub settings: Mutex<Settings>,
+    /// Ongoing status reported by the session watcher for the currently viewed session.
+    /// (session_path, is_ongoing) — kept in sync by the session watcher loop.
+    pub watched_session_ongoing: Mutex<Option<(String, bool)>>,
 }
 
 impl AppState {
@@ -19,6 +22,7 @@ impl AppState {
             picker_watcher: Mutex::new(None),
             session_cache: Mutex::new(SessionCache::new()),
             settings: Mutex::new(crate::settings::load_settings()),
+            watched_session_ongoing: Mutex::new(None),
         }
     }
 
@@ -53,4 +57,34 @@ impl AppState {
         *guard = Some(handle);
         Ok(())
     }
+
+    /// Update the ongoing status for the currently watched session.
+    pub fn set_watched_ongoing(&self, path: String, ongoing: bool) {
+        if let Ok(mut guard) = self.watched_session_ongoing.lock() {
+            *guard = Some((path, ongoing));
+        }
+    }
+
+    /// Clear the watched session ongoing status (e.g. when unwatching).
+    pub fn clear_watched_ongoing(&self) {
+        if let Ok(mut guard) = self.watched_session_ongoing.lock() {
+            *guard = None;
+        }
+    }
+
+    /// Apply the session watcher's ongoing status to a list of sessions.
+    /// The session watcher has the most accurate ongoing detection (full chunk
+    /// analysis + subagent tracking), so its verdict overrides the picker's
+    /// lightweight metadata scan.
+    pub fn apply_watched_ongoing(&self, sessions: &mut [crate::parser::session::SessionInfo]) {
+        let guard = match self.watched_session_ongoing.lock() {
+            Ok(g) => g,
+            Err(_) => return,
+        };
+        if let Some((ref path, ongoing)) = *guard {
+            if let Some(s) = sessions.iter_mut().find(|s| s.path == *path) {
+                s.is_ongoing = ongoing;
+            }
+        }
+    }
 }

src-tauri/src/state.rs

@@ -1,7 +1,7 @@
 use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
 use std::path::Path;
 use std::time::Duration;
-use tauri::{AppHandle, Emitter};
+use tauri::{AppHandle, Emitter, Manager};
 use tokio::sync::mpsc;
 
 use crate::convert::*;
@@ -150,6 +150,11 @@ pub fn start_session_watcher(
 
                     let ongoing = OngoingChecker::new(&chunks, &all_procs, &path_for_rebuild).is_ongoing();
 
+                    // Share ongoing status with AppState so the picker can use it.
+                    if let Some(state) = app.try_state::<crate::state::AppState>() {
+                        state.set_watched_ongoing(path_for_rebuild.clone(), ongoing);
+                    }
+
                     let teams = reconstruct_teams(&chunks, &all_procs);
                     let messages = chunks_to_messages(&chunks, &all_procs, &color_map);
 
@@ -244,9 +249,15 @@ pub fn start_picker_watcher(project_dirs: Vec<String>, app: AppHandle) -> Watche
                     break;
                 }
                 Some(()) = signal_rx.recv() => {
-                    let sessions = crate::parser::session::discover_all_project_sessions(&project_dirs)
+                    let mut sessions = crate::parser::session::discover_all_project_sessions(&project_dirs)
                         .unwrap_or_default();
 
+                    // Apply the session watcher's ongoing status (more accurate
+                    // than the picker's lightweight metadata scan).
+                    if let Some(state) = app.try_state::<crate::state::AppState>() {
+                        state.apply_watched_ongoing(&mut sessions);
+                    }
+
                     let payload = PickerRefreshPayload { sessions };
                     let _ = app.emit("picker-refresh", payload);
                 }

src-tauri/src/watcher.rs

@@ -62,13 +62,6 @@ export function App() {
     return () => clearInterval(id);
   }, [session.ongoing]);
 
-  // Sync session ongoing state to picker tree
-  useEffect(() => {
-    if (session.sessionPath) {
-      picker.syncOngoing(session.sessionPath, session.ongoing);
-    }
-  }, [session.ongoing, session.sessionPath, picker]);
-
   // Shared: fetch project dirs and discover sessions
   const loadProjectDirs = useCallback(async () => {
     try {

src/App.tsx

@@ -40,17 +40,6 @@ export function usePicker(selectedProject: string | null = null) {
     setState((prev) => ({ ...prev, searchQuery: query }));
   }, []);
 
-  /** Sync ongoing status from the session watcher into the picker list. */
-  const syncOngoing = useCallback((sessionPath: string, ongoing: boolean) => {
-    setState((prev) => {
-      const idx = prev.sessions.findIndex((s) => s.path === sessionPath);
-      if (idx === -1 || prev.sessions[idx].is_ongoing === ongoing) return prev;
-      const sessions = [...prev.sessions];
-      sessions[idx] = { ...sessions[idx], is_ongoing: ongoing };
-      return { ...prev, sessions };
-    });
-  }, []);
-
   // Listen for picker-refresh events (backend already applies staleness)
   useTauriEvent<{ sessions: SessionInfo[] }>("picker-refresh", (payload) => {
     setState((prev) => ({
@@ -90,6 +79,5 @@ export function usePicker(selectedProject: string | null = null) {
     searchQuery: state.searchQuery,
     setSearchQuery,
     discoverSessions,
-    syncOngoing,
   };
 }