Lightweight coding agent that runs in your terminal
Rust
Add managed worktree creation to TUI session commands (#43120)
Benjamin Carlssonf6976ab03699
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex b651273350..88b2316662 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -50,6 +50,10 @@ impl App {| AppEvent::SelectAgentThread(_)| AppEvent::StartSide { .. }| AppEvent::ForkCurrentSession { .. }+ | AppEvent::StartManagedWorktree {+ mode: crate::app_event::ManagedWorktreeMode::Fork,+ ..+ }| AppEvent::ForkSessionForPromptEdit { .. }| AppEvent::SetThreadGoalDraft { .. }| AppEvent::SetThreadGoalStatus {@@ -86,6 +90,9 @@ impl App {self.chat_widget.show_misalignment_policy_precaution();}}+ AppEvent::StartManagedWorktree { mode, name } => {+ self.start_managed_worktree(tui, app_server, mode, name).await;+ }AppEvent::ChangeWorkingDirectory {thread_id,requested_cwd,diff --git a/codex-rs/tui/src/app/reconnect.rs b/codex-rs/tui/src/app/reconnect.rsindex 7fee661b1e..8266534006 100644--- a/codex-rs/tui/src/app/reconnect.rs+++ b/codex-rs/tui/src/app/reconnect.rs@@ -244,6 +244,12 @@ impl App {self.rate_limit_refresh_state.invalidate_recovery();session.inherit_task_tool_capabilities(app_server);*app_server = session;+ self.chat_widget.set_local_worktree_operations(+ !crate::uses_remote_workspace_or_environment(+ &self.app_server_target,+ self.environment_manager.as_ref(),+ ),+ );self.chat_widget.cyber_policy_notice = Default::default();self.chat_widget.requires_openai_auth = bootstrap.requires_openai_auth;self.chat_widget.remote_connection =diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rsindex bef1726422..a5b143e6b2 100644--- a/codex-rs/tui/src/app/session_lifecycle.rs+++ b/codex-rs/tui/src/app/session_lifecycle.rs@@ -486,6 +486,7 @@ impl App {chat_widget.last_terminal_title = previous_terminal_title;}chat_widget.remote_connection = self.chat_widget.remote_connection.clone();+ chat_widget.set_local_worktree_operations(self.chat_widget.local_worktree_operations);chat_widget.set_agents_navigation_enabled(matches!(self.app_server_target,AppServerTarget::LocalDaemon { .. }diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rsindex ae32424052..9dae22c9fe 100644--- a/codex-rs/tui/src/app/startup.rs+++ b/codex-rs/tui/src/app/startup.rs@@ -505,6 +505,10 @@ impl App {};chat_widget.note_rendered_width(tui.terminal.last_known_screen_size.width);chat_widget.remote_connection = remote_connection;+ chat_widget.set_local_worktree_operations(!crate::uses_remote_workspace_or_environment(+ &app_server_target,+ environment_manager.as_ref(),+ ));chat_widget.set_agents_navigation_enabled(matches!(app_server_target,AppServerTarget::LocalDaemon { .. }diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex 50352de947..9e3be95ce9 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -2762,6 +2762,287 @@ async fn cold_paginated_subagent_transcript_excludes_inherited_parent_history()Ok(())}+#[tokio::test]+async fn managed_worktree_transitions_bind_owner_and_preserve_only_fork_history() -> Result<()> {+ use crate::app_event::ManagedWorktreeMode;+ use std::fs;+ use std::process::Command;++ let (mut app, mut events, _op_rx) = make_test_app_with_channels().await;+ let root = tempdir()?;+ let home = dunce::canonicalize(root.path())?.join("home");+ let source = dunce::canonicalize(root.path())?.join("source");+ let project_pool = dunce::canonicalize(root.path())?.join("project-pool");+ fs::create_dir_all(&home)?;+ fs::create_dir_all(source.join(".codex"))?;+ fs::write(home.join("config.toml"), "[features]\nworktrees = true\n")?;+ crate::legacy_core::config::set_project_trust_level(+ &home,+ &source,+ codex_protocol::config_types::TrustLevel::Trusted,+ )+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;+ let destination = format!(+ r#"developer_instructions = "committed policy"+model = "gpt-5.2"+model_reasoning_effort = "high"+[desktop]+git-worktree-root = {}+"#,+ toml::Value::String(project_pool.display().to_string()),+ );+ fs::write(source.join(".codex/config.toml"), destination)?;+ fs::write(source.join("AGENTS.md"), "committed worktree instructions")?;+ for args in [+ vec!["init", "--quiet"],+ vec!["add", "."],+ vec!["commit", "--quiet", "--no-gpg-sign", "-m", "initial"],+ ] {+ let result = Command::new("git")+ .current_dir(&source)+ .args([+ "-c",+ "user.name=Worktree Test",+ "-c",+ "[email protected]",+ ])+ .args(args)+ .output()?;+ assert!(+ result.status.success(),+ "{}",+ String::from_utf8_lossy(&result.stderr)+ );+ }+ fs::write(+ source.join(".codex/config.toml"),+ r#"developer_instructions = "dirty policy"+model = "gpt-5.4"+model_reasoning_effort = "low"+"#,+ )?;+ fs::write(source.join("AGENTS.md"), "dirty source instructions")?;+ app.config.codex_home = home.clone().abs();+ app.config.sqlite = SqliteConfig::new_for_testing(home.clone().abs());+ app.config.cwd = source.clone().abs();+ app.harness_overrides.permission_profile = Some(PermissionProfile::workspace_write());+ app.config = app.rebuild_config_for_cwd(source.clone()).await?;+ app.chat_widget+ .handle_thread_session_quiet(test_thread_session(ThreadId::new(), source.clone()));+ let (mut server, requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.start_fresh_session_with_summary_hint(+ &mut tui,+ &mut server,+ /*session_start_source*/ None,+ /*initial_user_message*/ None,+ /*new_thread_name*/ None,+ )+ .await;+ assert_eq!(+ (+ app.chat_widget.current_model(),+ app.config.model_provider_id.as_str(),+ app.chat_widget.current_reasoning_effort()+ ),+ ("gpt-5.4", "openai", Some(ReasoningEffortConfig::Low))+ );+ // Provider selection belongs to host config, not project config.+ let host_config = home.join("config.toml");+ let contents = fs::read_to_string(&host_config)?;+ fs::write(+ host_config,+ format!("model_provider = \"ollama\"\n{contents}"),+ )?;+ let original = app.chat_widget.thread_id().expect("original thread");+ server.thread_inject_items(original, vec![serde_json::from_value(serde_json::json!({+ "type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "managed fork history"}]+ }))?]).await?;+ let manager = codex_worktree::WorktreeManager::new(+ codex_worktree::WorktreeSettings::for_cli(&home, /*desktop*/ None)+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,+ );+ requests.lock().expect("request recorder lock").clear();+ app.handle_event(+ &mut tui,+ &mut server,+ AppEvent::StartManagedWorktree {+ mode: ManagedWorktreeMode::Fork,+ name: None,+ },+ )+ .await?;+ assert_eq!(app.chat_widget.thread_id(), Some(original));+ assert!(recorded_params(&requests, "thread/fork").is_empty());+ let unused = manager+ .list(&source)+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?+ .pop()+ .expect("unused checkout");+ assert_eq!(+ manager+ .owner(&unused.root)+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,+ None+ );+ let error = std::iter::from_fn(|| events.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => {+ Some(lines_to_single_string(&cell.display_lines(/*width*/ 500)))+ }+ _ => None,+ })+ .find(|message| message.contains("Cannot fork into this worktree"))+ .expect("fork refusal");+ let (_, with_path) = error+ .split_once("An unused checkout was created at ")+ .expect("checkout marker");+ let (path, _) = with_path+ .split_once("; remove it with")+ .expect("cleanup marker");+ insta::assert_snapshot!(error.replace(path, "<CHECKOUT>"), @"■ Cannot fork into this worktree because developer instructions differ. Start a new conversation instead. An unused checkout was created at <CHECKOUT>; remove it with `git worktree remove <checkout-path>` from the source repository.");+ fs::write(+ source.join(".codex/config.toml"),+ r#"developer_instructions = "committed policy"+[features]+terminal_visualization_instructions = true+"#,+ )?;+ app.config = app.rebuild_config_for_cwd(source.clone()).await?;+ requests.lock().expect("request recorder lock").clear();+ app.handle_event(+ &mut tui,+ &mut server,+ AppEvent::StartManagedWorktree {+ mode: ManagedWorktreeMode::Fork,+ name: None,+ },+ )+ .await?;+ assert_eq!(app.chat_widget.thread_id(), Some(original));+ assert!(recorded_params(&requests, "thread/fork").is_empty());+ for mode in [ManagedWorktreeMode::New, ManagedWorktreeMode::Fork] {+ requests.lock().expect("request recorder lock").clear();+ let previous = app.chat_widget.thread_id();+ let previous_rollout = app.chat_widget.rollout_path().expect("previous rollout");+ app.handle_event(+ &mut tui,+ &mut server,+ AppEvent::StartManagedWorktree {+ mode,+ name: Some(format!("{mode:?} worktree")),+ },+ )+ .await?;+ let replacement = app.chat_widget.thread_id().expect("replacement thread");+ assert_ne!(Some(replacement), previous);+ assert_eq!(+ app.chat_widget.thread_name(),+ Some(format!("{mode:?} worktree"))+ );+ let cwd = app.config.cwd.as_path().canonicalize()?;+ let checkouts = manager+ .list(&source)+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;+ let checkout = checkouts+ .iter()+ .find(|checkout| checkout.cwd.canonicalize().ok().as_ref() == Some(&cwd))+ .expect("managed checkout");+ assert!(checkout.root.starts_with(home.join("worktrees")));+ assert!(!project_pool.exists());+ assert_eq!(+ manager+ .owner(&checkout.root)+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?,+ Some(replacement.to_string())+ );+ assert_eq!(+ app.config.developer_instructions.as_deref(),+ Some("committed policy")+ );+ assert_eq!(+ fs::read_to_string(checkout.cwd.join("AGENTS.md"))?,+ "committed worktree instructions"+ );+ let fork = matches!(mode, ManagedWorktreeMode::Fork);+ let method = if fork { "thread/fork" } else { "thread/start" };+ let params = recorded_params(&requests, method);+ assert_eq!(params.len(), 1);+ assert_eq!(+ [+ params[0]["model"].as_str(),+ params[0]["modelProvider"].as_str(),+ params[0]["config"]["model_reasoning_effort"].as_str(),+ ],+ [Some("gpt-5.2"), Some("ollama"), Some("high")]+ );+ // Injection flushes and materializes a new thread's otherwise lazy rollout.+ server.thread_inject_items(replacement, vec![serde_json::from_value(serde_json::json!({+ "type": "message", "role": "assistant", "content": [{"type": "output_text", "text": format!("replacement persistence probe {mode:?}")}]+ }))?]).await?;+ let rollout = app.chat_widget.rollout_path().expect("replacement rollout");+ let mut history = fs::read(&rollout)?;+ let metadata = codex_rollout::read_session_meta_line(&rollout).await?;+ assert_eq!(metadata.meta.history_base.is_some(), fork);+ if let Some(base) = metadata.meta.history_base {+ assert!(fork, "New must not inherit history");+ assert_eq!(Some(base.thread_id), previous);+ let parent = fs::read(&previous_rollout)?;+ history.extend_from_slice(+ parent+ .get(..usize::try_from(base.end_byte_offset)?)+ .expect("valid inherited prefix"),+ );+ }+ let history = String::from_utf8(history)?;+ assert!(!history.contains("managed fork history"));+ if fork {+ assert!(history.contains("replacement persistence probe New"));+ }+ let attached = server+ .thread_read(replacement, /*include_turns*/ false)+ .await?;+ assert_eq!(attached.cwd.as_path().canonicalize()?, cwd);+ }+ app.start_fresh_session_with_summary_hint(+ &mut tui,+ &mut server,+ /*session_start_source*/ None,+ /*initial_user_message*/ None,+ /*new_thread_name*/ None,+ )+ .await;+ let unsaved = app.chat_widget.thread_id().expect("unsaved thread");+ let path = app.chat_widget.rollout_path();+ assert!(path.is_none_or(|path| !rollout_path_is_resumable(&path)));+ let completed = test_turn("completed-unsaved-turn", TurnStatus::Completed, Vec::new());+ app.thread_event_channels[&unsaved]+ .store+ .lock()+ .await+ .set_turns(vec![completed]);+ for mode in [ManagedWorktreeMode::Fork, ManagedWorktreeMode::New] {+ requests.lock().expect("request recorder lock").clear();+ app.handle_event(+ &mut tui,+ &mut server,+ AppEvent::StartManagedWorktree { mode, name: None },+ )+ .await?;+ let is_new = mode == ManagedWorktreeMode::New;+ assert_eq!(app.chat_widget.thread_id() != Some(unsaved), is_new);+ assert_eq!(recorded_params(&requests, "thread/fork").len(), 0);+ }+ server.shutdown().await?;+ proxy.await??;+ Ok(())+}+#[tokio::test]async fn changing_directory_preserves_project_trust_permissions_history_and_hooks() -> Result<()> {use codex_protocol::config_types::TrustLevel as T;diff --git a/codex-rs/tui/src/app/tests/turn_submission.rs b/codex-rs/tui/src/app/tests/turn_submission.rsindex 60342fd081..606ccaeb62 100644--- a/codex-rs/tui/src/app/tests/turn_submission.rs+++ b/codex-rs/tui/src/app/tests/turn_submission.rs@@ -11,6 +11,84 @@ use codex_protocol::permissions::FileSystemSpecialPath;use codex_protocol::permissions::NetworkSandboxPolicy;use pretty_assertions::assert_eq;+#[tokio::test]+async fn worktree_creation_event_requires_feature() -> Result<()> {+ let (mut app, mut events, _op_rx) = make_test_app_with_channels().await;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ while events.try_recv().is_ok() {}+ app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::StartManagedWorktree {+ mode: crate::app_event::ManagedWorktreeMode::New,+ name: None,+ },+ )+ .await?;+ let message = std::iter::from_fn(|| events.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => {+ Some(lines_to_single_string(&cell.display_lines(/*width*/ 100)))+ }+ _ => None,+ })+ .expect("disabled feature message");+ insta::assert_snapshot!(message, @"■ Enable worktrees in /experimental to create a worktree.");+ assert!(!app.config.codex_home.join("worktrees").exists());+ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn worktree_creation_rejects_untrusted_source_before_allocation() -> Result<()> {+ use crate::app_event::ManagedWorktreeMode;++ let (mut app, mut events, _op_rx) = make_test_app_with_channels().await;+ app.config.features.enable(Feature::Worktrees)?;+ app.config.active_project.trust_level =+ Some(codex_protocol::config_types::TrustLevel::Untrusted);+ let thread_id = ThreadId::new();+ app.primary_thread_id = Some(thread_id);+ app.chat_widget+ .handle_thread_session_quiet(test_thread_session(thread_id, app.config.cwd.to_path_buf()));+ let mut tui = crate::tui::test_support::make_test_tui()?;+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ for mode in [ManagedWorktreeMode::New, ManagedWorktreeMode::Fork] {+ if mode == ManagedWorktreeMode::Fork {+ app.config.active_project.trust_level =+ Some(codex_protocol::config_types::TrustLevel::Trusted);+ crate::legacy_core::config::set_project_trust_level(+ &app.config.codex_home,+ app.config.cwd.as_path(),+ codex_protocol::config_types::TrustLevel::Untrusted,+ )+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;+ }+ while events.try_recv().is_ok() {}+ app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::StartManagedWorktree { mode, name: None },+ )+ .await?;+ let message = std::iter::from_fn(|| events.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => {+ Some(lines_to_single_string(&cell.display_lines(/*width*/ 100)))+ }+ _ => None,+ })+ .expect("source trust error");+ insta::allow_duplicates! {+ insta::assert_snapshot!(message, @"■ Cannot create a worktree from an explicitly untrusted source.");+ }+ assert!(!app.config.codex_home.join("worktrees").exists());+ }+ app_server.shutdown().await?;+ Ok(())+}+#[tokio::test]async fn turn_start_failure_is_shown_without_exiting() -> Result<()> {let (mut app, mut app_event_rx, mut op_rx) = make_test_app_with_channels().await;@@ -64,6 +142,32 @@ async fn turn_start_failure_is_shown_without_exiting() -> Result<()> {#[tokio::test]async fn misalignment_policy_blocks_queued_turns_and_goal_resumption() -> Result<()> {let (mut app, _app_event_rx, mut op_rx) = make_test_app_with_channels().await;+ let checkout = tempfile::tempdir()?;+ app.config.cwd = AbsolutePathBuf::from_absolute_path(checkout.path())?;+ for args in [+ vec!["init", "--quiet"],+ vec![+ "-c",+ "user.name=Test",+ "-c",+ "[email protected]",+ "-c",+ "commit.gpgsign=false",+ "commit",+ "--quiet",+ "--allow-empty",+ "-m",+ "initial",+ ],+ ] {+ assert!(+ std::process::Command::new("git")+ .args(args)+ .current_dir(checkout.path())+ .status()?+ .success()+ );+ }let mut tui = crate::tui::test_support::make_test_tui()?;let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;let started = app_server.start_thread(&app.config).await?;@@ -126,12 +230,17 @@ async fn misalignment_policy_blocks_queued_turns_and_goal_resumption() -> Resultuser_message: Some("Do not fork this stopped thread".into()),},AppEvent::ForkCurrentSession { name: None },+ AppEvent::StartManagedWorktree {+ mode: crate::app_event::ManagedWorktreeMode::Fork,+ name: None,+ },AppEvent::OpenAgentPicker,AppEvent::SelectAgentThread(thread_id),] {app.handle_event(&mut tui, &mut app_server, event).await?;}+ assert!(!app.config.codex_home.join("worktrees").exists());assert_eq!(app_server.next_request_id(),AppServerRequestId::Integer(next_request_id + 1)diff --git a/codex-rs/tui/src/app/working_directory.rs b/codex-rs/tui/src/app/working_directory.rsindex 09ec332341..481b2867ce 100644--- a/codex-rs/tui/src/app/working_directory.rs+++ b/codex-rs/tui/src/app/working_directory.rs@@ -1,22 +1,141 @@-//! Local working-directory changes that preserve conversation history.+//! Local directory transitions and managed worktrees with fresh or preserved conversation history.use super::session_lifecycle::ThreadAttachPresentation;use super::*;use crate::app_server_session::ForkGoalContinuation::DeferUntilNextTurn;use crate::history_cell::McpInventoryLoadingCell as LoadingCell;+use crate::terminal_visualization_instructions::with_terminal_visualization_instructions;use codex_app_server_protocol::ThreadBackgroundTerminalsListParams;use codex_app_server_protocol::ThreadBackgroundTerminalsListResponse as ListResponse;impl App {+ pub(super) async fn start_managed_worktree(+ &mut self,+ tui: &mut tui::Tui,+ app_server: &mut AppServerSession,+ mode: crate::app_event::ManagedWorktreeMode,+ name: Option<String>,+ ) {+ if !self.config.features.enabled(Feature::Worktrees) {+ self.chat_widget.add_error_message(+ "Enable worktrees in /experimental to create a worktree.".to_string(),+ );+ } else if self.config.active_project.is_untrusted() {+ self.chat_widget.add_error_message(+ "Cannot create a worktree from an explicitly untrusted source.".to_string(),+ );+ } else if crate::uses_remote_workspace_or_environment(+ &self.app_server_target,+ self.environment_manager.as_ref(),+ ) {+ self.chat_widget.add_error_message(+ "Managed worktrees are only supported for local sessions.".to_string(),+ );+ } else if self+ .primary_thread_id+ .is_none_or(|thread_id| !self.chat_widget.can_change_working_directory(thread_id))+ {+ self.chat_widget.add_error_message(+ "Creating a worktree requires an idle primary session without queued input."+ .to_string(),+ );+ } else {+ let setup = async {+ let source = self+ .rebuild_config_for_cwd(self.config.cwd.to_path_buf())+ .await+ .map_err(|error| anyhow::anyhow!(error.to_string()))?;+ anyhow::ensure!(+ !source.active_project.is_untrusted(),+ "Cannot create a worktree from an explicitly untrusted source."+ );+ let host = crate::legacy_core::config::load_config_toml_with_layer_stack(+ &self.config.codex_home,+ /*cwd*/ None,+ Vec::new(),+ codex_config::ConfigLoadOptions::default(),+ )+ .await?;+ let settings = codex_worktree::WorktreeSettings::for_cli(+ &self.config.codex_home,+ host.config_toml.desktop.as_ref(),+ )?;+ let manager = codex_worktree::WorktreeManager::new(settings);+ let checkout = manager.create(&codex_worktree::CreateWorktree {+ source_cwd: self.config.cwd.to_path_buf(),+ base: None,+ })?;+ anyhow::Ok((manager, checkout))+ }+ .await;+ match setup {+ Ok((manager, checkout)) => {+ if let Err(error) = self+ .switch_to_managed_worktree(tui, app_server, manager, checkout, mode, name)+ .await+ {+ self.chat_widget.add_error_message(error.to_string());+ }+ }+ Err(error) => self.chat_widget.add_error_message(error.to_string()),+ }+ }+ }+fn working_directory_error(&mut self, message: impl Into<String>) {self.chat_widget.add_error_message(message.into());}+ pub(super) async fn switch_to_managed_worktree(+ &mut self,+ tui: &mut tui::Tui,+ app_server: &mut AppServerSession,+ manager: codex_worktree::WorktreeManager,+ checkout: codex_worktree::ManagedWorktree,+ mode: crate::app_event::ManagedWorktreeMode,+ name: Option<String>,+ ) -> Result<()> {+ let previous_thread_id = self.chat_widget.thread_id();+ let cwd = AbsolutePathBuf::from_absolute_path(checkout.cwd.clone())+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;+ self.change_working_directory_with_managed(+ tui,+ app_server,+ cwd,+ Some((manager, checkout, mode, name)),+ )+ .await;+ if self.chat_widget.thread_id() == previous_thread_id {+ return Err(color_eyre::eyre::eyre!(+ "Could not start a session in the managed worktree"+ ));+ }+ Ok(())+ }+pub(super) async fn change_working_directory(&mut self,tui: &mut tui::Tui,app_server: &mut AppServerSession,cwd: AbsolutePathBuf,+ ) {+ self.change_working_directory_with_managed(+ tui, app_server, cwd, /*managed_worktree*/ None,+ )+ .await;+ }++ async fn change_working_directory_with_managed(+ &mut self,+ tui: &mut tui::Tui,+ app_server: &mut AppServerSession,+ cwd: AbsolutePathBuf,+ managed_worktree: Option<(+ codex_worktree::WorktreeManager,+ codex_worktree::ManagedWorktree,+ crate::app_event::ManagedWorktreeMode,+ Option<String>,+ )>,) {if self.config.ephemeral || !cwd.as_path().is_dir() {return self.working_directory_error("This task cannot be safely replaced.");@@ -55,6 +174,21 @@ impl App {if config.active_project.trust_level.is_none() {return self.working_directory_error("This directory is not trusted; run Codex there.");}+ if let Some((_, checkout, crate::app_event::ManagedWorktreeMode::Fork, _)) =+ managed_worktree.as_ref()+ && with_terminal_visualization_instructions(+ &self.config,+ self.config.developer_instructions.clone(),+ ) != with_terminal_visualization_instructions(+ &config,+ config.developer_instructions.clone(),+ )+ {+ return self.working_directory_error(format!(+ "Cannot fork into this worktree because developer instructions differ. Start a new conversation instead. An unused checkout was created at {}; remove it with `git worktree remove <checkout-path>` from the source repository.",+ checkout.root.display()+ ));+ }if let Some(profile) = self.runtime_permission_profile_override.as_ref()&& profile.active_permission_profile.is_some()&& (!profile.matches_config(&config)@@ -98,10 +232,15 @@ impl App {Err(error) => return self.chat_widget.add_error_message(error),};config.service_tier = self.chat_widget.configured_service_tier();+ let is_new_worktree = matches!(+ managed_worktree.as_ref().map(|(_, _, mode, _)| mode),+ Some(crate::app_event::ManagedWorktreeMode::New)+ );let rollout = self.chat_widget.rollout_path();let has_rollout = rollout.as_deref().is_some_and(rollout_path_is_resumable);let channels = &self.thread_event_channels;if !has_rollout+ && !is_new_worktree&& (!self.chat_widget.token_usage().is_zero()|| channels.get(&thread_id).is_some_and(|channel| {channel.store.try_lock().map_or(/*default*/ true, |store| {@@ -142,7 +281,16 @@ impl App {return self.working_directory_error("Active background terminals block /cd.");}}- let transitioned = if has_rollout {+ if is_new_worktree {+ apply_managed_new_thread_defaults(+ &mut config,+ app_server.managed_new_thread_defaults(),+ &self.cli_kv_overrides,+ &self.harness_overrides,+ );+ }+ let preserve_history = has_rollout && !is_new_worktree;+ let transitioned = if preserve_history {app_server.fork_thread_at(&local_settings,@@ -163,7 +311,7 @@ impl App {).await};- let transitioned = match transitioned {+ let mut transitioned = match transitioned {Ok(value) => value,Err(e) => return self.working_directory_error(format!("Failed to change: {e}")),};@@ -177,16 +325,46 @@ impl App {{if session.thread_id != thread_id {let _ = app_server.thread_unsubscribe(session.thread_id).await;- if has_rollout {+ if preserve_history {let _ = app_server.thread_archive(session.thread_id).await;}}return self.working_directory_error("Requested directory or permissions not applied.");}+ if let Some((manager, checkout, _, _)) = managed_worktree.as_ref()+ && let Err(error) =+ manager.bind_thread(&checkout.root, &transitioned.session.thread_id.to_string())+ {+ let replacement_id = transitioned.session.thread_id;+ let _ = app_server.thread_unsubscribe(replacement_id).await;+ if preserve_history {+ let _ = app_server.thread_archive(replacement_id).await;+ }+ return self.working_directory_error(format!(+ "Cannot register managed worktree ownership: {error}"+ ));+ }+ let name_error = if let Some(name) = managed_worktree+ .as_ref()+ .and_then(|(_, _, _, name)| name.as_ref())+ {+ match app_server+ .thread_set_name(transitioned.session.thread_id, name.clone())+ .await+ {+ Ok(()) => {+ transitioned.session.thread_name = Some(name.clone());+ None+ }+ Err(error) => Some(format!("Failed to name the worktree session: {error}")),+ }+ } else {+ None+ };if let Err(error) = app_server.thread_unsubscribe(thread_id).await {let replacement_id = transitioned.session.thread_id;let _ = app_server.thread_unsubscribe(replacement_id).await;- if has_rollout {+ if preserve_history {let _ = app_server.thread_archive(replacement_id).await;}return self.working_directory_error(format!("Cannot change directories: {error}"));@@ -210,6 +388,9 @@ impl App {if let Err(error) = attach(self, tui, transitioned, lineage, message).await {return self.working_directory_error(format!("Could not restore session: {error}"));}+ if let Some(error) = name_error {+ self.chat_widget.add_error_message(error);+ }self.cancel_pending_key_chord();self.keymap = keymap;self.merge_startup_warnings(tui, &history_cell::StartupWarningsCell::default());diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex 1ac727a8c2..0a7fb54d85 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -66,6 +66,13 @@ use codex_protocol::models::ActivePermissionProfile;use crate::history_cell::HistoryCell;+/// Whether a managed checkout starts fresh or preserves the current conversation.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub(crate) enum ManagedWorktreeMode {+ New,+ Fork,+}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub(crate) enum ThreadGoalSetMode {ConfirmIfExists,@@ -388,6 +395,12 @@ pub(crate) enum AppEvent {name: Option<String>,},+ /// Create a managed checkout and start or fork a session into it.+ StartManagedWorktree {+ mode: ManagedWorktreeMode,+ name: Option<String>,+ },+/// Change the working directory of the originating idle primary thread.ChangeWorkingDirectory {thread_id: ThreadId,diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rsindex df82fdee71..967c712fe9 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs@@ -279,7 +279,6 @@ use super::paste_burst::PasteBurst;use super::prompt_args::parse_slash_name;use super::skill_popup::MentionItem;use super::skill_popup::SkillPopup;-use super::slash_commands::BuiltinCommandFlags;use super::slash_commands::ServiceTierCommand;use super::slash_commands::SlashCommandItem;use crate::bottom_pane::paste_burst::FlushResult;@@ -555,6 +554,7 @@ pub(crate) struct ChatComposer {mentions_v2_enabled: bool,goal_command_enabled: bool,personality_command_enabled: bool,+ worktrees_enabled: bool,windows_degraded_sandbox_active: bool,side_conversation_active: bool,history_search: Option<HistorySearchSession>,@@ -611,20 +611,6 @@ impl ChatComposer {)}- fn builtin_command_flags(&self) -> BuiltinCommandFlags {- BuiltinCommandFlags {- collaboration_modes_enabled: self.collaboration_modes_enabled,- connectors_enabled: self.connectors_enabled,- plugins_command_enabled: self.plugins_command_enabled,- token_activity_command_enabled: self.token_activity_command_enabled,- service_tier_commands_enabled: self.service_tier_commands_enabled,- goal_command_enabled: self.goal_command_enabled,- personality_command_enabled: self.personality_command_enabled,- allow_elevate_sandbox: self.windows_degraded_sandbox_active,- side_conversation_active: self.side_conversation_active,- }- }-pub fn new(has_input_focus: bool,app_event_tx: AppEventSender,@@ -732,6 +718,7 @@ impl ChatComposer {mentions_v2_enabled: false,goal_command_enabled: false,personality_command_enabled: false,+ worktrees_enabled: false,windows_degraded_sandbox_active: false,side_conversation_active: false,history_search: None,diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs b/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rsindex 81734f2d08..22fce854f4 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs@@ -178,6 +178,7 @@ impl<'a> SlashInput<'a> {service_tier_commands_enabled: self.command_flags.service_tier_commands_enabled,goal_command_enabled: self.command_flags.goal_command_enabled,personality_command_enabled: self.command_flags.personality_command_enabled,+ worktrees_enabled: self.command_flags.worktrees_enabled,windows_degraded_sandbox_active: self.command_flags.allow_elevate_sandbox,side_conversation_active: self.command_flags.side_conversation_active,},@@ -206,6 +207,25 @@ pub(super) fn queued_input_action(}impl ChatComposer {+ pub(super) fn builtin_command_flags(&self) -> BuiltinCommandFlags {+ BuiltinCommandFlags {+ collaboration_modes_enabled: self.collaboration_modes_enabled,+ connectors_enabled: self.connectors_enabled,+ plugins_command_enabled: self.plugins_command_enabled,+ token_activity_command_enabled: self.token_activity_command_enabled,+ service_tier_commands_enabled: self.service_tier_commands_enabled,+ goal_command_enabled: self.goal_command_enabled,+ personality_command_enabled: self.personality_command_enabled,+ worktrees_enabled: self.worktrees_enabled,+ allow_elevate_sandbox: self.windows_degraded_sandbox_active,+ side_conversation_active: self.side_conversation_active,+ }+ }++ pub fn set_worktrees_enabled(&mut self, enabled: bool) {+ self.worktrees_enabled = enabled;+ }+/// Handle key event when the slash-command popup is visible.pub(super) fn handle_key_event_with_slash_popup(&mut self,diff --git a/codex-rs/tui/src/bottom_pane/command_popup.rs b/codex-rs/tui/src/bottom_pane/command_popup.rsindex f613e5ee3f..81cc8013d8 100644--- a/codex-rs/tui/src/bottom_pane/command_popup.rs+++ b/codex-rs/tui/src/bottom_pane/command_popup.rs@@ -48,6 +48,7 @@ pub(crate) struct CommandPopupFlags {pub(crate) service_tier_commands_enabled: bool,pub(crate) goal_command_enabled: bool,pub(crate) personality_command_enabled: bool,+ pub(crate) worktrees_enabled: bool,pub(crate) windows_degraded_sandbox_active: bool,pub(crate) side_conversation_active: bool,}@@ -62,6 +63,7 @@ impl From<CommandPopupFlags> for BuiltinCommandFlags {service_tier_commands_enabled: value.service_tier_commands_enabled,goal_command_enabled: value.goal_command_enabled,personality_command_enabled: value.personality_command_enabled,+ worktrees_enabled: value.worktrees_enabled,allow_elevate_sandbox: value.windows_degraded_sandbox_active,side_conversation_active: value.side_conversation_active,}@@ -535,6 +537,7 @@ mod tests {service_tier_commands_enabled: false,goal_command_enabled: false,personality_command_enabled: true,+ worktrees_enabled: true,windows_degraded_sandbox_active: false,side_conversation_active: false,},@@ -562,6 +565,7 @@ mod tests {service_tier_commands_enabled: false,goal_command_enabled: false,personality_command_enabled: false,+ worktrees_enabled: false,windows_degraded_sandbox_active: false,side_conversation_active: false,},@@ -594,6 +598,7 @@ mod tests {service_tier_commands_enabled: false,goal_command_enabled: false,personality_command_enabled: true,+ worktrees_enabled: true,windows_degraded_sandbox_active: false,side_conversation_active: false,},diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rsindex c1cd7db9f3..aeff6e1f2e 100644--- a/codex-rs/tui/src/bottom_pane/mod.rs+++ b/codex-rs/tui/src/bottom_pane/mod.rs@@ -516,6 +516,11 @@ impl BottomPane {self.request_redraw();}+ pub fn set_worktrees_enabled(&mut self, enabled: bool) {+ self.composer.set_worktrees_enabled(enabled);+ self.request_redraw();+ }+pub fn set_personality_command_enabled(&mut self, enabled: bool) {self.composer.set_personality_command_enabled(enabled);self.request_redraw();diff --git a/codex-rs/tui/src/bottom_pane/slash_commands.rs b/codex-rs/tui/src/bottom_pane/slash_commands.rsindex 52b980e93f..61393648e7 100644--- a/codex-rs/tui/src/bottom_pane/slash_commands.rs+++ b/codex-rs/tui/src/bottom_pane/slash_commands.rs@@ -62,6 +62,7 @@ pub(crate) struct BuiltinCommandFlags {pub(crate) service_tier_commands_enabled: bool,pub(crate) goal_command_enabled: bool,pub(crate) personality_command_enabled: bool,+ pub(crate) worktrees_enabled: bool,pub(crate) allow_elevate_sandbox: bool,pub(crate) side_conversation_active: bool,}@@ -76,6 +77,7 @@ pub(crate) fn builtins_for_input(flags: BuiltinCommandFlags) -> Vec<(&'static st.filter(|(_, cmd)| flags.plugins_command_enabled || *cmd != SlashCommand::Plugins).filter(|(_, cmd)| flags.token_activity_command_enabled || *cmd != SlashCommand::Usage).filter(|(_, cmd)| flags.goal_command_enabled || *cmd != SlashCommand::Goal)+ .filter(|(_, cmd)| flags.worktrees_enabled || *cmd != SlashCommand::Worktree).filter(|(_, cmd)| flags.personality_command_enabled || *cmd != SlashCommand::Personality).filter(|(_, cmd)| !flags.side_conversation_active || cmd.available_in_side_conversation()).collect()@@ -171,11 +173,24 @@ mod tests {service_tier_commands_enabled: true,goal_command_enabled: true,personality_command_enabled: true,+ worktrees_enabled: true,allow_elevate_sandbox: true,side_conversation_active: false,}}+ #[test]+ fn worktree_command_lookup_requires_feature() {+ assert_eq!(+ find_builtin_command("worktree", BuiltinCommandFlags::default()),+ None+ );+ assert_eq!(+ find_builtin_command("worktree", all_enabled_flags()),+ Some(SlashCommand::Worktree)+ );+ }+#[test]fn debug_command_still_resolves_for_dispatch() {let cmd = find_builtin_command("debug-config", all_enabled_flags());diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 38f078b876..bbd1a13cea 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -366,6 +366,7 @@ mod hooks;mod interaction;mod skills;mod slash_dispatch;+mod worktree_picker;use self::skills::collect_tool_mentions;use self::skills::find_app_mentions;use self::skills::find_skill_mentions_with_tool_mentions;@@ -582,6 +583,7 @@ pub(crate) struct ChatWidget {status_account_display: Option<StatusAccountDisplay>,runtime_model_provider_base_url: Option<String>,pub(crate) remote_connection: Option<RemoteConnectionStatus>,+ pub(crate) local_worktree_operations: bool,token_info: Option<TokenUsageInfo>,token_usage_pending: bool,// Status and polling use account usage reads; response streams may identify meters differently.diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rsindex 945d85496a..8d4d956a29 100644--- a/codex-rs/tui/src/chatwidget/constructor.rs+++ b/codex-rs/tui/src/chatwidget/constructor.rs@@ -135,6 +135,7 @@ impl ChatWidget {status_account_display,runtime_model_provider_base_url,remote_connection: None,+ local_worktree_operations: true,token_info: None,token_usage_pending: false,rate_limit_snapshots_by_limit_id: BTreeMap::new(),@@ -287,6 +288,7 @@ impl ChatWidget {.set_collaboration_modes_enabled(/*enabled*/ true);widget.sync_service_tier_commands();widget.sync_personality_command_enabled();+ widget.sync_worktrees_enabled();widget.sync_plugins_command_enabled();widget.sync_goal_command_enabled();widget.sync_mentions_v2_enabled();diff --git a/codex-rs/tui/src/chatwidget/session_flow.rs b/codex-rs/tui/src/chatwidget/session_flow.rsindex 8ff0c58383..d62db38b6d 100644--- a/codex-rs/tui/src/chatwidget/session_flow.rs+++ b/codex-rs/tui/src/chatwidget/session_flow.rs@@ -132,6 +132,7 @@ impl ChatWidget {}self.sync_service_tier_commands();self.sync_personality_command_enabled();+ self.sync_worktrees_enabled();self.sync_plugins_command_enabled();self.sync_goal_command_enabled();self.refresh_plugin_mentions();diff --git a/codex-rs/tui/src/chatwidget/settings.rs b/codex-rs/tui/src/chatwidget/settings.rsindex 374d30d9b1..8fbf653e46 100644--- a/codex-rs/tui/src/chatwidget/settings.rs+++ b/codex-rs/tui/src/chatwidget/settings.rs@@ -80,6 +80,9 @@ impl ChatWidget {self.refresh_effective_service_tier();self.sync_service_tier_commands();}+ if feature == Feature::Worktrees {+ self.sync_worktrees_enabled();+ }if feature == Feature::Personality {self.sync_personality_command_enabled();}@@ -296,6 +299,17 @@ impl ChatWidget {.unwrap_or_else(|| self.current_collaboration_mode.model())}+ pub(crate) fn set_local_worktree_operations(&mut self, enabled: bool) {+ self.local_worktree_operations = enabled;+ self.sync_worktrees_enabled();+ }++ pub(super) fn sync_worktrees_enabled(&mut self) {+ self.bottom_pane.set_worktrees_enabled(+ self.config.features.enabled(Feature::Worktrees) && self.local_worktree_operations,+ );+ }+pub(super) fn sync_personality_command_enabled(&mut self) {self.bottom_pane.set_personality_command_enabled(self.config.features.enabled(Feature::Personality));diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rsindex c7dec771fb..b8db07ee74 100644--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs@@ -6,6 +6,7 @@//! slash-command recall follows the same submitted-input rule as ordinary text.use super::*;+use crate::app_event::ManagedWorktreeMode;use crate::app_event::ThreadGoalSetMode;use crate::bottom_pane::prompt_args::parse_slash_name;use crate::bottom_pane::slash_commands::BuiltinCommandFlags;@@ -181,7 +182,7 @@ impl ChatWidget {self.request_redraw();}SlashCommand::New => {- self.app_event_tx.send(AppEvent::NewSession { name: None });+ self.show_session_checkout_picker(ManagedWorktreeMode::New, /*name*/ None);}SlashCommand::Archive => {self.bottom_pane.show_selection_view(SelectionViewParams {@@ -247,8 +248,10 @@ impl ChatWidget {self.app_event_tx.send(AppEvent::OpenResumePicker);}SlashCommand::Fork => {- self.app_event_tx- .send(AppEvent::ForkCurrentSession { name: None });+ self.show_session_checkout_picker(ManagedWorktreeMode::Fork, /*name*/ None);+ }+ SlashCommand::Worktree => {+ self.show_managed_worktree_picker();}SlashCommand::App => {let Some(thread_id) = self.thread_id else {@@ -800,9 +803,10 @@ impl ChatWidget {self.app_event_tx.set_thread_name(name);}SlashCommand::New if !trimmed.is_empty() => {- self.app_event_tx.send(AppEvent::NewSession {- name: Some(trimmed.to_string()),- });+ self.show_session_checkout_picker(+ ManagedWorktreeMode::New,+ Some(trimmed.to_string()),+ );}SlashCommand::Clear if !trimmed.is_empty() => {self.app_event_tx.send(AppEvent::ClearUi {@@ -810,9 +814,10 @@ impl ChatWidget {});}SlashCommand::Fork if !trimmed.is_empty() => {- self.app_event_tx.send(AppEvent::ForkCurrentSession {- name: Some(trimmed.to_string()),- });+ self.show_session_checkout_picker(+ ManagedWorktreeMode::Fork,+ Some(trimmed.to_string()),+ );}SlashCommand::Plan if !trimmed.is_empty() => {let plan_available = self.apply_plan_slash_command();@@ -1139,6 +1144,8 @@ impl ChatWidget {goal_command_enabled: self.config.features.enabled(Feature::Goals),service_tier_commands_enabled: self.fast_mode_enabled(),personality_command_enabled: self.config.features.enabled(Feature::Personality),+ worktrees_enabled: self.config.features.enabled(Feature::Worktrees)+ && self.local_worktree_operations,allow_elevate_sandbox,side_conversation_active: self.active_side_conversation,}@@ -1182,6 +1189,13 @@ impl ChatWidget {Some(thread_id) if self.can_change_working_directory(thread_id) => QueueDrain::Stop,_ => QueueDrain::Continue,},+ SlashCommand::Worktree => {+ if self.managed_worktree_available() {+ QueueDrain::Stop+ } else {+ QueueDrain::Continue+ }+ }SlashCommand::Feedback| SlashCommand::Export| SlashCommand::Newdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snapnew file mode 100644index 0000000000..50f75113a6--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_local.snap@@ -0,0 +1,8 @@+---+source: tui/src/chatwidget/tests/slash_commands.rs+assertion_line: 3091+expression: popup+---+› /work++ /worktree start or continue a conversation in a new worktreediff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snapnew file mode 100644index 0000000000..38b1765f69--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_command_remote.snap@@ -0,0 +1,8 @@+---+source: tui/src/chatwidget/tests/slash_commands.rs+assertion_line: 3091+expression: popup+---+› /work++ gpt-5.6-sol default · /tmp/projectdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snapnew file mode 100644index 0000000000..a91fc16b17--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_conversation_choices.snap@@ -0,0 +1,12 @@+---+source: tui/src/chatwidget/tests/slash_commands.rs+expression: popup+---+ Create a new worktree++› 1. Continue current conversation Preserve this conversation in the new+ checkout+ 2. Start new conversation Open a fresh conversation in the new+ checkout++ Press enter to confirm or esc to go backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snapnew file mode 100644index 0000000000..e8cdf06c77--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_fork_choices.snap@@ -0,0 +1,10 @@+---+source: tui/src/chatwidget/tests/slash_commands.rs+expression: popup+---+ Where should the forked conversation run?++› 1. Current checkout Keep using the current working directory+ 2. New worktree Create an isolated managed checkout++ Press enter to confirm or esc to go backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snapnew file mode 100644index 0000000000..db7c23de4d--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__worktrees_new_choices.snap@@ -0,0 +1,10 @@+---+source: tui/src/chatwidget/tests/slash_commands.rs+expression: popup+---+ Where should the new conversation run?++› 1. Current checkout Keep using the current working directory+ 2. New worktree Create an isolated managed checkout++ Press enter to confirm or esc to go backdiff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rsindex 0435b3d554..6fe9ad42d0 100644--- a/codex-rs/tui/src/chatwidget/tests.rs+++ b/codex-rs/tui/src/chatwidget/tests.rs@@ -273,6 +273,8 @@ mod status_command_tests;mod status_surface_previews;mod terminal_title;mod usage;+#[path = "tests/worktree_picker_tests.rs"]+mod worktree_picker;pub(crate) use helpers::make_chatwidget_manual_with_sender;pub(crate) use helpers::set_chatgpt_auth;diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rsindex 71dc31a3bb..e84f8fb136 100644--- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs+++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs@@ -621,7 +621,7 @@ async fn queued_inline_rename_does_not_drain_again_before_turn_started() {#[tokio::test]async fn queued_unknown_slash_reports_error_when_dequeued() {- let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;chat.thread_id = Some(ThreadId::new());handle_turn_started(&mut chat, "turn-1");@@ -642,6 +642,24 @@ async fn queued_unknown_slash_reports_error_when_dequeued() {"expected delayed slash error, got {rendered:?}");assert!(chat.input_queue.queued_user_messages.is_empty());++ chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true);+ chat.set_local_worktree_operations(/*enabled*/ false);+ let drain = chat.submit_queued_slash_prompt(UserMessage::from("/worktree extra").into());+ assert_matches!(drain, QueueDrain::Continue);+ assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));+ assert!(drain_insert_history(&mut rx).iter().any(|lines| {+ lines_to_single_string(lines).contains("Unrecognized command '/worktree'")+ }));++ chat.set_local_worktree_operations(/*enabled*/ true);+ let non_git = tempfile::tempdir().unwrap();+ chat.config.cwd = non_git.path().to_path_buf().abs();+ let drain = chat.submit_queued_slash_prompt(UserMessage::from("/worktree").into());+ assert_matches!(drain, QueueDrain::Continue);+ assert!(drain_insert_history(&mut rx).iter().any(|lines| {+ lines_to_single_string(lines).contains("Managed worktrees require a local Git repository.")+ }));}#[tokio::test]diff --git a/codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rs b/codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rsnew file mode 100644index 0000000000..d6fc917381--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/worktree_picker_tests.rs@@ -0,0 +1,91 @@+//! Worktree picker behavior and rendered choices.++use super::*;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn slash_new_and_fork_offer_checkout_choices_inside_local_git_repository() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let checkout = tempdir().expect("temporary checkout");+ std::fs::create_dir(checkout.path().join(".git")).expect("git directory");+ std::fs::write(checkout.path().join(".git/HEAD"), "ref: refs/heads/main\n").expect("git HEAD");+ chat.config.cwd =+ AbsolutePathBuf::from_absolute_path(checkout.path()).expect("absolute checkout");++ chat.dispatch_command(SlashCommand::Fork);+ assert_matches!(+ rx.try_recv(),+ Ok(AppEvent::ForkCurrentSession { name: None })+ );+ chat.dispatch_command(SlashCommand::New);+ assert_matches!(rx.try_recv(), Ok(AppEvent::NewSession { name: None }));++ chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true);+ chat.dispatch_command(SlashCommand::Fork);++ let popup = render_bottom_popup(&chat, /*width*/ 80);+ assert_chatwidget_snapshot!("worktrees_fork_choices", popup);+ chat.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));+ chat.dispatch_command(SlashCommand::New);+ let popup = render_bottom_popup(&chat, /*width*/ 80);+ assert_chatwidget_snapshot!("worktrees_new_choices", popup);+ assert!(popup.contains("Current checkout"), "popup: {popup}");+ assert!(popup.contains("New worktree"), "popup: {popup}");+ assert_matches!(rx.try_recv(), Err(TryRecvError::Empty));+ chat.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));+ chat.bottom_pane+ .set_composer_text("/new named".into(), Vec::new(), Vec::new());+ chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ chat.handle_key_event(KeyEvent::new(KeyCode::Char('1'), KeyModifiers::NONE));+ assert_matches!(rx.try_recv(), Ok(AppEvent::NewSession { name: Some(name) }) if name == "named");+ chat.bottom_pane+ .set_composer_text("/fork named".into(), Vec::new(), Vec::new());+ chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ chat.handle_key_event(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE));+ assert_matches!(rx.try_recv(), Ok(AppEvent::StartManagedWorktree {+ mode: crate::app_event::ManagedWorktreeMode::Fork,+ name: Some(name),+ }) if name == "named");+ chat.set_local_worktree_operations(/*enabled*/ false);+ chat.dispatch_command(SlashCommand::New);+ assert_matches!(rx.try_recv(), Ok(AppEvent::NewSession { name: None }));+ chat.dispatch_command(SlashCommand::Fork);+ assert_matches!(+ rx.try_recv(),+ Ok(AppEvent::ForkCurrentSession { name: None })+ );+ for (available, snapshot) in [+ (false, "worktrees_command_remote"),+ (true, "worktrees_command_local"),+ ] {+ chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true);+ chat.set_local_worktree_operations(available);+ chat.bottom_pane+ .set_composer_text("/work".into(), Vec::new(), Vec::new());+ let popup = normalize_snapshot_paths(render_bottom_popup(&chat, /*width*/ 80));+ assert_chatwidget_snapshot!(snapshot, popup);+ assert_eq!(popup.contains("/worktree"), available);+ }+}++#[tokio::test]+async fn slash_worktree_offers_current_or_new_conversation() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let checkout = tempdir().expect("temporary checkout");+ std::fs::create_dir(checkout.path().join(".git")).expect("git directory");+ std::fs::write(checkout.path().join(".git/HEAD"), "ref: refs/heads/main\n").expect("git HEAD");+ chat.config.cwd =+ AbsolutePathBuf::from_absolute_path(checkout.path()).expect("absolute checkout");++ chat.set_feature_enabled(Feature::Worktrees, /*enabled*/ true);+ chat.dispatch_command(SlashCommand::Worktree);++ let popup = render_bottom_popup(&chat, /*width*/ 80);+ assert_chatwidget_snapshot!("worktrees_conversation_choices", popup);+ assert!(+ popup.contains("Continue current conversation"),+ "popup: {popup}"+ );+ assert!(popup.contains("Start new conversation"), "popup: {popup}");+ assert_matches!(rx.try_recv(), Err(TryRecvError::Empty));+}diff --git a/codex-rs/tui/src/chatwidget/worktree_picker.rs b/codex-rs/tui/src/chatwidget/worktree_picker.rsnew file mode 100644index 0000000000..31359aa8eb--- /dev/null+++ b/codex-rs/tui/src/chatwidget/worktree_picker.rs@@ -0,0 +1,121 @@+//! Worktree choices for local, feature-enabled session commands.++use super::*;+use crate::app_event::ManagedWorktreeMode;++impl ChatWidget {+ pub(super) fn managed_worktree_available(&self) -> bool {+ self.config.features.enabled(Feature::Worktrees)+ && self.local_worktree_operations+ && get_git_repo_root(self.config.cwd.as_path()).is_some()+ }++ pub(super) fn show_session_checkout_picker(+ &mut self,+ mode: ManagedWorktreeMode,+ name: Option<String>,+ ) {+ if !self.managed_worktree_available() {+ match mode {+ ManagedWorktreeMode::New => {+ self.app_event_tx.send(AppEvent::NewSession { name });+ }+ ManagedWorktreeMode::Fork => {+ self.app_event_tx+ .send(AppEvent::ForkCurrentSession { name });+ }+ }+ return;+ }++ let title = match mode {+ ManagedWorktreeMode::New => "Where should the new conversation run?",+ ManagedWorktreeMode::Fork => "Where should the forked conversation run?",+ };+ let current_name = name.clone();+ self.bottom_pane.show_selection_view(SelectionViewParams {+ title: Some(title.to_string()),+ footer_hint: Some(standard_popup_hint_line()),+ items: vec![+ SelectionItem {+ name: "Current checkout".to_string(),+ description: Some("Keep using the current working directory".to_string()),+ actions: vec![Box::new(move |tx| match mode {+ ManagedWorktreeMode::New => {+ tx.send(AppEvent::NewSession {+ name: current_name.clone(),+ });+ }+ ManagedWorktreeMode::Fork => {+ tx.send(AppEvent::ForkCurrentSession {+ name: current_name.clone(),+ });+ }+ })],+ dismiss_on_select: true,+ ..Default::default()+ },+ SelectionItem {+ name: "New worktree".to_string(),+ description: Some("Create an isolated managed checkout".to_string()),+ actions: vec![Box::new(move |tx| {+ tx.send(AppEvent::StartManagedWorktree {+ mode,+ name: name.clone(),+ });+ })],+ dismiss_on_select: true,+ ..Default::default()+ },+ ],+ ..Default::default()+ });+ self.request_redraw();+ }++ pub(super) fn show_managed_worktree_picker(&mut self) {+ if !self.config.features.enabled(Feature::Worktrees) {+ self.add_error_message(+ "Enable worktrees in /experimental to create a worktree.".to_string(),+ );+ return;+ }+ if !self.managed_worktree_available() {+ self.add_error_message("Managed worktrees require a local Git repository.".to_string());+ return;+ }++ self.bottom_pane.show_selection_view(SelectionViewParams {+ title: Some("Create a new worktree".to_string()),+ footer_hint: Some(standard_popup_hint_line()),+ items: vec![+ SelectionItem {+ name: "Continue current conversation".to_string(),+ description: Some("Preserve this conversation in the new checkout".to_string()),+ actions: vec![Box::new(|tx| {+ tx.send(AppEvent::StartManagedWorktree {+ mode: ManagedWorktreeMode::Fork,+ name: None,+ });+ })],+ dismiss_on_select: true,+ ..Default::default()+ },+ SelectionItem {+ name: "Start new conversation".to_string(),+ description: Some("Open a fresh conversation in the new checkout".to_string()),+ actions: vec![Box::new(|tx| {+ tx.send(AppEvent::StartManagedWorktree {+ mode: ManagedWorktreeMode::New,+ name: None,+ });+ })],+ dismiss_on_select: true,+ ..Default::default()+ },+ ],+ ..Default::default()+ });+ self.request_redraw();+ }+}diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rsindex 97b4b9897b..ca83861bdb 100644--- a/codex-rs/tui/src/slash_command.rs+++ b/codex-rs/tui/src/slash_command.rs@@ -35,6 +35,7 @@ pub enum SlashCommand {Delete,Resume,Fork,+ Worktree,App,Init,Compact,@@ -99,6 +100,7 @@ impl SlashCommand {SlashCommand::Delete => "permanently delete this session and exit",SlashCommand::Clear => "clear the terminal and start a new chat",SlashCommand::Fork => "fork the current chat",+ SlashCommand::Worktree => "start or continue a conversation in a new worktree",SlashCommand::App => "continue this session in the Desktop app",SlashCommand::Quit | SlashCommand::Exit => "exit Codex",SlashCommand::Copy => "copy the last response or part of it",@@ -210,6 +212,7 @@ impl SlashCommand {| SlashCommand::Archive| SlashCommand::Delete| SlashCommand::Fork+ | SlashCommand::Worktree| SlashCommand::Init| SlashCommand::Compact| SlashCommand::Recap