feat: implement session forking with custom session ID support

vinhnx · vinhnx · commit ca3b4824fd11 · 2025-12-25T23:27:01.000+07:00
diff --git a/docs/project/TODO.md b/docs/project/TODO.md
@@ -2,43 +2,9 @@ Add LSP (Language Server Protocol) tool for code intelligence features like go-t
 
 --
 
-enhance /sessions command to
-add support for custom session IDs when forking sessions with --session-id combined with --resume or --continue and --fork-session
+review and fix agent harness run, especially tool execution and output handling. sometime the agent stop in the middle of execution without completing the task
 
---
-
-improve sessions resume to clear current session and open in full tui mode with transcription view when resuming from a previous session that was in full tui mode
-
-eg: current it just open the summarization in stead.Owner
-
-Full TUI sessions restore
-
-Currently when using /sessions command, the program only return one summary final message. Try to find a way to fully render all message in transcript log as TUI messages.
-
--   (ID: session-vtcode-20251225T103836Z_356523-71490) 2025-12-25
-    17:38 · Model: zai-org/GLM-4.7:novita · Workspace: vtcode
-
-Duration: 16s · 1 msgs · 0 tools
-
-Prompt: 1
-
-File: /Users/vinhnguyenxuan/.vtcode/sessions/session-vtcode
--20251225T103836Z_356523-71490.json
-
--   (ID: session-vtcode-20251225T103107Z_704712-65298) 2025-12-25
-    17:34 · Model: zai-org/GLM-4.7:novita · Workspace: vtcode
-
-Duration: 3m 44s · 4 msgs · 0 tools
-
-Prompt: hello
-
-Reply: Hello! I'm VT Code, your Rust-based terminal coding
-agent. I'm here to help you…
-
-File: /Users/vinhnguyenxuan/.vtcode/sessions/session-vtcode
--20251225T103107Z_704712-65298.json
-
-Closed session browser.
+eg: /Users/vinhnguyenxuan/.vtcode/sessions/session-vtcode-20251225T155341Z_067404-41496.json
 
 --
 
diff --git a/src/agent/agents.rs b/src/agent/agents.rs
@@ -12,6 +12,7 @@ pub struct ResumeSession {
     pub snapshot: SessionSnapshot,
     pub history: Vec<ProviderMessage>,
     pub path: PathBuf,
+    pub is_fork: bool,
 }
 
 impl ResumeSession {
diff --git a/src/agent/runloop/unified/session_setup.rs b/src/agent/runloop/unified/session_setup.rs
@@ -574,7 +574,7 @@ pub(crate) async fn initialize_session_ui(
         config.reasoning_effort.as_str().to_string(),
     );
     let mut session_archive_error: Option<String> = None;
-    let session_archive = match SessionArchive::new(archive_metadata).await {
+    let session_archive = match SessionArchive::new(archive_metadata, None).await {
         Ok(archive) => Some(archive),
         Err(err) => {
             session_archive_error = Some(err.to_string());
diff --git a/src/agent/runloop/unified/turn/run_loop.rs b/src/agent/runloop/unified/turn/run_loop.rs
@@ -1026,7 +1026,7 @@ pub(crate) async fn run_single_agent_loop_unified(
             config.reasoning_effort.as_str().to_string(),
         );
         let mut session_archive_error: Option<String> = None;
-        let mut session_archive = match SessionArchive::new(archive_metadata).await {
+        let mut session_archive = match SessionArchive::new(archive_metadata, None).await {
             Ok(archive) => Some(archive),
             Err(err) => {
                 session_archive_error = Some(err.to_string());
diff --git a/src/agent/runloop/unified/turn/session_loop.rs b/src/agent/runloop/unified/turn/session_loop.rs
@@ -234,10 +234,14 @@ pub(crate) async fn run_single_agent_loop_unified(
                 .ended_at
                 .with_timezone(&Local)
                 .format("%Y-%m-%d %H:%M");
+
+            let action = if session.is_fork { "Forking" } else { "Resuming" };
+
             renderer.line(
                 MessageStyle::Info,
                 &format!(
-                    "Resuming session {} · ended {} · {} messages",
+                    "{} session {} · ended {} · {} messages",
+                    action,
                     session.identifier,
                     ended_local,
                     session.message_count()
@@ -247,6 +251,46 @@ pub(crate) async fn run_single_agent_loop_unified(
                 MessageStyle::Info,
                 &format!("Previous archive: {}", session.path.display()),
             )?;
+
+            if session.is_fork {
+                renderer.line(
+                    MessageStyle::Info,
+                    "Starting independent forked session",
+                )?;
+            }
+
+            // Display full conversation history
+            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 content_preview = match &msg.content {
+                        uni::MessageContent::Text(text) => {
+                            if text.len() > 200 {
+                                format!("{}...", &text[..200])
+                            } else {
+                                text.clone()
+                            }
+                        }
+                        uni::MessageContent::Parts(parts) => {
+                            format!("[{} content parts]", parts.len())
+                        }
+                    };
+
+                    renderer.line(
+                        MessageStyle::Info,
+                        &format!("  [{}] {}: {}", idx + 1, role_label, content_preview),
+                    )?;
+                }
+            }
+
             renderer.line_if_not_empty(MessageStyle::Output)?;
         }
 
@@ -263,20 +307,52 @@ pub(crate) async fn run_single_agent_loop_unified(
             config.provider.clone()
         };
         let header_provider_label = provider_label.clone();
-        let archive_metadata = SessionArchiveMetadata::new(
-            workspace_label,
-            workspace_path,
-            config.model.clone(),
-            provider_label,
-            config.theme.clone(),
-            config.reasoning_effort.as_str().to_string(),
-        );
         let mut session_archive_error: Option<String> = None;
-        let mut session_archive = match SessionArchive::new(archive_metadata).await {
-            Ok(archive) => Some(archive),
-            Err(err) => {
-                session_archive_error = Some(err.to_string());
-                None
+        let mut session_archive = if let Some(resume) = resume_state.as_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());
+                match SessionArchive::fork(&resume.snapshot, custom_id).await {
+                    Ok(archive) => Some(archive),
+                    Err(err) => {
+                        session_archive_error = Some(err.to_string());
+                        None
+                    }
+                }
+            } else {
+                // Resume: create normal archive (resume doesn't modify original)
+                let archive_metadata = SessionArchiveMetadata::new(
+                    workspace_label,
+                    workspace_path,
+                    config.model.clone(),
+                    provider_label,
+                    config.theme.clone(),
+                    config.reasoning_effort.as_str().to_string(),
+                );
+                match SessionArchive::new(archive_metadata, None).await {
+                    Ok(archive) => Some(archive),
+                    Err(err) => {
+                        session_archive_error = Some(err.to_string());
+                        None
+                    }
+                }
+            }
+        } else {
+            // New session: create normal archive
+            let archive_metadata = SessionArchiveMetadata::new(
+                workspace_label,
+                workspace_path,
+                config.model.clone(),
+                provider_label,
+                config.theme.clone(),
+                config.reasoning_effort.as_str().to_string(),
+            );
+            match SessionArchive::new(archive_metadata, None).await {
+                Ok(archive) => Some(archive),
+                Err(err) => {
+                    session_archive_error = Some(err.to_string());
+                    None
+                }
             }
         };
 
diff --git a/src/cli/sessions.rs b/src/cli/sessions.rs
@@ -17,44 +17,58 @@ const INTERACTIVE_SESSION_LIMIT: usize = 10;
 pub async fn handle_resume_session_command(
     config: &CoreAgentConfig,
     mode: SessionResumeMode,
+    custom_session_id: Option<String>,
     skip_confirmations: bool,
 ) -> Result<()> {
     let resume = match mode {
-        SessionResumeMode::Latest => select_latest_session().await?,
-        SessionResumeMode::Specific(identifier) => Some(load_specific_session(&identifier).await?),
-        SessionResumeMode::Interactive => select_session_interactively().await?,
+        SessionResumeMode::Latest => select_latest_session(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__" {
+                select_latest_session(true).await?
+            } else {
+                Some(load_specific_session(&identifier, true).await?)
+            }
+        }
     };
 
-    let Some(resume) = resume else {
+    let Some(mut resume) = resume else {
         println!("{}", style("No session selected. Exiting.").yellow());
         return Ok(());
     };
 
-    print_resume_summary(&resume);
+    // If custom_session_id is provided, mark as fork
+    if let Some(suffix) = custom_session_id {
+        resume = fork_session(resume, suffix);
+        print_fork_summary(&resume);
+    } else {
+        print_resume_summary(&resume);
+    }
 
     run_single_agent_loop(config, skip_confirmations, resume).await
 }
 
-async fn select_latest_session() -> Result<Option<ResumeSession>> {
+async fn select_latest_session(is_fork: bool) -> Result<Option<ResumeSession>> {
     let mut listings = list_recent_sessions(1)
         .await
         .context("failed to load recent sessions")?;
     if let Some(listing) = listings.pop() {
-        Ok(Some(convert_listing(&listing)))
+        Ok(Some(convert_listing(&listing, is_fork)))
     } else {
         println!("{}", style("No archived sessions were found.").yellow());
         Ok(None)
     }
 }
 
-async fn load_specific_session(identifier: &str) -> Result<ResumeSession> {
+async fn load_specific_session(identifier: &str, is_fork: bool) -> Result<ResumeSession> {
     let listing = find_session_by_identifier(identifier)
         .await?
         .ok_or_else(|| anyhow!("No session with identifier '{}' was found.", identifier))?;
-    Ok(convert_listing(&listing))
+    Ok(convert_listing(&listing, is_fork))
 }
 
-async fn select_session_interactively() -> Result<Option<ResumeSession>> {
+async fn select_session_interactively(is_fork: bool) -> Result<Option<ResumeSession>> {
     let listings = list_recent_sessions(INTERACTIVE_SESSION_LIMIT)
         .await
         .context("failed to load recent sessions")?;
@@ -68,8 +82,14 @@ async fn select_session_interactively() -> Result<Option<ResumeSession>> {
         options.push(format_listing(listing));
     }
 
+    let prompt_text = if is_fork {
+        "Select a session to fork"
+    } else {
+        "Select a session to resume"
+    };
+
     let selection = Select::with_theme(&ColorfulTheme::default())
-        .with_prompt("Select a session to resume")
+        .with_prompt(prompt_text)
         .items(&options)
         .default(0)
         .interact_opt()
@@ -79,10 +99,10 @@ async fn select_session_interactively() -> Result<Option<ResumeSession>> {
         return Ok(None);
     };
 
-    Ok(Some(convert_listing(&listings[index])))
+    Ok(Some(convert_listing(&listings[index], is_fork)))
 }
 
-fn convert_listing(listing: &SessionListing) -> ResumeSession {
+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()
     } else {
@@ -99,6 +119,7 @@ fn convert_listing(listing: &SessionListing) -> ResumeSession {
         snapshot: listing.snapshot.clone(),
         history,
         path: listing.path.clone(),
+        is_fork,
     }
 }
 
@@ -143,6 +164,38 @@ fn print_resume_summary(resume: &ResumeSession) {
     );
 }
 
+fn fork_session(mut original: ResumeSession, custom_suffix: String) -> ResumeSession {
+    // Update identifier to reflect fork
+    original.identifier = format!("forked-{}", custom_suffix);
+    original.is_fork = true;
+    original
+}
+
+fn print_fork_summary(resume: &ResumeSession) {
+    let ended = resume
+        .snapshot
+        .ended_at
+        .with_timezone(&Local)
+        .format("%Y-%m-%d %H:%M");
+    println!(
+        "{}",
+        style(format!(
+            "Forking session with {} messages (original ended {})",
+            resume.message_count(),
+            ended
+        ))
+        .green()
+    );
+    println!(
+        "{}",
+        style(format!("Original archive: {}", resume.path.display())).green()
+    );
+    println!(
+        "{}",
+        style("Starting independent forked session").green()
+    );
+}
+
 async fn run_single_agent_loop(
     config: &CoreAgentConfig,
     skip_confirmations: bool,
@@ -250,8 +303,9 @@ mod tests {
             snapshot,
         };
 
-        let resume = convert_listing(&listing);
+        let resume = convert_listing(&listing, false);
         assert_eq!(resume.history.len(), 1);
         assert_eq!(resume.history[0].content.as_text(), "progress");
+        assert!(!resume.is_fork); // Verify is_fork is false for non-forked sessions
     }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -153,8 +153,13 @@ async fn run() -> Result<()> {
     }
 
     if let Some(resume_mode) = &startup.session_resume {
-        cli::handle_resume_session_command(core_cfg, resume_mode.clone(), skip_confirmations)
-            .await?;
+        cli::handle_resume_session_command(
+            core_cfg,
+            resume_mode.clone(),
+            startup.custom_session_id.clone(),
+            skip_confirmations,
+        )
+        .await?;
         return Ok(());
     }
 
diff --git a/src/startup/mod.rs b/src/startup/mod.rs
diff --git a/vtcode-core/src/cli/args.rs b/vtcode-core/src/cli/args.rs
diff --git a/vtcode-core/src/utils/session_archive.rs b/vtcode-core/src/utils/session_archive.rs

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ pub struct ResumeSession {`
`12`	`12`	`pub snapshot: SessionSnapshot,`
`13`	`13`	`pub history: Vec<ProviderMessage>,`
`14`	`14`	`pub path: PathBuf,`
	`15`	`+ pub is_fork: bool,`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`impl ResumeSession {`
Original file line number	Diff line number	Diff line change
`@@ -153,8 +153,13 @@ async fn run() -> Result<()> {`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`if let Some(resume_mode) = &startup.session_resume {`
`156`		`- cli::handle_resume_session_command(core_cfg, resume_mode.clone(), skip_confirmations)`
`157`		`- .await?;`
	`156`	`+ cli::handle_resume_session_command(`
	`157`	`+ core_cfg,`
	`158`	`+ resume_mode.clone(),`
	`159`	`+ startup.custom_session_id.clone(),`
	`160`	`+ skip_confirmations,`
	`161`	`+ )`
	`162`	`+ .await?;`
`158`	`163`	`return Ok(());`
`159`	`164`	`}`
`160`	`165`