feat: add session resumption functionality and update related actions

vinhnx · vinhnx · commit 00b43e1132fb · 2025-12-26T00:07:53.000+07:00
diff --git a/.vtcode/tool-policy.json b/.vtcode/tool-policy.json
@@ -15,6 +15,8 @@
     "grep_file",
     "list_files",
     "list_pty_sessions",
+    "mcp::fetch::fetch",
+    "mcp::time::convert_time",
     "mcp::time::get_current_time",
     "read_file",
     "read_pty_session",
@@ -54,12 +56,12 @@
     "skill": "prompt",
     "code_intelligence": "prompt",
     "agent_info": "prompt",
-    "mcp_convert_time": "prompt",
-    "mcp_time_convert_time": "prompt",
     "mcp_get_current_time": "prompt",
     "mcp_time_get_current_time": "prompt",
     "mcp_fetch": "prompt",
-    "mcp_fetch_fetch": "prompt"
+    "mcp_fetch_fetch": "prompt",
+    "mcp_convert_time": "prompt",
+    "mcp_time_convert_time": "prompt"
   },
   "constraints": {},
   "mcp": {
diff --git a/src/agent/runloop/unified/inline_events/action.rs b/src/agent/runloop/unified/inline_events/action.rs
@@ -4,4 +4,5 @@ pub(crate) enum InlineLoopAction {
     Continue,
     Submit(String),
     Exit(SessionEndReason),
+    ResumeSession(String), // Session identifier to resume
 }
diff --git a/src/agent/runloop/unified/inline_events/driver.rs b/src/agent/runloop/unified/inline_events/driver.rs
@@ -157,6 +157,7 @@ impl<'a> InlineEventLoop<'a> {
             InlineLoopAction::Exit(reason) => Some(InlineLoopAction::Exit(reason)),
             InlineLoopAction::Continue => None,
             InlineLoopAction::Submit(_) => None,
+            InlineLoopAction::ResumeSession(_) => None,
         }
     }
 }
diff --git a/src/agent/runloop/unified/inline_events/modal.rs b/src/agent/runloop/unified/inline_events/modal.rs
@@ -62,8 +62,7 @@ impl<'a> InlineModalProcessor<'a> {
         match self.model_picker.handle_submit(renderer, selection).await? {
             ModelPickerOutcome::SkipPalette => Ok(InlineLoopAction::Continue),
             ModelPickerOutcome::ForwardToPalette(selection) => {
-                self.palette.handle_submit(renderer, selection).await?;
-                Ok(InlineLoopAction::Continue)
+                self.palette.handle_submit(renderer, selection).await
             }
             ModelPickerOutcome::Continue => Ok(InlineLoopAction::Continue),
         }
@@ -92,14 +91,23 @@ impl<'a> PaletteCoordinator<'a> {
         &mut self,
         renderer: &mut AnsiRenderer,
         selection: InlineListSelection,
-    ) -> Result<()> {
+    ) -> Result<InlineLoopAction> {
         if let Some(active) = self.state.take() {
+            // Check if this is a session selection - if so, return the ResumeSession action
+            if let InlineListSelection::Session(session_id) = &selection {
+                renderer.line(
+                    MessageStyle::Info,
+                    &format!("Resuming session: {}", session_id),
+                )?;
+                return Ok(InlineLoopAction::ResumeSession(session_id.clone()));
+            }
+
             let restore =
                 handle_palette_selection(active, selection, renderer, self.handle).await?;
             if let Some(state) = restore {
                 *self.state = Some(state);
             }
-            return Ok(());
+            return Ok(InlineLoopAction::Continue);
         }
 
         // Safety net: If palette state is missing, log and inform the user
@@ -112,7 +120,7 @@ impl<'a> PaletteCoordinator<'a> {
             "Selection dismissed because the palette is no longer active. Please try again.",
         )?;
 
-        Ok(())
+        Ok(InlineLoopAction::Continue)
     }
 
     fn handle_cancel(&mut self, renderer: &mut AnsiRenderer) -> Result<()> {
diff --git a/src/agent/runloop/unified/palettes.rs b/src/agent/runloop/unified/palettes.rs
@@ -19,7 +19,7 @@ const THEME_ACTIVE_BADGE: &str = "Active";
 const THEME_SELECT_HINT: &str = "Use ↑/↓ to choose a theme, Enter to apply, Esc to cancel.";
 const SESSIONS_PALETTE_TITLE: &str = "Archived sessions";
 const SESSIONS_HINT_PRIMARY: &str = "Use ↑/↓ to browse sessions.";
-const SESSIONS_HINT_SECONDARY: &str = "Enter to print details • Esc to close.";
+const SESSIONS_HINT_SECONDARY: &str = "Enter to resume session • Esc to close.";
 const SESSIONS_LATEST_BADGE: &str = "Latest";
 
 #[derive(Clone)]
@@ -137,56 +137,6 @@ pub(crate) fn show_sessions_palette(
     Ok(true)
 }
 
-pub(crate) fn render_session_details(
-    renderer: &mut AnsiRenderer,
-    listing: &SessionListing,
-) -> Result<()> {
-    let ended_local = listing
-        .snapshot
-        .ended_at
-        .with_timezone(&Local)
-        .format("%Y-%m-%d %H:%M");
-    let duration = listing
-        .snapshot
-        .ended_at
-        .signed_duration_since(listing.snapshot.started_at);
-    let duration_std = duration.to_std().unwrap_or_else(|_| Duration::from_secs(0));
-    let duration_label = format_duration_label(duration_std);
-    let tool_count = listing.snapshot.distinct_tools.len();
-
-    renderer.line(
-        MessageStyle::Info,
-        &format!(
-            "- (ID: {}) {} · Model: {} · Workspace: {}",
-            listing.identifier(),
-            ended_local,
-            listing.snapshot.metadata.model,
-            listing.snapshot.metadata.workspace_label,
-        ),
-    )?;
-    renderer.line(
-        MessageStyle::Info,
-        &format!(
-            "    Duration: {} · {} msgs · {} tools",
-            duration_label, listing.snapshot.total_messages, tool_count,
-        ),
-    )?;
-
-    if let Some(prompt) = listing.first_prompt_preview() {
-        renderer.line(MessageStyle::Info, &format!("    Prompt: {prompt}"))?;
-    }
-
-    if let Some(reply) = listing.first_reply_preview() {
-        renderer.line(MessageStyle::Info, &format!("    Reply: {reply}"))?;
-    }
-
-    renderer.line(
-        MessageStyle::Info,
-        &format!("    File: {}", listing.path.display()),
-    )?;
-    Ok(())
-}
-
 pub(crate) async fn handle_palette_selection(
     palette: ActivePalette,
     selection: InlineListSelection,
@@ -222,14 +172,8 @@ pub(crate) async fn handle_palette_selection(
             _ => Ok(Some(ActivePalette::Theme { mode })),
         },
         ActivePalette::Sessions { listings, limit } => {
-            if let InlineListSelection::Session(selected_id) = &selection
-                && let Some(listing) = listings
-                    .iter()
-                    .find(|entry| entry.identifier() == *selected_id)
-                    .cloned()
-            {
-                render_session_details(renderer, &listing)?;
-            }
+            // Session selection is handled earlier in the modal handler
+            // This path is for refreshing the palette display
             if show_sessions_palette(renderer, &listings, limit)? {
                 Ok(Some(ActivePalette::Sessions { listings, limit }))
             } else {
diff --git a/src/agent/runloop/unified/turn/run_loop.rs b/src/agent/runloop/unified/turn/run_loop.rs
@@ -1423,6 +1423,16 @@ pub(crate) async fn run_single_agent_loop_unified(
                         session_end_reason = reason;
                         break;
                     }
+                    InlineLoopAction::ResumeSession(_session_id) => {
+                        // Session resumption is handled in the outer loop (session_loop.rs)
+                        // This code path (run_loop.rs) is not designed for mid-session resumption
+                        // Log and continue
+                        renderer.line(
+                            MessageStyle::Info,
+                            "Session resumption requested but not available in this context.",
+                        )?;
+                        continue;
+                    }
                 };
 
             if input_owned.is_empty() {
diff --git a/src/agent/runloop/unified/turn/session_loop.rs b/src/agent/runloop/unified/turn/session_loop.rs
@@ -741,6 +741,58 @@ pub(crate) async fn run_single_agent_loop_unified(
                         session_end_reason = reason;
                         break;
                     }
+                    InlineLoopAction::ResumeSession(session_id) => {
+                        // Load and resume the selected session
+                        use vtcode_core::utils::session_archive::find_session_by_identifier;
+                        use vtcode_core::llm::provider::Message;
+
+                        renderer.line(
+                            MessageStyle::Info,
+                            &format!("Loading session: {}", session_id),
+                        )?;
+
+                        match find_session_by_identifier(&session_id).await {
+                            Ok(Some(listing)) => {
+                                let history = if let Some(progress) = &listing.snapshot.progress {
+                                    progress.recent_messages.iter().map(Message::from).collect()
+                                } else {
+                                    listing.snapshot.messages.iter().map(Message::from).collect()
+                                };
+
+                                #[allow(unused_assignments)]
+                                {
+                                    resume_state = Some(ResumeSession {
+                                        identifier: listing.identifier(),
+                                        snapshot: listing.snapshot.clone(),
+                                        history,
+                                        path: listing.path.clone(),
+                                        is_fork: false,
+                                    });
+                                }
+
+                                renderer.line(
+                                    MessageStyle::Info,
+                                    &format!("Restarting with session: {}", session_id),
+                                )?;
+                                session_end_reason = SessionEndReason::Completed;
+                                break; // Exit current loop to restart with resumed session
+                            }
+                            Ok(None) => {
+                                renderer.line(
+                                    MessageStyle::Error,
+                                    &format!("Session not found: {}", session_id),
+                                )?;
+                                continue;
+                            }
+                            Err(err) => {
+                                renderer.line(
+                                    MessageStyle::Error,
+                                    &format!("Failed to load session: {}", err),
+                                )?;
+                                continue;
+                            }
+                        }
+                    }
                 };
 
             if input_owned.is_empty() {
diff --git a/vtcode-core/src/ui/tui/event_router.rs b/vtcode-core/src/ui/tui/event_router.rs
@@ -6,6 +6,7 @@
 use super::modern_tui::Event;
 use super::session::Session;
 use ratatui::crossterm::event::{KeyCode, KeyEvent};
+use crate::ui::tui::session::slash;
 
 /// Determines which component should handle an event
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -122,8 +123,7 @@ impl Session {
     }
 
     pub(crate) fn is_slash_palette_active(&self) -> bool {
-        // Check if slash palette has suggestions
-        false // Placeholder - implement based on SlashPalette API
+        slash::slash_navigation_available(self)
     }
 }
 
diff --git a/vtcode-core/src/ui/tui/runner.rs b/vtcode-core/src/ui/tui/runner.rs
@@ -89,6 +89,7 @@ fn has_active_navigation_ui(session: &Session) -> bool {
         || session.file_palette_active
         || session.prompt_palette_active
         || session.config_palette_active
+        || crate::ui::tui::session::slash::slash_navigation_available(session)
 }
 
 const INLINE_FALLBACK_ROWS: u16 = ui::DEFAULT_INLINE_VIEWPORT_ROWS;
diff --git a/vtcode-core/src/ui/tui/session/slash.rs b/vtcode-core/src/ui/tui/session/slash.rs
@@ -165,7 +165,7 @@ pub(super) fn update_slash_suggestions(session: &mut Session) {
     }
 }
 
-pub(super) fn slash_navigation_available(session: &Session) -> bool {
+pub(crate) fn slash_navigation_available(session: &Session) -> bool {
     session.input_enabled
         && !session.slash_palette.is_empty()
         && session.modal.is_none()
@@ -439,19 +439,35 @@ pub(super) fn try_handle_slash_navigation(
     has_alt: bool,
     has_command: bool,
 ) -> bool {
-    if !slash_navigation_available(session) || has_control || has_alt {
+    if !slash_navigation_available(session) {
+        return false;
+    }
+
+    // Block Control modifier
+    if has_control {
+        return false;
+    }
+
+    // Block Alt unless combined with Command for Up/Down navigation
+    if has_alt && !matches!(key.code, KeyCode::Up | KeyCode::Down) {
         return false;
     }
 
     let handled = match key.code {
         KeyCode::Up => {
+            if has_alt && !has_command {
+                return false;
+            }
             if has_command {
                 select_first_slash_suggestion(session)
             } else {
                 move_slash_selection_up(session)
             }
         }
         KeyCode::Down => {
+            if has_alt && !has_command {
+                return false;
+            }
             if has_command {
                 select_last_slash_suggestion(session)
             } else {

Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,5 @@ pub(crate) enum InlineLoopAction {`
`4`	`4`	`Continue,`
`5`	`5`	`Submit(String),`
`6`	`6`	`Exit(SessionEndReason),`
	`7`	`+ ResumeSession(String), // Session identifier to resume`
`7`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -157,6 +157,7 @@ impl<'a> InlineEventLoop<'a> {`
`157`	`157`	`InlineLoopAction::Exit(reason) => Some(InlineLoopAction::Exit(reason)),`
`158`	`158`	`InlineLoopAction::Continue => None,`
`159`	`159`	`InlineLoopAction::Submit(_) => None,`
	`160`	`+ InlineLoopAction::ResumeSession(_) => None,`
`160`	`161`	`}`
`161`	`162`	`}`
`162`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`use super::modern_tui::Event;`
`7`	`7`	`use super::session::Session;`
`8`	`8`	`use ratatui::crossterm::event::{KeyCode, KeyEvent};`
	`9`	`+use crate::ui::tui::session::slash;`
`9`	`10`
`10`	`11`	`/// Determines which component should handle an event`
`11`	`12`	`#[derive(Debug, Clone, Copy, PartialEq, Eq)]`
`@@ -122,8 +123,7 @@ impl Session {`
`122`	`123`	`}`
`123`	`124`
`124`	`125`	`pub(crate) fn is_slash_palette_active(&self) -> bool {`
`125`		`- // Check if slash palette has suggestions`
`126`		`- false // Placeholder - implement based on SlashPalette API`
	`126`	`+ slash::slash_navigation_available(self)`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ fn has_active_navigation_ui(session: &Session) -> bool {`
`89`	`89`	`\|\| session.file_palette_active`
`90`	`90`	`\|\| session.prompt_palette_active`
`91`	`91`	`\|\| session.config_palette_active`
	`92`	`+ \|\| crate::ui::tui::session::slash::slash_navigation_available(session)`
`92`	`93`	`}`
`93`	`94`
`94`	`95`	`const INLINE_FALLBACK_ROWS: u16 = ui::DEFAULT_INLINE_VIEWPORT_ROWS;`