Optimize TUI startup with async session loading (#26)

* Load sessions asynchronously at startup

* Address async loading review feedback

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: Copilot

src/app.rs

@@ -126,22 +126,26 @@ pub struct App {
     remote_log_receiver: Receiver<(String, String)>,
     /// Remote session IDs whose logs are currently loading in the background.
     remote_logs_loading: HashSet<String>,
+    /// Sends completed session loads from background workers to the main loop.
+    session_load_sender: Sender<(u64, Vec<CopilotSession>)>,
+    /// Receives completed session loads without blocking startup or rendering.
+    session_load_receiver: Receiver<(u64, Vec<CopilotSession>)>,
+    /// Whether a session list load is currently in flight.
+    sessions_loading: bool,
+    /// Monotonically increasing token used to ignore stale background loads.
+    session_load_generation: u64,
 }
 
 impl App {
     pub fn new(copilot_dir: PathBuf, launch_dir: PathBuf) -> Self {
-        let sessions = load_sessions(&copilot_dir);
-        let flat_list = build_flat_list(&sessions, SessionFilter::All, "");
-
-        let selected_session = flat_list.first().copied();
-        let cursor = 0;
         let (remote_log_sender, remote_log_receiver) = mpsc::channel();
+        let (session_load_sender, session_load_receiver) = mpsc::channel();
 
         App {
-            sessions,
-            flat_list,
-            cursor,
-            selected_session,
+            sessions: Vec::new(),
+            flat_list: Vec::new(),
+            cursor: 0,
+            selected_session: None,
             active_panel: Panel::Sessions,
             copilot_dir,
             launch_dir,
@@ -164,11 +168,36 @@ impl App {
             remote_log_sender,
             remote_log_receiver,
             remote_logs_loading: HashSet::new(),
+            session_load_sender,
+            session_load_receiver,
+            sessions_loading: false,
+            session_load_generation: 0,
         }
     }
 
     pub fn reload(&mut self) {
-        self.replace_sessions(load_sessions(&self.copilot_dir));
+        self.session_load_generation = self.session_load_generation.wrapping_add(1);
+        self.sessions_loading = true;
+        let generation = self.session_load_generation;
+        let copilot_dir = self.copilot_dir.clone();
+        let sender = self.session_load_sender.clone();
+        std::thread::spawn(move || {
+            let sessions = load_sessions(&copilot_dir);
+            let _ = sender.send((generation, sessions));
+        });
+    }
+
+    pub fn poll_session_loads(&mut self) {
+        while let Ok((generation, sessions)) = self.session_load_receiver.try_recv() {
+            if generation == self.session_load_generation {
+                self.sessions_loading = false;
+                self.replace_sessions(sessions);
+            }
+        }
+    }
+
+    pub fn is_loading_sessions(&self) -> bool {
+        self.sessions_loading
     }
 
     pub fn refresh_statuses(&mut self) -> bool {
@@ -263,8 +292,10 @@ impl App {
             .find(|session| !baseline.contains(&session.id))
             .map(|session| session.id.clone())?;
 
+        self.session_load_generation = self.session_load_generation.wrapping_add(1);
         self.new_session_reload_baseline = None;
         self.replace_sessions(sessions);
+        self.sessions_loading = false;
         Some(new_session_id)
     }
 
@@ -493,7 +524,7 @@ impl App {
         let sender = self.remote_log_sender.clone();
         std::thread::spawn(move || {
             let log = load_remote_task_log(&id);
-            drop(sender.send((id, log)));
+            let _ = sender.send((id, log));
         });
     }
 
@@ -769,6 +800,7 @@ mod tests {
 
     fn app_with_sessions(sessions: Vec<CopilotSession>) -> App {
         let (remote_log_sender, remote_log_receiver) = mpsc::channel();
+        let (session_load_sender, session_load_receiver) = mpsc::channel();
         let flat_list = build_flat_list(&sessions, SessionFilter::All, "");
         let selected_session = flat_list.first().copied();
         App {
@@ -798,6 +830,10 @@ mod tests {
             remote_log_sender,
             remote_log_receiver,
             remote_logs_loading: HashSet::new(),
+            session_load_sender,
+            session_load_receiver,
+            sessions_loading: false,
+            session_load_generation: 0,
         }
     }
 
@@ -1060,6 +1096,43 @@ mod tests {
         assert_eq!(app.directory_suggestion_cursor(), Some(1));
     }
 
+    #[test]
+    fn app_new_starts_with_empty_non_loading_session_list() {
+        let app = App::new(PathBuf::from("/tmp/copilot"), PathBuf::from("/tmp"));
+
+        assert!(app.sessions.is_empty());
+        assert!(app.flat_list.is_empty());
+        assert_eq!(app.selected_session, None);
+        assert!(!app.is_loading_sessions());
+    }
+
+    #[test]
+    fn reload_starts_background_session_load() {
+        let mut app = App::new(PathBuf::from("/tmp/copilot"), PathBuf::from("/tmp"));
+
+        app.reload();
+
+        assert!(app.is_loading_sessions());
+    }
+
+    #[test]
+    fn poll_session_loads_replaces_sessions() {
+        let mut app = App::new(PathBuf::from("/tmp/copilot"), PathBuf::from("/tmp"));
+        app.sessions_loading = true;
+        app.session_load_sender
+            .send((
+                app.session_load_generation,
+                vec![session("local", SessionSource::Local)],
+            ))
+            .unwrap();
+
+        app.poll_session_loads();
+
+        assert!(!app.is_loading_sessions());
+        assert_eq!(app.sessions.len(), 1);
+        assert_eq!(app.selected_session, Some(0));
+    }
+
     #[test]
     fn moving_cursor_to_remote_task_does_not_load_log() {
         let mut app = app_with_sessions(vec![

src/main.rs

@@ -36,6 +36,7 @@ fn main() -> Result<()> {
     let backend = CrosstermBackend::new(io::stdout());
     let mut terminal = Terminal::new(backend).context("Failed to create terminal")?;
     terminal.clear()?;
+    app.reload();
 
     let result = run_event_loop(&mut terminal, &mut app);
 
@@ -70,6 +71,7 @@ where
     let mut last_status_poll = Instant::now();
 
     loop {
+        app.poll_session_loads();
         app.poll_remote_log_loads();
         resize_embedded_terminal(app, terminal.size()?);
         terminal.draw(|f| ui::draw(f, app))?;

src/ui.rs

@@ -119,8 +119,13 @@ fn draw_sessions_panel(f: &mut Frame, app: &mut App, area: Rect) {
         Style::default().fg(MUTED_COLOR)
     };
 
+    let title = if app.is_loading_sessions() {
+        " Sessions (loading…) "
+    } else {
+        " Sessions "
+    };
     let block = Block::default()
-        .title(" Sessions ")
+        .title(title)
         .title_style(
             Style::default()
                 .fg(ACCENT_COLOR)
@@ -135,18 +140,22 @@ fn draw_sessions_panel(f: &mut Frame, app: &mut App, area: Rect) {
     let list_area = inner;
 
     if app.flat_list.is_empty() {
-        let title = if app.sessions.is_empty() {
+        let title = if app.is_loading_sessions() {
+            "Loading Copilot sessions…"
+        } else if app.sessions.is_empty() {
             "No Copilot sessions found."
         } else {
             "No sessions match the active filters."
         };
+        let description = if app.is_loading_sessions() {
+            "Reading local sessions and Remote agent tasks."
+        } else {
+            "No sessions match the current filters."
+        };
         let msg = Paragraph::new(Text::from(vec![
             Line::from(Span::styled(title, Style::default().fg(MUTED_COLOR))),
             Line::from(Span::raw("")),
-            Line::from(Span::styled(
-                "No sessions match the current filters.",
-                Style::default().fg(MUTED_COLOR),
-            )),
+            Line::from(Span::styled(description, Style::default().fg(MUTED_COLOR))),
         ]))
         .style(Style::default().bg(SURFACE_COLOR))
         .alignment(Alignment::Center);
@@ -416,16 +425,21 @@ fn draw_detail_panel(f: &mut Frame, app: &mut App, area: Rect) {
             .border_style(border_style);
         let inner = block.inner(area);
         f.render_widget(block, area);
-        let msg = Paragraph::new(Text::from(vec![
-            Line::from(Span::styled(
+        let (title, description) = if app.is_loading_sessions() {
+            (
+                "Loading session details…",
+                "Sessions will appear here as soon as they are ready.",
+            )
+        } else {
+            (
                 "Select a session with j/k + Enter",
-                Style::default().fg(MUTED_COLOR),
-            )),
-            Line::from(Span::raw("")),
-            Line::from(Span::styled(
                 "Press [o] to open a live terminal session",
-                Style::default().fg(MUTED_COLOR),
-            )),
+            )
+        };
+        let msg = Paragraph::new(Text::from(vec![
+            Line::from(Span::styled(title, Style::default().fg(MUTED_COLOR))),
+            Line::from(Span::raw("")),
+            Line::from(Span::styled(description, Style::default().fg(MUTED_COLOR))),
         ]))
         .style(Style::default().bg(SURFACE_COLOR))
         .alignment(Alignment::Center);
@@ -1061,11 +1075,16 @@ fn draw_footer(f: &mut Frame, app: &App, area: Rect) {
 }
 
 fn footer_text(app: &App) -> String {
-    footer_shortcuts(app)
+    let shortcuts = footer_shortcuts(app)
         .into_iter()
         .map(|(action, key)| format!("{action}: {key}"))
         .collect::<Vec<_>>()
-        .join("  ")
+        .join("  ");
+    if app.is_loading_sessions() {
+        format!("Loading sessions…  {shortcuts}")
+    } else {
+        shortcuts
+    }
 }
 
 fn footer_shortcuts(app: &App) -> Vec<(&'static str, &'static str)> {