Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add working-directory commands to the TUI (#38894)

Benjamin Carlssoned32158e90ef
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rs
index a947f240cf..f7c68c9341 100644
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -234,6 +234,7 @@ mod thread_routing;
mod thread_session_state;
mod thread_settings;
mod transcript_export;
+mod working_directory;
use self::agent_navigation::AgentNavigationDirection;
use self::agent_navigation::AgentNavigationState;
@@ -522,6 +523,8 @@ pub(crate) struct App {
/// Config is stored here so we can recreate ChatWidgets as needed.
pub(crate) config: Config,
launch_cwd: PathBuf,
+ /// Resume anchor selected by `/cd`; ordinary resumes retain the immutable launch cwd.
+ runtime_working_directory_override: Option<PathBuf>,
pub(crate) state_db: Option<StateDbHandle>,
cli_kv_overrides: Vec<(String, TomlValue)>,
harness_overrides: ConfigOverrides,
diff --git a/codex-rs/tui/src/app/background_requests.rs b/codex-rs/tui/src/app/background_requests.rs
index 4f14c69070..43f2e4585c 100644
--- a/codex-rs/tui/src/app/background_requests.rs
+++ b/codex-rs/tui/src/app/background_requests.rs
@@ -232,10 +232,10 @@ impl App {
let app_event_tx = self.app_event_tx.clone();
let cwd = self.config.cwd.to_path_buf();
tokio::spawn(async move {
- let result = fetch_skills_list(request_handle, cwd)
+ let result = fetch_skills_list(request_handle, cwd.clone())
.await
.map_err(|err| format!("{err:#}"));
- app_event_tx.send(AppEvent::SkillsListLoaded { result });
+ app_event_tx.send(AppEvent::SkillsListLoaded { cwd, result });
});
}
@@ -565,14 +565,15 @@ impl App {
let request_handle = app_server.request_handle();
let app_event_tx = self.app_event_tx.clone();
if !self.config.features.enabled(Feature::Plugins) {
- app_event_tx.send(AppEvent::PluginMentionsLoaded { plugins: None });
+ app_event_tx.send(AppEvent::PluginMentionsLoaded { cwd, plugins: None });
return;
}
tokio::spawn(async move {
- match fetch_plugin_mentions(request_handle, cwd).await {
+ match fetch_plugin_mentions(request_handle, cwd.clone()).await {
Ok(plugins) => {
app_event_tx.send(AppEvent::PluginMentionsLoaded {
+ cwd,
plugins: Some(plugins),
});
}
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index 1a23f6f06a..9884e89c8a 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -10,6 +10,7 @@ use crate::app_server_session::ForkGoalContinuation;
use crate::config_update::format_config_error;
use crate::external_agent_config_migration::flow::ExternalAgentConfigMigrationFlowOutcome;
use crate::pager_overlay::TranscriptHistoryState;
+use crate::session_resume::cwds_differ;
#[cfg(target_os = "windows")]
use codex_config::types::WindowsSandboxModeToml;
@@ -23,6 +24,9 @@ impl App {
event: AppEvent,
) -> Result<AppRunControl> {
match event {
+ AppEvent::SkillsListLoaded { ref cwd, .. }
+ | AppEvent::PluginMentionsLoaded { ref cwd, .. }
+ if cwds_differ(cwd, self.config.cwd.as_path()) => {}
AppEvent::NewSession { name } => {
self.start_fresh_session_with_summary_hint(
tui, app_server, /*session_start_source*/ None,
@@ -30,6 +34,44 @@ impl App {
)
.await;
}
+ AppEvent::ChangeWorkingDirectory {
+ thread_id,
+ requested_cwd,
+ } => {
+ if self.primary_thread_id != Some(thread_id)
+ || !self.chat_widget.can_change_working_directory(thread_id)
+ {
+ self.chat_widget.add_error_message(
+ "Changing directories requires an idle primary session without queued input."
+ .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(
+ "Changing directories is not supported for remote workspaces or remote execution environments."
+ .to_string(),
+ );
+ } else {
+ let cwd = AbsolutePathBuf::resolve_path_against_base(
+ requested_cwd.as_path(),
+ self.chat_widget.config_ref().cwd.as_path(),
+ );
+ match std::fs::metadata(cwd.as_path()) {
+ Ok(metadata) if metadata.is_dir() => {
+ self.change_working_directory(tui, app_server, cwd).await;
+ }
+ Ok(_) => self
+ .chat_widget
+ .add_error_message(format!("Not a directory: {}", cwd.display())),
+ Err(error) => self.chat_widget.add_error_message(format!(
+ "Cannot access directory {}: {error}",
+ cwd.display()
+ )),
+ }
+ }
+ }
AppEvent::StartupThreadStarted { result } => {
self.handle_startup_thread_started(app_server, result)
.await?;
@@ -657,7 +699,11 @@ impl App {
AppEvent::AppendMessageHistoryEntry { thread_id, text } => {
self.append_message_history_entry(thread_id, text);
}
- AppEvent::SyncThreadGitBranch { thread_id, branch } => {
+ AppEvent::SyncThreadGitBranch {
+ thread_id,
+ branch,
+ cwd: _cwd,
+ } => {
if let Err(err) = app_server
.thread_metadata_update_branch(thread_id, branch)
.await
@@ -692,7 +738,10 @@ impl App {
self.enqueue_thread_history_entry_response(thread_id, event)
.await?;
}
- AppEvent::DiffResult(text) => {
+ AppEvent::DiffResult(cwd, text) => {
+ if cwds_differ(&cwd, self.chat_widget.config_ref().cwd.as_path()) {
+ return Ok(AppRunControl::Continue);
+ }
// Clear the in-progress state in the bottom pane
self.chat_widget.on_diff_complete();
// Enter alternate screen using TUI helper and build pager lines
@@ -1028,7 +1077,7 @@ impl App {
} => {
self.handle_mcp_inventory_result(result, detail, thread_id);
}
- AppEvent::SkillsListLoaded { result } => {
+ AppEvent::SkillsListLoaded { result, .. } => {
self.handle_skills_list_result(
result.map_err(|err| color_eyre::eyre::eyre!(err)),
"failed to load skills on startup",
@@ -1959,7 +2008,7 @@ impl App {
AppEvent::RefreshPluginMentions => {
self.refresh_plugin_mentions(app_server);
}
- AppEvent::PluginMentionsLoaded { mut plugins } => {
+ AppEvent::PluginMentionsLoaded { mut plugins, .. } => {
if !self.config.features.enabled(Feature::Plugins) {
plugins = None;
}
diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs
index 4edbb5abc6..d255fefcbf 100644
--- a/codex-rs/tui/src/app/session_lifecycle.rs
+++ b/codex-rs/tui/src/app/session_lifecycle.rs
@@ -922,9 +922,9 @@ impl App {
self.refresh_in_memory_config_from_disk_best_effort("resuming a thread")
.await;
let cwd_override = self
- .harness_overrides
- .cwd
+ .runtime_working_directory_override
.as_deref()
+ .or(self.harness_overrides.cwd.as_deref())
.or_else(|| app_server.remote_cwd_override());
let resume_cwd_mode = crate::session_resume::effective_resume_cwd_mode(
self.config.tui_resume_cwd,
diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs
index 97d5bb6977..5d2a244253 100644
--- a/codex-rs/tui/src/app/startup.rs
+++ b/codex-rs/tui/src/app/startup.rs
@@ -396,6 +396,7 @@ See the Codex keymap documentation for supported actions and examples."
workspace_command_runner: Some(workspace_command_runner),
config,
launch_cwd,
+ runtime_working_directory_override: None,
state_db,
cli_kv_overrides,
harness_overrides,
diff --git a/codex-rs/tui/src/app/test_support.rs b/codex-rs/tui/src/app/test_support.rs
index 45ab3116cc..2c39c9972e 100644
--- a/codex-rs/tui/src/app/test_support.rs
+++ b/codex-rs/tui/src/app/test_support.rs
@@ -23,6 +23,7 @@ pub(super) async fn make_test_app() -> App {
chat_widget,
workspace_command_runner: None,
launch_cwd: config.cwd.to_path_buf(),
+ runtime_working_directory_override: None,
config,
state_db: None,
cli_kv_overrides: Vec::new(),
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 04322ea582..5ce24e40ef 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -4867,6 +4867,7 @@ async fn make_test_app() -> App {
chat_widget,
workspace_command_runner: None,
launch_cwd: config.cwd.to_path_buf(),
+ runtime_working_directory_override: None,
config,
state_db: None,
cli_kv_overrides: Vec::new(),
@@ -4942,6 +4943,7 @@ async fn make_test_app_with_channels() -> (
chat_widget,
workspace_command_runner: None,
launch_cwd: config.cwd.to_path_buf(),
+ runtime_working_directory_override: None,
config,
state_db: None,
cli_kv_overrides: Vec::new(),
@@ -6362,12 +6364,16 @@ async fn remote_resume_keeps_server_only_cwd_out_of_local_config() -> Result<()>
#[tokio::test]
async fn in_app_resume_uses_configured_or_explicit_cwd() -> Result<()> {
- for (configured_mode, has_explicit_cwd, has_remote_exec, expected_directory) in [
- ("current", false, false, "launch"),
- ("session", false, false, "session"),
- ("session", true, false, "explicit"),
- ("session", false, true, "session"),
- ("session", true, true, "explicit"),
+ for (configured_mode, has_explicit_cwd, has_remote_exec, has_runtime_cwd, expected_directory) in [
+ ("current", false, false, false, "launch"),
+ ("session", false, false, false, "session"),
+ ("session", true, false, false, "explicit"),
+ ("session", false, true, false, "session"),
+ ("session", true, true, false, "explicit"),
+ ("current", false, false, true, "runtime"),
+ ("current", true, false, true, "runtime"),
+ ("session", false, false, true, "runtime"),
+ ("session", true, false, true, "runtime"),
] {
let temp_dir = tempdir()?;
let codex_home = temp_dir.path().join("codex-home");
@@ -6375,15 +6381,25 @@ async fn in_app_resume_uses_configured_or_explicit_cwd() -> Result<()> {
let active_cwd = temp_dir.path().join("active");
let session_cwd = temp_dir.path().join("session");
let explicit_cwd = temp_dir.path().join("explicit");
+ let runtime_cwd = temp_dir.path().join("runtime");
std::fs::create_dir_all(&codex_home)?;
std::fs::create_dir_all(&launch_cwd)?;
std::fs::create_dir_all(&active_cwd)?;
std::fs::create_dir_all(&session_cwd)?;
std::fs::create_dir_all(&explicit_cwd)?;
+ std::fs::create_dir_all(&runtime_cwd)?;
std::fs::write(
codex_home.join("config.toml"),
format!("[tui]\nresume_cwd = \"{configured_mode}\"\n"),
)?;
+ if has_runtime_cwd {
+ crate::legacy_core::config::set_project_trust_level(
+ codex_home.as_path(),
+ runtime_cwd.as_path(),
+ codex_protocol::config_types::TrustLevel::Trusted,
+ )
+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
+ }
let config = ConfigBuilder::default()
.codex_home(codex_home.clone())
.loader_overrides(LoaderOverrides::without_managed_config_for_tests())
@@ -6455,6 +6471,30 @@ async fn in_app_resume_uses_configured_or_explicit_cwd() -> Result<()> {
app.chat_widget
.handle_thread_session_quiet(test_thread_session(ThreadId::new(), active_cwd));
let mut tui = crate::tui::test_support::make_test_tui()?;
+ if has_runtime_cwd {
+ let started = app_server
+ .start_thread_with_session_start_source(
+ &app.config,
+ /*session_start_source*/ None,
+ )
+ .await?;
+ let empty_thread_id = started.session.thread_id;
+ app.replace_chat_widget_with_app_server_thread(
+ &mut tui,
+ started,
+ crate::app::session_lifecycle::ThreadAttachPresentation::SessionLineage,
+ /*initial_user_message*/ None,
+ )
+ .await?;
+ app.change_working_directory(&mut tui, &mut app_server, runtime_cwd.clone().abs())
+ .await;
+
+ assert_ne!(app.chat_widget.thread_id(), Some(empty_thread_id));
+ assert_eq!(
+ app.runtime_working_directory_override.as_deref(),
+ Some(runtime_cwd.as_path()),
+ );
+ }
let control = app
.resume_target_session(
diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
index 234275913a..9c5b0659ea 100644
--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
@@ -109,6 +109,8 @@ async fn start_recording_app_server_with_history(
let proxy = tokio::spawn(async move {
let (stream, _) = listener.accept().await?;
let mut websocket = accept_async(stream).await?;
+ let mut inventories = usize::from(failed_thread_name == Some("background"));
+ let mut reject_detach = false;
while let Some(frame) = websocket.next().await {
let Message::Text(text) = frame? else {
continue;
@@ -187,6 +189,11 @@ async fn start_recording_app_server_with_history(
},
})
} else {
+ let background = request.method == "thread/backgroundTerminals/list" && {
+ inventories += usize::from(inventories > 0);
+ matches!(inventories, 2 | 4)
+ };
+ let detach = request.method == "thread/unsubscribe";
let request = serde_json::from_value::<ClientRequest>(
serde_json::to_value(request)?,
)?;
@@ -202,7 +209,12 @@ async fn start_recording_app_server_with_history(
&request,
ClientRequest::ThreadSetName { params, .. }
if failed_thread_name == Some(params.name.as_str())
- );
+ ) || matches!(
+ &request,
+ ClientRequest::ThreadFork { params, .. }
+ if params.cwd.as_deref().is_some_and(|cwd| cwd.ends_with("failure"))
+ && { reject_detach = true; true }
+ ) || (detach && std::mem::take(&mut reject_detach));
if force_failure {
JSONRPCMessage::Error(JSONRPCError {
id: request_id,
@@ -213,7 +225,12 @@ async fn start_recording_app_server_with_history(
},
})
} else {
- match embedded.request(request).await? {
+ let mut result = embedded.request(request).await?;
+ if background {
+ let terminal = r#"{"data":[{"itemId":"x","processId":"x","command":"x","cwd":"/"}],"nextCursor":null}"#;
+ result = Ok(serde_json::from_str(terminal)?);
+ }
+ match result {
Ok(result) => JSONRPCMessage::Response(JSONRPCResponse {
id: request_id,
result,
@@ -1313,6 +1330,254 @@ async fn cold_paginated_subagent_transcript_excludes_inherited_parent_history()
Ok(())
}
+#[tokio::test]
+async fn changing_directory_preserves_project_trust_permissions_history_and_hooks() -> Result<()> {
+ use codex_protocol::config_types::TrustLevel as T;
+ use serde_json::json;
+ use std::fs;
+
+ let (mut app, mut events, _op_rx) = make_test_app_with_channels().await;
+ let codex_home = tempdir()?;
+ app.config.codex_home = codex_home.path().to_path_buf().abs();
+ app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
+ app.harness_overrides.permission_profile = Some(PermissionProfile::workspace_write());
+ let names = ["root", "trusted", "unknown", "untrusted", "p", "failure"];
+ let [current, trusted, unknown, untrusted, mismatch, failed] =
+ names.map(|name| codex_home.path().join(name));
+ fs::create_dir_all(&current)?;
+ for directory in [&trusted, &unknown, &untrusted, &mismatch, &failed] {
+ fs::create_dir_all(directory.join(".codex"))?;
+ fs::write(directory.join(".codex/config.toml"), "")?;
+ }
+ let contents = "developer_instructions = \"destination policy\"\nmodel_reasoning_effort = \"high\"\napproval_policy = \"on-request\"\n[tui]\ntheme = \"dracula\"\n[tui.keymap.global]\nopen_transcript = \"f12\"";
+ fs::write(trusted.join(".codex/config.toml"), contents)?;
+ let agents = trusted.join("AGENTS.md");
+ fs::write(&agents, "Follow destination project instructions.")?;
+ let hooks = r#"{"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"x"}]}]}}"#;
+ fs::write(trusted.join(".codex/hooks.json"), hooks)?;
+ let contents = "default_permissions = \"dev\"\n[permissions.dev.filesystem]\n\":root\" = \"write\"\n[tui.keymap.global]\nopen_transcript = \"ctrl-l\"";
+ fs::write(mismatch.join(".codex/config.toml"), contents)?;
+ let requirements = codex_home.path().join("requirements.toml");
+ let rules = "allowed_approval_policies=[\"untrusted\"]\nallowed_sandbox_modes=[\"read-only\"]";
+ fs::write(&requirements, rules)?;
+ fs::create_dir_all(unknown.join(".git"))?;
+ for dir in [&trusted, &untrusted, &mismatch, &failed] {
+ let trust = [T::Trusted, T::Untrusted][usize::from(dir == &untrusted)];
+ crate::legacy_core::config::set_project_trust_level(codex_home.path(), dir, trust)
+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;
+ }
+ app.config.cwd = current.clone().abs();
+ app.chat_widget
+ .handle_thread_session_quiet(test_thread_session(ThreadId::new(), current.clone()));
+ let (no_list, nick, role, runtime, background) = (None, None, None, None, Some("background"));
+ let (mut server, requests, proxy) =
+ start_recording_app_server(&app.config, no_list, background).await?;
+ let (rec, plain, req) = (recorded_params, crate::key_hint::plain, &requests);
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ let (source, message, name) = (None, None, Some("Previous project".to_string()));
+ app.start_fresh_session_with_summary_hint(&mut tui, &mut server, source, message, name)
+ .await;
+ let original = app.chat_widget.thread_id().expect("original thread");
+ let rollout = app.chat_widget.rollout_path().expect("original rollout");
+ let json = r#"{"type":"message","role":"assistant","content":[{"type":"output_text","text":"saved history"}]}"#;
+ let item = serde_json::from_str(json)?;
+ server.thread_inject_items(original, vec![item]).await?;
+ let tracked = server.start_thread(&app.config).await?;
+ let (child, capacity) = (tracked.session.thread_id, THREAD_EVENT_CHANNEL_CAPACITY);
+ let channel = ThreadEventChannel::new_with_session(capacity, tracked.session, tracked.turns);
+ app.thread_event_channels.insert(child, channel);
+ app.agent_navigation
+ .upsert(child, nick, role, /*is_closed*/ false);
+ let store = app.thread_event_channels[&child].store.clone();
+ let config_path = codex_home.path().join("config.toml");
+ let original_user_config = fs::read_to_string(&config_path).ok();
+ let (local, url) = (app.environment_manager.clone(), Some("ws://[::1]".into()));
+ let remote = Arc::new(EnvironmentManager::create_for_tests(url, runtime).await);
+ let mut history = || {
+ std::iter::from_fn(|| events.try_recv().ok())
+ .filter_map(|event| match event {
+ AppEvent::InsertHistoryCell(cell) => Some(cell),
+ _ => None,
+ })
+ .map(|cell| lines_to_single_string(&cell.display_lines(/*width*/ 200)))
+ .collect::<Vec<_>>()
+ };
+ let change = |thread_id, path: &str| AppEvent::ChangeWorkingDirectory {
+ thread_id,
+ requested_cwd: path.into(),
+ };
+ for (path, kind, expected) in [
+ ("missing", "local", "Cannot access directory"),
+ ("../config.toml", "local", "Not a directory"),
+ (r"C:\bad", "workspace", "not supported for remote"),
+ ("~", "executor", "not supported for remote"),
+ ("../trusted", "stale", "requires an idle primary session"),
+ ("../trusted", "running", "another agent is running"),
+ ("../trusted", "active", "another agent is running"),
+ ("../trusted", "mcp", "inventory is still loading"),
+ ("../trusted", "approval", "approval policy override"),
+ ("../trusted", "profile", "permission profile override"),
+ ("../trusted", "reviewer", "reviewer"),
+ ("../p", "named", "different settings"),
+ ("../p", "keymap", "open_transcript"),
+ ("../unknown", "local", "This directory is not trusted"),
+ ("../trusted", "main", "background terminals"),
+ ("../trusted", "child", "background terminals"),
+ ] {
+ app.config.approvals_reviewer = ApprovalsReviewer::User;
+ if kind == "reviewer" {
+ app.config.approvals_reviewer = ApprovalsReviewer::AutoReview;
+ fs::write(&requirements, "allowed_approvals_reviewers = [\"user\"]")?;
+ }
+ app.agent_navigation.set_running(child, kind == "running");
+ store.lock().await.active_turn_id = (kind == "active").then(|| "active".into());
+ app.loader_overrides.system_requirements_path =
+ matches!(kind, "approval" | "profile" | "reviewer").then_some(requirements.clone());
+ app.harness_overrides.permission_profile =
+ (kind != "named").then_some(PermissionProfile::workspace_write());
+ app.runtime_approval_policy_override =
+ (kind == "approval").then_some(AskForApproval::OnRequest);
+ let mut profile = RuntimePermissionProfileOverride::from_config(&app.config);
+ profile.active_permission_profile =
+ (kind == "named").then(|| ActivePermissionProfile::new("dev"));
+ app.runtime_permission_profile_override =
+ matches!(kind, "profile" | "reviewer" | "named").then_some(profile);
+ app.app_server_target = crate::AppServerTarget::Embedded;
+ if kind == "workspace" {
+ let endpoint = crate::resolve_remote_addr("ws://127.0.0.1:8765")?;
+ app.app_server_target = crate::AppServerTarget::Remote { endpoint };
+ }
+ app.environment_manager = [&local, &remote][usize::from(kind == "executor")].clone();
+ requests.lock().expect("request recorder lock").clear();
+ if kind == "mcp" {
+ let loading = history_cell::new_mcp_inventory_loading;
+ app.transcript_cells
+ .push(Arc::new(loading(/*animations_enabled*/ false)));
+ } else if kind == "child" {
+ app.thread_event_channels.remove(&child);
+ }
+ let thread_id = [original, ThreadId::new()][usize::from(kind == "stale")];
+ app.handle_event(&mut tui, &mut server, change(thread_id, path))
+ .await?;
+ assert_eq!(app.chat_widget.thread_id(), Some(original));
+ assert_eq!(app.config.cwd, current.clone().abs());
+ assert!(app.runtime_working_directory_override.is_none());
+ let count = requests.lock().expect("request recorder lock").len();
+ let checked = usize::from(kind == "main") + 2 * usize::from(kind == "child");
+ assert_eq!(count, checked, "{kind}");
+ let listed = recorded_params(&requests, "thread/backgroundTerminals/list");
+ let mut ids = listed.iter().zip([original, child]);
+ assert!(ids.all(|(p, id)| p["threadId"] == id.to_string()));
+ assert_eq!(fs::read_to_string(&config_path).ok(), original_user_config);
+ let output = history().join("");
+ if kind == "mcp" {
+ assert_snapshot!(output, @"■ MCP inventory is still loading.");
+ }
+ assert!(output.contains(expected), "{path}");
+ app.clear_committed_mcp_inventory_loading();
+ }
+ app.set_approvals_reviewer_in_app_and_widget(ApprovalsReviewer::AutoReview);
+ app.runtime_permission_profile_override =
+ Some(RuntimePermissionProfileOverride::from_config(&app.config));
+ for (path, expected) in [(&failed, 0), (&trusted, 2)] {
+ requests.lock().expect("request recorder lock").clear();
+ app.change_working_directory(&mut tui, &mut server, path.clone().abs())
+ .await;
+ assert_eq!(app.chat_widget.thread_id(), Some(original));
+ assert_eq!(app.config.cwd, current.clone().abs());
+ assert_eq!(rec(&requests, "thread/unsubscribe").len(), expected);
+ assert!(history().join("").contains("change"));
+ }
+ let removed = recorded_params(&requests, "thread/unsubscribe");
+ let archived = recorded_params(&requests, "thread/archive");
+ assert_eq!(removed[0]["threadId"], original.to_string());
+ assert_eq!(archived[0]["threadId"], removed[1]["threadId"]);
+ requests.lock().expect("request recorder lock").clear();
+ app.handle_event(&mut tui, &mut server, change(original, "../trusted"))
+ .await?;
+ let forked = app.chat_widget.thread_id().expect("forked thread");
+ assert_ne!(forked, original);
+ let forked_rollout = app.chat_widget.rollout_path().expect("forked rollout");
+ assert!(fs::read_to_string(&rollout)?.contains("saved history"));
+ let copied = fs::read_to_string(&forked_rollout)?;
+ let meta = codex_rollout::read_session_meta_line(&forked_rollout).await?;
+ let base = meta.meta.history_base;
+ assert!(copied.contains("saved history") || base.is_some_and(|h| h.thread_id == original));
+ assert_eq!(app.config.cwd, trusted.clone().abs());
+ let configured = app.primary_session_configured.as_ref().expect("session");
+ let source = codex_utils_path_uri::PathUri::from_abs_path(&agents.abs());
+ assert!(configured.instruction_source_paths.contains(&source));
+ let (cwd, result) = (current.clone(), Err("stale skills".into()));
+ let skills = AppEvent::SkillsListLoaded { cwd, result };
+ let (cwd, plugins) = (current.clone(), Some(vec![]));
+ let plugins = AppEvent::PluginMentionsLoaded { cwd, plugins };
+ let diff = AppEvent::DiffResult(current.clone(), "stale diff".to_string());
+ let branch = AppEvent::SyncThreadGitBranch {
+ thread_id: original,
+ branch: "stale".to_string(),
+ cwd: current.clone(),
+ };
+ for event in [diff, skills, plugins, branch] {
+ app.handle_event(&mut tui, &mut server, event).await?;
+ }
+ let path = trusted.to_str().expect("trusted path");
+ let output = history().join("").replace(path, "<PROJECT>");
+ let message = &output[output.rfind('•').expect("change")..];
+ assert_snapshot!(message, @"• Working directory changed to: <PROJECT>");
+ assert!(!output.contains("stale skills"));
+ assert!(app.overlay.is_none());
+ assert_eq!(app.keymap.app.open_transcript, vec![plain(KeyCode::F(12))]);
+ let anchor = app.runtime_working_directory_override.as_deref();
+ assert_eq!(anchor, Some(trusted.as_path()));
+ let effort = app.chat_widget.current_reasoning_effort();
+ assert_eq!(effort, Some(ReasoningEffortConfig::High));
+ let approval = app.config.permissions.approval_policy.value();
+ assert_eq!(approval, AskForApproval::OnRequest.to_core());
+ let forks = recorded_params(&requests, "thread/fork");
+ assert_eq!(forks.len(), 1);
+ let params = &forks[0];
+ assert_eq!(params["threadId"], serde_json::json!(original.to_string()));
+ assert_eq!(params["cwd"], serde_json::json!(trusted));
+ assert_eq!(params["approvalsReviewer"].as_str(), Some("auto_review"));
+ assert_eq!(params["developerInstructions"], "destination policy");
+ assert_eq!(params["deferGoalContinuation"], serde_json::json!(true));
+ assert_eq!(&params["runtimeWorkspaceRoots"], &json!([trusted]));
+ assert_eq!(rec(&requests, "hooks/list")[0]["cwds"], json!([trusted]));
+ for suffix in "start resume settings/update archive".split(' ') {
+ assert!(recorded_params(&requests, &format!("thread/{suffix}")).is_empty());
+ }
+ assert!(rec(req, "thread/metadata/update")[0]["threadId"] == params["threadId"]);
+ let removed = recorded_params(&requests, "thread/unsubscribe");
+ assert_eq!(removed.len(), 2);
+ let found = |id: ThreadId| removed.iter().any(|p| p["threadId"] == id.to_string());
+ assert!([original, child].into_iter().all(found));
+ let retained = server.thread_read(original, /*include_turns*/ false);
+ assert_eq!(retained.await?.cwd, current.abs().canonicalize()?);
+ assert_eq!(app.chat_widget.config_ref().cwd, trusted.clone().abs());
+ assert!(render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("SessionStart"));
+ app.chat_widget
+ .handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
+ app.harness_overrides.bypass_hook_trust = Some(true);
+ requests.lock().expect("request recorder lock").clear();
+ app.change_working_directory(&mut tui, &mut server, trusted.abs())
+ .await;
+ assert!(app.config.bypass_hook_trust && !app.chat_widget.has_active_view());
+ assert!(recorded_params(&requests, "hooks/list").is_empty());
+ app.harness_overrides.bypass_hook_trust = None;
+ requests.lock().expect("request recorder lock").clear();
+ app.change_working_directory(&mut tui, &mut server, untrusted.clone().abs())
+ .await;
+ assert_eq!(app.config.active_project.trust_level, Some(T::Untrusted));
+ let approval = app.config.permissions.approval_policy.value();
+ assert_eq!(approval, AskForApproval::UnlessTrusted.to_core());
+ assert_eq!(rec(req, "thread/fork")[0]["approvalPolicy"], "untrusted");
+ let warning = "Project-local config, hooks, and exec policies are disabled";
+ assert!(history().iter().any(|line| line.contains(warning)));
+ server.shutdown().await?;
+ proxy.await??;
+ Ok(())
+}
+
#[test]
fn fresh_session_applies_requested_name() -> Result<()> {
const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
diff --git a/codex-rs/tui/src/app/working_directory.rs b/codex-rs/tui/src/app/working_directory.rs
new file mode 100644
index 0000000000..7f4dad99b8
--- /dev/null
+++ b/codex-rs/tui/src/app/working_directory.rs
@@ -0,0 +1,196 @@
+//! Local working-directory changes that preserve conversation history.
+
+use super::session_lifecycle::ThreadAttachPresentation;
+use super::*;
+use crate::app_server_session::ForkGoalContinuation::DeferUntilNextTurn;
+use crate::history_cell::McpInventoryLoadingCell as LoadingCell;
+use codex_app_server_protocol::ThreadBackgroundTerminalsListParams;
+use codex_app_server_protocol::ThreadBackgroundTerminalsListResponse as ListResponse;
+
+impl App {
+ fn working_directory_error(&mut self, message: impl Into<String>) {
+ self.chat_widget.add_error_message(message.into());
+ }
+
+ pub(super) async fn change_working_directory(
+ &mut self,
+ tui: &mut tui::Tui,
+ app_server: &mut AppServerSession,
+ cwd: AbsolutePathBuf,
+ ) {
+ if self.config.ephemeral || !cwd.as_path().is_dir() {
+ return self.working_directory_error("This task cannot be safely replaced.");
+ }
+ let Some(thread_id) = self.chat_widget.thread_id() else {
+ return;
+ };
+ let cells = &self.transcript_cells;
+ if cells.iter().any(|cell| cell.as_any().is::<LoadingCell>()) {
+ return self.working_directory_error("MCP inventory is still loading.");
+ }
+ let agents = self.agent_navigation.ordered_threads();
+ let active = self.thread_event_channels.iter().any(|(id, channel)| {
+ let store = channel.store.try_lock();
+ *id != thread_id && !store.is_ok_and(|store| store.active_turn_id().is_none())
+ });
+ if active || agents.iter().any(|(t, a)| *t != thread_id && a.is_running) {
+ return self.working_directory_error("Cannot change: another agent is running.");
+ }
+ let mut config = match self.rebuild_config_for_cwd(cwd.to_path_buf()).await {
+ Ok(config) => config,
+ Err(err) => return self.working_directory_error(format!("Cannot load {cwd:?}: {err}")),
+ };
+ if config.active_project.trust_level.is_none() {
+ return self.working_directory_error("This directory is not trusted; run Codex there.");
+ }
+ if let Some(profile) = self.runtime_permission_profile_override.as_ref()
+ && profile.active_permission_profile.is_some()
+ && (RuntimePermissionProfileOverride::from_config(&config) != *profile
+ || config.permissions.profile_workspace_roots()
+ != self.config.permissions.profile_workspace_roots())
+ {
+ return self.working_directory_error("Permission profile has different settings.");
+ }
+ self.apply_runtime_policy_overrides(&mut config);
+ if self.runtime_permission_profile_override.is_some() {
+ let reviewer = self.config.approvals_reviewer;
+ let reviewers = &config.config_layer_stack.requirements().approvals_reviewer;
+ if let Err(error) = reviewers.can_set(&reviewer) {
+ return self.working_directory_error(format!("Approvals reviewer: {error}"));
+ }
+ config.approvals_reviewer = reviewer;
+ }
+ let actual = config.permissions.approval_policy.value();
+ let snapshot = RuntimePermissionProfileOverride::from_config(&config);
+ let approval = self.runtime_approval_policy_override;
+ let profile = self.runtime_permission_profile_override.as_ref();
+ if approval.is_some_and(|p| actual != p.to_core())
+ || profile.is_some_and(|p| snapshot != *p)
+ {
+ return;
+ }
+ let keymap = match RuntimeKeymap::from_config(&config.tui_keymap) {
+ Ok(keymap) => keymap,
+ Err(error) => return self.chat_widget.add_error_message(error),
+ };
+ config.service_tier = self.chat_widget.configured_service_tier();
+ 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
+ && (!self.chat_widget.token_usage().is_zero()
+ || channels.get(&thread_id).is_some_and(|channel| {
+ channel.store.try_lock().map_or(/*default*/ true, |store| {
+ !store.turns.is_empty()
+ || store.buffer.iter().any(|event| {
+ matches!(
+ event,
+ ThreadBufferedEvent::Notification(notification)
+ if matches!(notification.as_ref(),
+ ServerNotification::TurnStarted(_)
+ | ServerNotification::TurnCompleted(_))
+ )
+ })
+ })
+ }))
+ {
+ return self.working_directory_error("Conversation history is not saved.");
+ }
+ let mut ids: HashSet<_> = channels.keys().copied().collect();
+ for (id, agent) in self.agent_navigation.ordered_threads() {
+ ids.extend((!agent.is_closed).then_some(id));
+ }
+ let descendants = ids.iter().copied().filter(|id| *id != thread_id);
+ for tracked_id in std::iter::once(thread_id).chain(descendants) {
+ let request = ClientRequest::ThreadBackgroundTerminalsList {
+ request_id: app_server.next_request_id(),
+ params: ThreadBackgroundTerminalsListParams {
+ thread_id: tracked_id.to_string(),
+ cursor: None,
+ limit: Some(1),
+ },
+ };
+ let handle = app_server.request_handle();
+ let result = handle.request_typed::<ListResponse>(request).await;
+ if !matches!(result, Ok(response) if response.data.is_empty()) {
+ return self.working_directory_error("Active background terminals block /cd.");
+ }
+ }
+ let transitioned = if has_rollout {
+ app_server
+ .fork_thread_at(
+ config.clone(),
+ thread_id,
+ /*last_turn_id*/ None,
+ /*before_turn_id*/ None,
+ DeferUntilNextTurn,
+ )
+ .await
+ } else {
+ app_server
+ .start_thread_with_session_start_source(&config, /*session_start_source*/ None)
+ .await
+ };
+ let transitioned = match transitioned {
+ Ok(value) => value,
+ Err(e) => return self.working_directory_error(format!("Failed to change: {e}")),
+ };
+ let session = &transitioned.session;
+ if session.thread_id == thread_id
+ || crate::session_resume::cwds_differ(session.cwd.as_path(), cwd.as_path())
+ || session.runtime_workspace_roots != config.workspace_roots
+ || session.approval_policy.to_core() != config.permissions.approval_policy.value()
+ || session.approvals_reviewer != config.approvals_reviewer
+ || session.active_permission_profile != config.permissions.active_permission_profile()
+ {
+ if session.thread_id != thread_id {
+ let _ = app_server.thread_unsubscribe(session.thread_id).await;
+ if has_rollout {
+ let _ = app_server.thread_archive(session.thread_id).await;
+ }
+ }
+ return self.working_directory_error("Requested directory or permissions not applied.");
+ }
+ 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 {
+ let _ = app_server.thread_archive(replacement_id).await;
+ }
+ return self.working_directory_error(format!("Cannot change directories: {error}"));
+ }
+ for tracked_id in ids.into_iter().filter(|id| *id != thread_id) {
+ if let Err(error) = app_server.thread_unsubscribe(tracked_id).await {
+ tracing::warn!("failed to unsubscribe tracked thread {tracked_id}: {error}");
+ }
+ }
+ self.config = config;
+ self.file_search
+ .update_search_dir(self.config.cwd.to_path_buf());
+ let notify = &self.config.tui_notifications;
+ tui.set_notification_settings(notify.method, notify.condition);
+ if let Err(error) = tui.clear_ambient_pet_image() {
+ tracing::warn!(%error, "failed to clear ambient pet image");
+ }
+ let attach = App::replace_chat_widget_with_app_server_thread;
+ let (lineage, message) = (ThreadAttachPresentation::SessionLineage, None);
+ if let Err(error) = attach(self, tui, transitioned, lineage, message).await {
+ return self.working_directory_error(format!("Could not restore session: {error}"));
+ }
+ self.cancel_pending_key_chord();
+ self.keymap = keymap;
+ self.restore_runtime_theme_from_config();
+ self.runtime_working_directory_override = Some(cwd.to_path_buf());
+ emit_project_config_warnings(&self.app_event_tx, &self.config);
+ let message = format!("Working directory changed to: {}", cwd.display());
+ self.chat_widget.add_info_message(message, /*hint*/ None);
+ if !self.config.bypass_hook_trust {
+ let load_review = crate::startup_hooks_review::load_startup_hooks_review_entry;
+ let hooks = load_review(app_server.request_handle(), cwd.to_path_buf()).await;
+ if hooks.hooks.iter().any(crate::hooks_rpc::hook_needs_review) {
+ self.chat_widget.open_hooks_browser(hooks);
+ }
+ }
+ tui.frame_requester().schedule_frame();
+ }
+}
diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs
index 6fde0759d6..8b7f6fe901 100644
--- a/codex-rs/tui/src/app_event.rs
+++ b/codex-rs/tui/src/app_event.rs
@@ -263,6 +263,7 @@ pub(crate) enum AppEvent {
SyncThreadGitBranch {
thread_id: ThreadId,
branch: String,
+ cwd: PathBuf,
},
/// Fetch a persistent cross-session message history entry by offset.
@@ -284,6 +285,12 @@ pub(crate) enum AppEvent {
name: Option<String>,
},
+ /// Change the working directory of the originating idle primary thread.
+ ChangeWorkingDirectory {
+ thread_id: ThreadId,
+ requested_cwd: PathBuf,
+ },
+
/// Result of the fresh startup thread that is attached after the input UI is live.
StartupThreadStarted {
result: Result<AppServerStartedThread, String>,
@@ -504,7 +511,7 @@ pub(crate) enum AppEvent {
},
/// Result of computing a `/diff` command.
- DiffResult(String),
+ DiffResult(PathBuf, String),
/// Open the app link view in the bottom pane.
OpenAppLink {
@@ -748,6 +755,7 @@ pub(crate) enum AppEvent {
/// Result of refreshing plugin mention bindings.
PluginMentionsLoaded {
+ cwd: PathBuf,
plugins: Option<Vec<PluginCapabilitySummary>>,
},
@@ -778,6 +786,7 @@ pub(crate) enum AppEvent {
/// command path because those callers expect the visible skill state to be current when their command
/// completes.
SkillsListLoaded {
+ cwd: PathBuf,
result: Result<SkillsListResponse, String>,
},
diff --git a/codex-rs/tui/src/bottom_pane/slash_commands.rs b/codex-rs/tui/src/bottom_pane/slash_commands.rs
index 139990e40f..9d165445f1 100644
--- a/codex-rs/tui/src/bottom_pane/slash_commands.rs
+++ b/codex-rs/tui/src/bottom_pane/slash_commands.rs
@@ -309,6 +309,7 @@ mod tests {
SlashCommand::Diff,
SlashCommand::Mention,
SlashCommand::Status,
+ SlashCommand::Pwd,
SlashCommand::Usage,
]
);
diff --git a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap
index f7c45aec63..3e1d02c211 100644
--- a/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap
+++ b/codex-rs/tui/src/bottom_pane/snapshots/codex_tui__bottom_pane__command_popup__tests__command_popup_default_items.snap
@@ -31,6 +31,8 @@ expression: commands
/diff - show git diff (including untracked files)
/mention - mention a file
/status - show current session configuration and token usage
+/cd - change the current working directory
+/pwd - show the current working directory
/title - configure which items appear in the terminal title
/statusline - configure which items appear in the status line
/theme - choose a syntax highlighting theme
diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs
index 2e31278911..754c651d82 100644
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -438,6 +438,7 @@ mod turn_runtime;
use self::turn_lifecycle::TurnLifecycleState;
mod usage;
mod user_messages;
+mod working_directory;
use self::user_messages::PendingSteer;
use self::user_messages::PendingSteerCompareKey;
use self::user_messages::QueueDrain;
diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
index fafe2e079b..da5943b5d5 100644
--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs
+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
@@ -138,7 +138,7 @@ impl ChatWidget {
|| (self.bottom_pane.is_task_running()
&& (self.mcp_startup_status.is_none()
|| self.input_queue.user_turn_pending_start))))
- || (cmd == SlashCommand::Resume
+ || (matches!(cmd, SlashCommand::Resume | SlashCommand::Cd)
&& (self.input_queue.user_turn_pending_start
|| self.turn_lifecycle.agent_turn_running))
|| (cmd == SlashCommand::Export && self.input_queue.suppress_queue_autosend)
@@ -430,7 +430,7 @@ impl ChatWidget {
None => "Failed to compute diff: workspace command runner unavailable"
.to_string(),
};
- tx.send(AppEvent::DiffResult(text));
+ tx.send(AppEvent::DiffResult(cwd, text));
});
}
SlashCommand::Mention => {
@@ -461,6 +461,15 @@ impl ChatWidget {
);
}
}
+ SlashCommand::Cd => {
+ self.dispatch_command_with_args(SlashCommand::Cd, "~".to_string(), Vec::new());
+ }
+ SlashCommand::Pwd => {
+ self.add_info_message(
+ format!("Current working directory: {}", self.config.cwd.display()),
+ /*hint*/ None,
+ );
+ }
SlashCommand::Usage => {
if self.ensure_usage_command_available() {
self.open_usage_menu();
@@ -694,6 +703,10 @@ impl ChatWidget {
),
});
}
+ SlashCommand::Cd => self.request_working_directory_change(trimmed),
+ SlashCommand::Pwd => {
+ self.add_error_message("Usage: /pwd".to_string());
+ }
SlashCommand::Usage => {
if self.ensure_usage_command_available() {
match tokens::TokenActivityView::parse(trimmed) {
@@ -1085,6 +1098,7 @@ impl ChatWidget {
match cmd {
SlashCommand::Ide
| SlashCommand::Status
+ | SlashCommand::Pwd
| SlashCommand::Usage
| SlashCommand::DebugConfig
| SlashCommand::Ps
@@ -1102,6 +1116,10 @@ impl ChatWidget {
| SlashCommand::App
| SlashCommand::Rename
| SlashCommand::TestApproval => QueueDrain::Continue,
+ SlashCommand::Cd => match self.thread_id {
+ Some(thread_id) if self.can_change_working_directory(thread_id) => QueueDrain::Stop,
+ _ => QueueDrain::Continue,
+ },
SlashCommand::Feedback
| SlashCommand::Export
| SlashCommand::New
diff --git a/codex-rs/tui/src/chatwidget/streaming.rs b/codex-rs/tui/src/chatwidget/streaming.rs
index dcccbd027f..9c19a93d22 100644
--- a/codex-rs/tui/src/chatwidget/streaming.rs
+++ b/codex-rs/tui/src/chatwidget/streaming.rs
@@ -338,13 +338,18 @@ impl ChatWidget {
&& let Some(thread_id) = self.thread_id
&& let Some(runner) = self.workspace_command_runner.clone()
{
- let cwd = PathBuf::from(cwd);
+ let branch_cwd = PathBuf::from(cwd);
+ let cwd = self.config.cwd.to_path_buf();
let tx = self.app_event_tx.clone();
tokio::spawn(async move {
if let Some(branch) =
- crate::branch_summary::current_branch_name(runner.as_ref(), &cwd).await
+ crate::branch_summary::current_branch_name(runner.as_ref(), &branch_cwd).await
{
- tx.send(AppEvent::SyncThreadGitBranch { thread_id, branch });
+ tx.send(AppEvent::SyncThreadGitBranch {
+ thread_id,
+ branch,
+ cwd,
+ });
}
});
}
diff --git a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs
index bb62505808..2997c0a24e 100644
--- a/codex-rs/tui/src/chatwidget/tests/slash_commands.rs
+++ b/codex-rs/tui/src/chatwidget/tests/slash_commands.rs
@@ -2635,6 +2635,109 @@ async fn slash_app_without_thread_id_shows_starting_error() {
);
}
+#[tokio::test]
+async fn slash_pwd_and_cwd_alias_display_current_working_directory_from_composer() {
+ let mut output = Vec::new();
+ for (command, side) in [("/pwd", false), ("/cwd", true), ("/pwd x", false)] {
+ let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.set_side_conversation_active(side);
+ chat.bottom_pane.set_task_running(!side);
+ chat.bottom_pane
+ .set_composer_text(command.to_string(), Vec::new(), Vec::new());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));
+ let [cell]: [_; 1] = drain_insert_history(&mut rx).try_into().expect("one cell");
+ output.push(normalize_snapshot_paths(lines_to_single_string(&cell)));
+ }
+ insta::assert_snapshot!(output.join(""), @r"
+• Current working directory: /tmp/project
+• Current working directory: /tmp/project
+■ Usage: /pwd
+");
+}
+
+#[tokio::test]
+async fn slash_cd_changes_current_session_after_replay_and_defaults_to_home() {
+ let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ let thread_id = ThreadId::new();
+ chat.thread_id = Some(thread_id);
+ chat.thread_name = Some("Completed task".to_string());
+ chat.forked_from = Some(ThreadId::new());
+ let (status, duration, error) = (AppServerTurnStatus::Completed, None, None);
+ let turn = app_server_turn("turn-1", status, duration, error);
+ chat.replay_thread_turns(vec![turn], ReplayKind::ResumeInitialMessages);
+ drain_insert_history(&mut rx);
+ assert!(!chat.can_change_working_directory(ThreadId::new()));
+ let drain = chat.submit_queued_slash_prompt(UserMessage::from("/cd /tmp").into());
+ assert_eq!(drain, QueueDrain::Stop);
+ chat.bottom_pane
+ .set_composer_text("/cd".to_string(), Vec::new(), Vec::new());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ for expected in ["/tmp", "~"] {
+ assert_matches!(
+ rx.try_recv(),
+ Ok(AppEvent::ChangeWorkingDirectory { thread_id: actual, requested_cwd })
+ if actual == thread_id && requested_cwd == std::path::Path::new(expected)
+ );
+ }
+ assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));
+}
+
+#[tokio::test]
+async fn rejected_queued_cd_drains_following_input() {
+ 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");
+ queue_composer_text_with_tab(&mut chat, "/cd /tmp");
+ queue_composer_text_with_tab(&mut chat, "follow-up");
+ complete_turn_with_message(&mut chat, "turn-1", /*message*/ None);
+ assert_matches!(next_submit_op(&mut op_rx), Op::UserTurn { .. });
+ assert!(chat.input_queue.queued_user_messages.is_empty());
+ while let Ok(event) = rx.try_recv() {
+ assert!(!matches!(event, AppEvent::ChangeWorkingDirectory { .. }));
+ }
+}
+
+#[tokio::test]
+async fn slash_cd_rejects_pending_input_and_unsupported_session_ownership() {
+ let mut errors = Vec::new();
+ for state in "new active pending queued steer side owned ephemeral mcp exec".split(' ') {
+ let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = (state != "new").then(ThreadId::new);
+ let (queued, steer) = (UserMessage::from("q").into(), pending_steer("s"));
+ match state {
+ "active" => chat.bottom_pane.set_task_running(/*running*/ true),
+ "pending" => chat.input_queue.user_turn_pending_start = true,
+ "queued" => chat.input_queue.queued_user_messages.push_back(queued),
+ "steer" => chat.input_queue.pending_steers.push_back(steer),
+ "side" => chat.set_side_conversation_active(/*active*/ true),
+ "owned" => chat.set_parent_owned_thread(),
+ "ephemeral" => chat.config.ephemeral = true,
+ "exec" => chat.track_unified_exec_process_begin("call", Some("process"), "sleep"),
+ "mcp" => {
+ let cell =
+ history_cell::new_mcp_inventory_loading(/*animations_enabled*/ false);
+ chat.transcript.active_cell = Some(Box::new(cell));
+ }
+ _ => {}
+ }
+
+ chat.dispatch_command_with_args(SlashCommand::Cd, "/tmp".to_string(), Vec::new());
+
+ assert!(state != "mcp" || chat.transcript.active_cell.is_some());
+ assert_matches!(op_rx.try_recv(), Err(TryRecvError::Empty));
+ let Ok(AppEvent::InsertHistoryCell(cell)) = rx.try_recv() else {
+ unreachable!("missing error for {state}");
+ };
+ errors.push(lines_to_single_string(&cell.display_lines(/*width*/ 200)));
+ assert!(rx.try_recv().is_err(), "{state}");
+ }
+ insta::assert_snapshot!(format!("{}{}", errors[0], errors[3]), @r"
+■ The session must start before you can change its working directory.
+■ Changing directories requires an idle primary session without queued input.
+");
+}
+
#[tokio::test]
async fn slash_rollout_displays_current_path() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
diff --git a/codex-rs/tui/src/chatwidget/working_directory.rs b/codex-rs/tui/src/chatwidget/working_directory.rs
new file mode 100644
index 0000000000..27e5322184
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/working_directory.rs
@@ -0,0 +1,47 @@
+//! Working-directory slash commands for the current local session.
+
+use super::*;
+use crate::history_cell::McpInventoryLoadingCell;
+
+impl ChatWidget {
+ pub(crate) fn can_change_working_directory(&self, thread_id: ThreadId) -> bool {
+ let active = &self.transcript.active_cell;
+ self.thread_id == Some(thread_id)
+ && !self.active_side_conversation
+ && !self.blocks_direct_input
+ && !self.config.ephemeral
+ && self.unified_exec_processes.is_empty()
+ && !self.is_user_turn_pending_or_running()
+ && !self.input_queue.has_queued_follow_up_messages()
+ && self.input_queue.pending_steers.is_empty()
+ && active
+ .as_ref()
+ .is_none_or(|cell| !cell.as_any().is::<McpInventoryLoadingCell>())
+ }
+
+ pub(super) fn request_working_directory_change(&mut self, path: &str) {
+ if !self.is_session_configured() {
+ self.add_error_message(
+ "The session must start before you can change its working directory.".to_string(),
+ );
+ return;
+ }
+
+ let Some(thread_id) = self.thread_id else {
+ return;
+ };
+ if !self.can_change_working_directory(thread_id) {
+ let message =
+ "Changing directories requires an idle primary session without queued input.";
+ self.app_event_tx.send(AppEvent::InsertHistoryCell(Box::new(
+ history_cell::new_error_event(message.to_string()),
+ )));
+ return;
+ }
+
+ self.app_event_tx.send(AppEvent::ChangeWorkingDirectory {
+ thread_id,
+ requested_cwd: PathBuf::from(path),
+ });
+ }
+}
diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rs
index b369870346..5a00072f15 100644
--- a/codex-rs/tui/src/slash_command.rs
+++ b/codex-rs/tui/src/slash_command.rs
@@ -49,6 +49,9 @@ pub enum SlashCommand {
Diff,
Mention,
Status,
+ Cd,
+ #[strum(to_string = "pwd", serialize = "cwd")]
+ Pwd,
Usage,
DebugConfig,
Title,
@@ -105,6 +108,8 @@ impl SlashCommand {
SlashCommand::Import => "import setup, this project, and recent chats from Claude Code",
SlashCommand::Hooks => "view and manage lifecycle hooks",
SlashCommand::Status => "show current session configuration and token usage",
+ SlashCommand::Cd => "change the current working directory",
+ SlashCommand::Pwd => "show the current working directory",
SlashCommand::Usage => "view account usage or use a usage limit reset",
SlashCommand::DebugConfig => "show config layers and requirement sources for debugging",
SlashCommand::Title => "configure which items appear in the terminal title",
@@ -167,6 +172,8 @@ impl SlashCommand {
| SlashCommand::Mcp
| SlashCommand::Export
| SlashCommand::Raw
+ | SlashCommand::Cd
+ | SlashCommand::Pwd
| SlashCommand::Usage
| SlashCommand::Pets
| SlashCommand::Side
@@ -186,6 +193,7 @@ impl SlashCommand {
| SlashCommand::Diff
| SlashCommand::Mention
| SlashCommand::Status
+ | SlashCommand::Pwd
| SlashCommand::Usage
| SlashCommand::Ide
)
@@ -210,6 +218,7 @@ impl SlashCommand {
| SlashCommand::Import
| SlashCommand::Review
| SlashCommand::Plan
+ | SlashCommand::Cd
| SlashCommand::Clear
| SlashCommand::Logout
| SlashCommand::MemoryDrop
@@ -226,6 +235,7 @@ impl SlashCommand {
| SlashCommand::Skills
| SlashCommand::Hooks
| SlashCommand::Status
+ | SlashCommand::Pwd
| SlashCommand::Usage
| SlashCommand::DebugConfig
| SlashCommand::Ps