feat: Enhance session resume/fork logic and improve conversation history display during session startup.

vinhnx · vinhnx · commit 661ca205c083 · 2025-12-26T00:31:35.000+07:00
diff --git a/.vtcode/tool-policy.json b/.vtcode/tool-policy.json
@@ -15,8 +15,6 @@
     "grep_file",
     "list_files",
     "list_pty_sessions",
-    "mcp::fetch::fetch",
-    "mcp::time::convert_time",
     "mcp::time::get_current_time",
     "read_file",
     "read_pty_session",
@@ -56,10 +54,10 @@
     "skill": "prompt",
     "code_intelligence": "prompt",
     "agent_info": "prompt",
-    "mcp_get_current_time": "prompt",
-    "mcp_time_get_current_time": "prompt",
     "mcp_fetch": "prompt",
     "mcp_fetch_fetch": "prompt",
+    "mcp_get_current_time": "prompt",
+    "mcp_time_get_current_time": "prompt",
     "mcp_convert_time": "prompt",
     "mcp_time_convert_time": "prompt"
   },
diff --git a/src/agent/runloop/unified/diagnostics.rs b/src/agent/runloop/unified/diagnostics.rs
@@ -126,10 +126,11 @@ pub(crate) async fn run_doctor_diagnostics(
             renderer,
             "  HITL Enabled",
             Ok((if cfg.security.human_in_the_loop {
-                    "Yes"
-                } else {
-                    "No"
-                }).to_string()),
+                "Yes"
+            } else {
+                "No"
+            })
+            .to_string()),
         )?;
 
         // Tool default policy
diff --git a/src/agent/runloop/unified/turn/session_loop.rs b/src/agent/runloop/unified/turn/session_loop.rs
@@ -94,7 +94,10 @@ pub(crate) async fn run_single_agent_loop_unified(
     let mut resume_state = resume;
 
     loop {
-        let resume_ref = resume_state.as_ref();
+        // Take the pending resume request (if any) for this session iteration.
+        // New resume requests issued mid-session will populate `resume_state` again.
+        let resume_request = resume_state.take();
+        let resume_ref = resume_request.as_ref();
 
         let session_trigger = if resume_ref.is_some() {
             SessionStartTrigger::Resume
@@ -228,14 +231,18 @@ pub(crate) async fn run_single_agent_loop_unified(
 
         transcript::clear();
 
-        if let Some(session) = resume_state.as_ref() {
+        if let Some(session) = resume_ref {
             let ended_local = session
                 .snapshot
                 .ended_at
                 .with_timezone(&Local)
                 .format("%Y-%m-%d %H:%M");
 
-            let action = if session.is_fork { "Forking" } else { "Resuming" };
+            let action = if session.is_fork {
+                "Forking"
+            } else {
+                "Resuming"
+            };
 
             renderer.line(
                 MessageStyle::Info,
@@ -253,45 +260,56 @@ pub(crate) async fn run_single_agent_loop_unified(
             )?;
 
             if session.is_fork {
-                renderer.line(
-                    MessageStyle::Info,
-                    "Starting independent forked session",
-                )?;
+                renderer.line(MessageStyle::Info, "Starting independent forked session")?;
             }
 
-            // Display full conversation history
+            // Display full conversation history with proper TUI styles (no truncation)
             if !session.history.is_empty() {
-                renderer.line_if_not_empty(MessageStyle::Output)?;
                 renderer.line(MessageStyle::Info, "Conversation history:")?;
 
                 for (idx, msg) in session.history.iter().enumerate() {
-                    let role_label = match msg.role {
-                        uni::MessageRole::User => "You",
-                        uni::MessageRole::Assistant => "Assistant",
-                        _ => "System",
+                    let (style, role_label) = match msg.role {
+                        uni::MessageRole::User => (MessageStyle::User, "You"),
+                        uni::MessageRole::Assistant => (MessageStyle::Response, "Assistant"),
+                        uni::MessageRole::Tool => (MessageStyle::ToolOutput, "Tool"),
+                        uni::MessageRole::System => (MessageStyle::Info, "System"),
                     };
 
-                    let content_preview = match &msg.content {
+                    let tool_suffix = msg
+                        .tool_call_id
+                        .as_ref()
+                        .map(|id| format!(" [tool_call_id: {}]", id))
+                        .unwrap_or_default();
+
+                    // For user messages, skip the numbered header to avoid clutter.
+                    if msg.role != uni::MessageRole::User {
+                        renderer.line(
+                            style,
+                            &format!("  [{}] {}{}:", idx + 1, role_label, tool_suffix),
+                        )?;
+                    }
+
+                    match &msg.content {
                         uni::MessageContent::Text(text) => {
-                            if text.len() > 200 {
-                                format!("{}...", &text[..200])
-                            } else {
-                                text.clone()
+                            for line in text.lines() {
+                                // Indent user text as well for alignment
+                                renderer.line(style, &format!("    {}", line))?;
                             }
                         }
                         uni::MessageContent::Parts(parts) => {
-                            format!("[{} content parts]", parts.len())
+                            renderer.line(
+                                style,
+                                &format!("    [content parts: {}]", parts.len()),
+                            )?;
                         }
-                    };
+                    }
 
-                    renderer.line(
-                        MessageStyle::Info,
-                        &format!("  [{}] {}: {}", idx + 1, role_label, content_preview),
-                    )?;
+                    // Compact spacing between messages
+                    if idx + 1 < session.history.len() {
+                        renderer.line(style, "")?;
+                    }
                 }
             }
-
-            renderer.line_if_not_empty(MessageStyle::Output)?;
         }
 
         let workspace_label = config
@@ -308,10 +326,13 @@ pub(crate) async fn run_single_agent_loop_unified(
         };
         let header_provider_label = provider_label.clone();
         let mut session_archive_error: Option<String> = None;
-        let mut session_archive = if let Some(resume) = resume_state.as_ref() {
+        let mut session_archive = if let Some(resume) = resume_ref {
             if resume.is_fork {
                 // Fork: create new archive from source snapshot with custom ID
-                let custom_id = resume.identifier.strip_prefix("forked-").map(|s| s.to_string());
+                let custom_id = resume
+                    .identifier
+                    .strip_prefix("forked-")
+                    .map(|s| s.to_string());
                 match SessionArchive::fork(&resume.snapshot, custom_id).await {
                     Ok(archive) => Some(archive),
                     Err(err) => {
@@ -743,8 +764,8 @@ pub(crate) async fn run_single_agent_loop_unified(
                     }
                     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;
+                        use vtcode_core::utils::session_archive::find_session_by_identifier;
 
                         renderer.line(
                             MessageStyle::Info,
@@ -753,11 +774,15 @@ pub(crate) async fn run_single_agent_loop_unified(
 
                         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()
+                                // Prefer full archived messages; fall back to progress snapshot.
+                                let history_iter = if !listing.snapshot.messages.is_empty() {
+                                    listing.snapshot.messages.iter()
+                                } else if let Some(progress) = &listing.snapshot.progress {
+                                    progress.recent_messages.iter()
                                 } else {
-                                    listing.snapshot.messages.iter().map(Message::from).collect()
+                                    [].iter()
                                 };
+                                let history = history_iter.map(Message::from).collect();
 
                                 #[allow(unused_assignments)]
                                 {
@@ -1257,6 +1282,11 @@ pub(crate) async fn run_single_agent_loop_unified(
         }
 
         // If the session ended with NewSession, restart the loop with fresh config
+        // If a new resume request was queued (e.g., via /sessions), start it now.
+        if resume_state.is_some() {
+            continue;
+        }
+
         if matches!(session_end_reason, SessionEndReason::NewSession) {
             // Reload config to pick up any changes
             vt_cfg =
diff --git a/src/agent/runloop/unified/turn/turn_loop.rs b/src/agent/runloop/unified/turn/turn_loop.rs
@@ -287,10 +287,8 @@ pub async fn run_turn_loop(
                     if let Some(reasoning_text) = reasoning.as_ref()
                         && !reasoning_text.trim().is_empty()
                     {
-                        ctx.renderer.line(
-                            MessageStyle::Info,
-                            &format!(" {}", reasoning_text),
-                        )?;
+                        ctx.renderer
+                            .line(MessageStyle::Info, &format!(" {}", reasoning_text))?;
                     }
                 }
                 // Note: reasoning already rendered during streaming; don't fabricate announcements
@@ -439,10 +437,8 @@ pub async fn run_turn_loop(
                     if let Some(reasoning_text) = reasoning.as_ref()
                         && !reasoning_text.trim().is_empty()
                     {
-                        ctx.renderer.line(
-                            MessageStyle::Info,
-                            &format!(" {}", reasoning_text),
-                        )?;
+                        ctx.renderer
+                            .line(MessageStyle::Info, &format!(" {}", reasoning_text))?;
                     }
                 }
                 // Note: reasoning already rendered during streaming; don't fabricate announcements
diff --git a/src/cli/sessions.rs b/src/cli/sessions.rs
@@ -22,7 +22,9 @@ pub async fn handle_resume_session_command(
 ) -> Result<()> {
     let resume = match mode {
         SessionResumeMode::Latest => select_latest_session(false).await?,
-        SessionResumeMode::Specific(identifier) => Some(load_specific_session(&identifier, false).await?),
+        SessionResumeMode::Specific(identifier) => {
+            Some(load_specific_session(&identifier, false).await?)
+        }
         SessionResumeMode::Interactive => select_session_interactively(false).await?,
         SessionResumeMode::Fork(identifier) => {
             if identifier == "__latest__" {
@@ -103,17 +105,17 @@ async fn select_session_interactively(is_fork: bool) -> Result<Option<ResumeSess
 }
 
 fn convert_listing(listing: &SessionListing, is_fork: bool) -> ResumeSession {
-    let history = if let Some(progress) = &listing.snapshot.progress {
-        progress.recent_messages.iter().map(Message::from).collect()
+    // Prefer full archived messages; fall back to recent progress if the full log is absent.
+    let history_source = if !listing.snapshot.messages.is_empty() {
+        listing.snapshot.messages.iter()
+    } else if let Some(progress) = &listing.snapshot.progress {
+        progress.recent_messages.iter()
     } else {
-        listing
-            .snapshot
-            .messages
-            .iter()
-            .map(Message::from)
-            .collect()
+        [].iter()
     };
 
+    let history = history_source.map(Message::from).collect();
+
     ResumeSession {
         identifier: listing.identifier(),
         snapshot: listing.snapshot.clone(),
@@ -190,10 +192,7 @@ fn print_fork_summary(resume: &ResumeSession) {
         "{}",
         style(format!("Original archive: {}", resume.path.display())).green()
     );
-    println!(
-        "{}",
-        style("Starting independent forked session").green()
-    );
+    println!("{}", style("Starting independent forked session").green());
 }
 
 async fn run_single_agent_loop(
diff --git a/src/main.rs b/src/main.rs
@@ -58,9 +58,10 @@ async fn run() -> Result<()> {
 
     // Load .env (non-fatal if missing)
     if let Err(err) = load_dotenv()
-        && !args.quiet {
-            eprintln!("vtcode: warning: failed to load .env: {err}");
-        }
+        && !args.quiet
+    {
+        eprintln!("vtcode: warning: failed to load .env: {err}");
+    }
 
     process_hardening::apply_process_hardening()
         .context("failed to apply process hardening safeguards")?;
diff --git a/src/startup/mod.rs b/src/startup/mod.rs
@@ -25,8 +25,13 @@ fn validate_session_id_suffix(suffix: &str) -> Result<()> {
     if suffix.len() > 64 {
         bail!("Custom session ID suffix too long (maximum 64 characters)");
     }
-    if !suffix.chars().all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_') {
-        bail!("Custom session ID suffix must contain only alphanumeric characters, dashes, or underscores");
+    if !suffix
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
+    {
+        bail!(
+            "Custom session ID suffix must contain only alphanumeric characters, dashes, or underscores"
+        );
     }
     Ok(())
 }
@@ -61,7 +66,7 @@ pub enum SessionResumeMode {
     Interactive,
     Latest,
     Specific(String),
-    Fork(String),  // Fork from specific session ID
+    Fork(String), // Fork from specific session ID
 }
 
 impl StartupContext {
@@ -154,7 +159,7 @@ impl StartupContext {
             if value == "__interactive__" {
                 // --resume with interactive mode
                 if custom_session_id.is_some() {
-                    Some(SessionResumeMode::Interactive)  // Will fork after selection
+                    Some(SessionResumeMode::Interactive) // Will fork after selection
                 } else {
                     Some(SessionResumeMode::Interactive)
                 }
diff --git a/vtcode-core/src/cli/args.rs b/vtcode-core/src/cli/args.rs
@@ -351,11 +351,7 @@ pub struct Cli {
     ///   vtcode --continue --session-id suffix             (fork from latest)
     ///
     /// Validation: Alphanumeric characters, dash, and underscore only (max 64 chars).
-    #[arg(
-        long = "session-id",
-        global = true,
-        value_name = "CUSTOM_SUFFIX"
-    )]
+    #[arg(long = "session-id", global = true, value_name = "CUSTOM_SUFFIX")]
     pub session_id: Option<String>,
 
     /// **Enable skills system**
diff --git a/vtcode-core/src/tools/registry/executors.rs b/vtcode-core/src/tools/registry/executors.rs
@@ -552,10 +552,7 @@ impl ToolRegistry {
     /// Merged agent diagnostics tool (replaces debug_agent + analyze_agent)
     pub(super) fn agent_info_executor(&mut self, args: Value) -> BoxFuture<'_, Result<Value>> {
         Box::pin(async move {
-            let mode = args
-                .get("mode")
-                .and_then(|v| v.as_str())
-                .unwrap_or("full");
+            let mode = args.get("mode").and_then(|v| v.as_str()).unwrap_or("full");
 
             let available_tools = self.available_tools().await;
             let workspace_root = self.workspace_root_str();
diff --git a/vtcode-core/src/utils/session_archive.rs b/vtcode-core/src/utils/session_archive.rs
@@ -276,7 +276,10 @@ pub struct SessionArchive {
 }
 
 impl SessionArchive {
-    pub async fn new(metadata: SessionArchiveMetadata, custom_suffix: Option<String>) -> Result<Self> {
+    pub async fn new(
+        metadata: SessionArchiveMetadata,
+        custom_suffix: Option<String>,
+    ) -> Result<Self> {
         let sessions_dir = resolve_sessions_dir().await?;
         let started_at = Utc::now();
         let path = generate_unique_archive_path(

Original file line number	Diff line number	Diff line change
`@@ -287,10 +287,8 @@ pub async fn run_turn_loop(`
`287`	`287`	`if let Some(reasoning_text) = reasoning.as_ref()`
`288`	`288`	`&& !reasoning_text.trim().is_empty()`
`289`	`289`	`{`
`290`		`- ctx.renderer.line(`
`291`		`- MessageStyle::Info,`
`292`		`- &format!(" {}", reasoning_text),`
`293`		`- )?;`
	`290`	`+ ctx.renderer`
	`291`	`+ .line(MessageStyle::Info, &format!(" {}", reasoning_text))?;`
`294`	`292`	`}`
`295`	`293`	`}`
`296`	`294`	`// Note: reasoning already rendered during streaming; don't fabricate announcements`
`@@ -439,10 +437,8 @@ pub async fn run_turn_loop(`
`439`	`437`	`if let Some(reasoning_text) = reasoning.as_ref()`
`440`	`438`	`&& !reasoning_text.trim().is_empty()`
`441`	`439`	`{`
`442`		`- ctx.renderer.line(`
`443`		`- MessageStyle::Info,`
`444`		`- &format!(" {}", reasoning_text),`
`445`		`- )?;`
	`440`	`+ ctx.renderer`
	`441`	`+ .line(MessageStyle::Info, &format!(" {}", reasoning_text))?;`
`446`	`442`	`}`
`447`	`443`	`}`
`448`	`444`	`// Note: reasoning already rendered during streaming; don't fabricate announcements`