Spread AbsolutePathBuf (#17792)

Mechanical change to promote absolute paths through code.

codex-rs/core/src/tools/events.rs

@@ -18,8 +18,8 @@ use codex_protocol::protocol::PatchApplyEndEvent;
 use codex_protocol::protocol::PatchApplyStatus;
 use codex_protocol::protocol::TurnDiffEvent;
 use codex_shell_command::parse_command::parse_command;
+use codex_utils_absolute_path::AbsolutePathBuf;
 use std::collections::HashMap;
-use std::path::Path;
 use std::path::PathBuf;
 use std::time::Duration;
 
@@ -64,7 +64,7 @@ pub(crate) enum ToolEventFailure {
 pub(crate) async fn emit_exec_command_begin(
     ctx: ToolEventCtx<'_>,
     command: &[String],
-    cwd: &Path,
+    cwd: &AbsolutePathBuf,
     parsed_cmd: &[ParsedCommand],
     source: ExecCommandSource,
     interaction_input: Option<String>,
@@ -78,7 +78,7 @@ pub(crate) async fn emit_exec_command_begin(
                 process_id: process_id.map(str::to_owned),
                 turn_id: ctx.turn.sub_id.clone(),
                 command: command.to_vec(),
-                cwd: cwd.to_path_buf(),
+                cwd: cwd.clone(),
                 parsed_cmd: parsed_cmd.to_vec(),
                 source,
                 interaction_input,
@@ -90,7 +90,7 @@ pub(crate) async fn emit_exec_command_begin(
 pub(crate) enum ToolEmitter {
     Shell {
         command: Vec<String>,
-        cwd: PathBuf,
+        cwd: AbsolutePathBuf,
         source: ExecCommandSource,
         parsed_cmd: Vec<ParsedCommand>,
         freeform: bool,
@@ -101,7 +101,7 @@ pub(crate) enum ToolEmitter {
     },
     UnifiedExec {
         command: Vec<String>,
-        cwd: PathBuf,
+        cwd: AbsolutePathBuf,
         source: ExecCommandSource,
         parsed_cmd: Vec<ParsedCommand>,
         process_id: Option<String>,
@@ -111,7 +111,7 @@ pub(crate) enum ToolEmitter {
 impl ToolEmitter {
     pub fn shell(
         command: Vec<String>,
-        cwd: PathBuf,
+        cwd: AbsolutePathBuf,
         source: ExecCommandSource,
         freeform: bool,
     ) -> Self {
@@ -134,7 +134,7 @@ impl ToolEmitter {
 
     pub fn unified_exec(
         command: &[String],
-        cwd: PathBuf,
+        cwd: AbsolutePathBuf,
         source: ExecCommandSource,
         process_id: Option<String>,
     ) -> Self {
@@ -163,11 +163,7 @@ impl ToolEmitter {
                 emit_exec_stage(
                     ctx,
                     ExecCommandInput::new(
-                        command,
-                        cwd.as_path(),
-                        parsed_cmd,
-                        *source,
-                        /*interaction_input*/ None,
+                        command, cwd, parsed_cmd, *source, /*interaction_input*/ None,
                         /*process_id*/ None,
                     ),
                     stage,
@@ -273,7 +269,7 @@ impl ToolEmitter {
                     ctx,
                     ExecCommandInput::new(
                         command,
-                        cwd.as_path(),
+                        cwd,
                         parsed_cmd,
                         *source,
                         /*interaction_input*/ None,
@@ -365,7 +361,7 @@ impl ToolEmitter {
 
 struct ExecCommandInput<'a> {
     command: &'a [String],
-    cwd: &'a Path,
+    cwd: &'a AbsolutePathBuf,
     parsed_cmd: &'a [ParsedCommand],
     source: ExecCommandSource,
     interaction_input: Option<&'a str>,
@@ -375,7 +371,7 @@ struct ExecCommandInput<'a> {
 impl<'a> ExecCommandInput<'a> {
     fn new(
         command: &'a [String],
-        cwd: &'a Path,
+        cwd: &'a AbsolutePathBuf,
         parsed_cmd: &'a [ParsedCommand],
         source: ExecCommandSource,
         interaction_input: Option<&'a str>,
@@ -479,7 +475,7 @@ async fn emit_exec_end(
                 process_id: exec_input.process_id.map(str::to_owned),
                 turn_id: ctx.turn.sub_id.clone(),
                 command: exec_input.command.to_vec(),
-                cwd: exec_input.cwd.to_path_buf(),
+                cwd: exec_input.cwd.clone(),
                 parsed_cmd: exec_input.parsed_cmd.to_vec(),
                 source: exec_input.source,
                 interaction_input: exec_input.interaction_input.map(str::to_owned),

codex-rs/core/src/tools/handlers/js_repl.rs

@@ -60,7 +60,7 @@ async fn emit_js_repl_exec_begin(
 ) {
     let emitter = ToolEmitter::shell(
         vec!["js_repl".to_string()],
-        turn.cwd.to_path_buf(),
+        turn.cwd.clone(),
         ExecCommandSource::Agent,
         /*freeform*/ false,
     );
@@ -79,7 +79,7 @@ async fn emit_js_repl_exec_end(
     let exec_output = build_js_repl_exec_output(output, error, duration);
     let emitter = ToolEmitter::shell(
         vec!["js_repl".to_string()],
-        turn.cwd.to_path_buf(),
+        turn.cwd.clone(),
         ExecCommandSource::Agent,
         /*freeform*/ false,
     );

codex-rs/core/src/tools/handlers/js_repl_tests.rs

@@ -77,7 +77,7 @@ async fn emit_js_repl_exec_end_sends_event() {
     assert_eq!(event.call_id, "call-1");
     assert_eq!(event.turn_id, turn.sub_id);
     assert_eq!(event.command, vec!["js_repl".to_string()]);
-    assert_eq!(event.cwd, turn.cwd.to_path_buf());
+    assert_eq!(event.cwd, turn.cwd);
     assert_eq!(event.source, ExecCommandSource::Agent);
     assert_eq!(event.interaction_input, None);
     assert_eq!(event.stdout, "hello");

codex-rs/core/src/tools/handlers/shell.rs

@@ -483,7 +483,7 @@ impl ShellHandler {
         let source = ExecCommandSource::Agent;
         let emitter = ToolEmitter::shell(
             exec_params.command.clone(),
-            exec_params.cwd.to_path_buf(),
+            exec_params.cwd.clone(),
             source,
             freeform,
         );

codex-rs/core/src/tools/handlers/shell_tests.rs

@@ -2,6 +2,8 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use codex_protocol::models::ShellCommandToolCallParams;
+use core_test_support::PathBufExt;
+use core_test_support::test_path_buf;
 use pretty_assertions::assert_eq;
 
 use crate::codex::make_session_and_context;
@@ -125,8 +127,8 @@ async fn shell_command_handler_to_exec_params_uses_session_shell_and_turn_contex
 #[test]
 fn shell_command_handler_respects_explicit_login_flag() {
     let (_tx, shell_snapshot) = watch::channel(Some(Arc::new(ShellSnapshot {
-        path: PathBuf::from("/tmp/snapshot.sh"),
-        cwd: PathBuf::from("/tmp"),
+        path: test_path_buf("/tmp/snapshot.sh").abs(),
+        cwd: test_path_buf("/tmp").abs(),
     })));
     let shell = Shell {
         shell_type: ShellType::Bash,

codex-rs/core/src/tools/handlers/view_image.rs

@@ -123,7 +123,7 @@ impl ToolHandler for ViewImageHandler {
                     abs_path.display()
                 ))
             })?;
-        let event_path = abs_path.to_path_buf();
+        let event_path = abs_path.clone();
 
         let can_request_original_detail = can_request_original_image_detail(&turn.model_info);
         let use_original_detail =

codex-rs/core/src/tools/network_approval.rs

@@ -401,7 +401,7 @@ impl NetworkApprovalService {
                     approval_id,
                     /*approval_id*/ None,
                     prompt_command,
-                    turn_context.cwd.to_path_buf(),
+                    turn_context.cwd.clone(),
                     Some(prompt_reason),
                     Some(network_approval_context.clone()),
                     /*proposed_execpolicy_amendment*/ None,

codex-rs/core/src/tools/registry.rs

@@ -578,7 +578,7 @@ async fn dispatch_after_tool_use_hook(
         .hooks()
         .dispatch(HookPayload {
             session_id: session.conversation_id,
-            cwd: turn.cwd.to_path_buf(),
+            cwd: turn.cwd.clone(),
             client: turn.app_server_client_name.clone(),
             triggered_at: chrono::Utc::now(),
             hook_event: HookEvent::AfterToolUse {

codex-rs/core/src/tools/runtimes/apply_patch.rs

@@ -60,7 +60,7 @@ impl ApplyPatchRuntime {
     ) -> GuardianApprovalRequest {
         GuardianApprovalRequest::ApplyPatch {
             id: call_id.to_string(),
-            cwd: req.action.cwd.to_path_buf(),
+            cwd: req.action.cwd.clone(),
             files: req.file_paths.clone(),
             patch: req.action.patch.clone(),
         }

codex-rs/core/src/tools/runtimes/apply_patch_tests.rs

@@ -43,7 +43,7 @@ fn guardian_review_request_includes_patch_context() {
         .join("guardian-apply-patch-test.txt")
         .abs();
     let action = ApplyPatchAction::new_add_for_test(&path, "hello".to_string());
-    let expected_cwd = action.cwd.to_path_buf();
+    let expected_cwd = action.cwd.clone();
     let expected_patch = action.patch.clone();
     let request = ApplyPatchRequest {
         action,
@@ -108,7 +108,7 @@ fn file_system_sandbox_context_uses_active_attempt() {
         network_policy: NetworkSandboxPolicy::Restricted,
         enforce_managed_network: false,
         manager: &manager,
-        sandbox_cwd: path.as_path(),
+        sandbox_cwd: &path,
         codex_linux_sandbox_exe: None,
         use_legacy_landlock: true,
         windows_sandbox_level: WindowsSandboxLevel::RestrictedToken,
@@ -154,7 +154,7 @@ fn no_sandbox_attempt_has_no_file_system_context() {
         network_policy: NetworkSandboxPolicy::Enabled,
         enforce_managed_network: false,
         manager: &manager,
-        sandbox_cwd: path.as_path(),
+        sandbox_cwd: &path,
         codex_linux_sandbox_exe: None,
         use_legacy_landlock: false,
         windows_sandbox_level: WindowsSandboxLevel::Disabled,

codex-rs/core/src/tools/runtimes/mod.rs

@@ -12,7 +12,6 @@ use codex_protocol::models::PermissionProfile;
 use codex_sandboxing::SandboxCommand;
 use codex_utils_absolute_path::AbsolutePathBuf;
 use std::collections::HashMap;
-use std::path::Path;
 
 pub(crate) mod apply_patch;
 pub(crate) mod shell;
@@ -60,7 +59,7 @@ pub(crate) fn build_sandbox_command(
 pub(crate) fn maybe_wrap_shell_lc_with_snapshot(
     command: &[String],
     session_shell: &Shell,
-    cwd: &Path,
+    cwd: &AbsolutePathBuf,
     explicit_env_overrides: &HashMap<String, String>,
     env: &HashMap<String, String>,
 ) -> Vec<String> {

codex-rs/core/src/tools/runtimes/mod_tests.rs

@@ -1,6 +1,9 @@
 use super::*;
 use crate::shell::ShellType;
 use crate::shell_snapshot::ShellSnapshot;
+use codex_utils_absolute_path::AbsolutePathBuf;
+use core_test_support::PathBufExt;
+use core_test_support::PathExt;
 use pretty_assertions::assert_eq;
 use std::path::PathBuf;
 use std::process::Command;
@@ -11,8 +14,8 @@ use tokio::sync::watch;
 fn shell_with_snapshot(
     shell_type: ShellType,
     shell_path: &str,
-    snapshot_path: PathBuf,
-    snapshot_cwd: PathBuf,
+    snapshot_path: AbsolutePathBuf,
+    snapshot_cwd: AbsolutePathBuf,
 ) -> Shell {
     let (_tx, shell_snapshot) = watch::channel(Some(Arc::new(ShellSnapshot {
         path: snapshot_path,
@@ -33,8 +36,8 @@ fn maybe_wrap_shell_lc_with_snapshot_bootstraps_in_user_shell() {
     let session_shell = shell_with_snapshot(
         ShellType::Zsh,
         "/bin/zsh",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -45,7 +48,7 @@ fn maybe_wrap_shell_lc_with_snapshot_bootstraps_in_user_shell() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -64,8 +67,8 @@ fn maybe_wrap_shell_lc_with_snapshot_escapes_single_quotes() {
     let session_shell = shell_with_snapshot(
         ShellType::Zsh,
         "/bin/zsh",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -76,7 +79,7 @@ fn maybe_wrap_shell_lc_with_snapshot_escapes_single_quotes() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -92,8 +95,8 @@ fn maybe_wrap_shell_lc_with_snapshot_uses_bash_bootstrap_shell() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/zsh".to_string(),
@@ -104,7 +107,7 @@ fn maybe_wrap_shell_lc_with_snapshot_uses_bash_bootstrap_shell() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -123,8 +126,8 @@ fn maybe_wrap_shell_lc_with_snapshot_uses_sh_bootstrap_shell() {
     let session_shell = shell_with_snapshot(
         ShellType::Sh,
         "/bin/sh",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -135,7 +138,7 @@ fn maybe_wrap_shell_lc_with_snapshot_uses_sh_bootstrap_shell() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -154,8 +157,8 @@ fn maybe_wrap_shell_lc_with_snapshot_preserves_trailing_args() {
     let session_shell = shell_with_snapshot(
         ShellType::Zsh,
         "/bin/zsh",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -168,7 +171,7 @@ fn maybe_wrap_shell_lc_with_snapshot_preserves_trailing_args() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -188,8 +191,12 @@ fn maybe_wrap_shell_lc_with_snapshot_skips_when_cwd_mismatch() {
     let command_cwd = dir.path().join("worktree-b");
     std::fs::create_dir_all(&snapshot_cwd).expect("create snapshot cwd");
     std::fs::create_dir_all(&command_cwd).expect("create command cwd");
-    let session_shell =
-        shell_with_snapshot(ShellType::Zsh, "/bin/zsh", snapshot_path, snapshot_cwd);
+    let session_shell = shell_with_snapshot(
+        ShellType::Zsh,
+        "/bin/zsh",
+        snapshot_path.abs(),
+        snapshot_cwd.abs(),
+    );
     let command = vec![
         "/bin/bash".to_string(),
         "-lc".to_string(),
@@ -199,7 +206,7 @@ fn maybe_wrap_shell_lc_with_snapshot_skips_when_cwd_mismatch() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        &command_cwd,
+        &command_cwd.abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -215,8 +222,8 @@ fn maybe_wrap_shell_lc_with_snapshot_accepts_dot_alias_cwd() {
     let session_shell = shell_with_snapshot(
         ShellType::Zsh,
         "/bin/zsh",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -228,7 +235,7 @@ fn maybe_wrap_shell_lc_with_snapshot_accepts_dot_alias_cwd() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        &command_cwd,
+        &command_cwd.abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -251,8 +258,8 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_explicit_override_precedence() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -264,7 +271,7 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_explicit_override_precedence() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &explicit_env_overrides,
         &HashMap::from([("TEST_ENV_SNAPSHOT".to_string(), "worktree".to_string())]),
     );
@@ -293,8 +300,8 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_codex_thread_id_from_env() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -304,7 +311,7 @@ fn maybe_wrap_shell_lc_with_snapshot_restores_codex_thread_id_from_env() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::from([("CODEX_THREAD_ID".to_string(), "nested-thread".to_string())]),
     );
@@ -330,8 +337,8 @@ fn maybe_wrap_shell_lc_with_snapshot_keeps_snapshot_path_without_override() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -341,7 +348,7 @@ fn maybe_wrap_shell_lc_with_snapshot_keeps_snapshot_path_without_override() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &HashMap::new(),
         &HashMap::new(),
     );
@@ -366,8 +373,8 @@ fn maybe_wrap_shell_lc_with_snapshot_applies_explicit_path_override() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -378,7 +385,7 @@ fn maybe_wrap_shell_lc_with_snapshot_applies_explicit_path_override() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &explicit_env_overrides,
         &HashMap::from([("PATH".to_string(), "/worktree/bin".to_string())]),
     );
@@ -404,8 +411,8 @@ fn maybe_wrap_shell_lc_with_snapshot_does_not_embed_override_values_in_argv() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
         "/bin/bash".to_string(),
@@ -419,7 +426,7 @@ fn maybe_wrap_shell_lc_with_snapshot_does_not_embed_override_values_in_argv() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &explicit_env_overrides,
         &HashMap::from([(
             "OPENAI_API_KEY".to_string(),
@@ -452,8 +459,8 @@ fn maybe_wrap_shell_lc_with_snapshot_preserves_unset_override_variables() {
     let session_shell = shell_with_snapshot(
         ShellType::Bash,
         "/bin/bash",
-        snapshot_path,
-        dir.path().to_path_buf(),
+        snapshot_path.abs(),
+        dir.path().abs(),
     );
     let command = vec![
             "/bin/bash".to_string(),
@@ -467,7 +474,7 @@ fn maybe_wrap_shell_lc_with_snapshot_preserves_unset_override_variables() {
     let rewritten = maybe_wrap_shell_lc_with_snapshot(
         &command,
         &session_shell,
-        dir.path(),
+        &dir.path().abs(),
         &explicit_env_overrides,
         &HashMap::new(),
     );

codex-rs/core/src/tools/runtimes/shell.rs

@@ -145,7 +145,7 @@ impl Approvable<ShellRequest> for ShellRuntime {
     ) -> BoxFuture<'a, ReviewDecision> {
         let keys = self.approval_keys(req);
         let command = req.command.clone();
-        let cwd = req.cwd.to_path_buf();
+        let cwd = req.cwd.clone();
         let retry_reason = ctx.retry_reason.clone();
         let reason = retry_reason.clone().or_else(|| req.justification.clone());
         let session = ctx.session;
@@ -161,7 +161,7 @@ impl Approvable<ShellRequest> for ShellRuntime {
                     GuardianApprovalRequest::Shell {
                         id: call_id,
                         command,
-                        cwd,
+                        cwd: cwd.clone(),
                         sandbox_permissions: req.sandbox_permissions,
                         additional_permissions: req.additional_permissions.clone(),
                         justification: req.justification.clone(),

codex-rs/core/src/tools/runtimes/shell/unix_escalation.rs

@@ -158,7 +158,7 @@ pub(super) async fn try_run_zsh_fork(
         network: sandbox_network,
         windows_sandbox_level,
         arg0,
-        sandbox_policy_cwd: ctx.turn.cwd.to_path_buf(),
+        sandbox_policy_cwd: ctx.turn.cwd.clone(),
         codex_linux_sandbox_exe: ctx.turn.codex_linux_sandbox_exe.clone(),
         use_legacy_landlock: ctx.turn.features.use_legacy_landlock(),
     };
@@ -256,7 +256,7 @@ pub(crate) async fn prepare_unified_exec_zsh_fork(
         network: exec_request.network.clone(),
         windows_sandbox_level: exec_request.windows_sandbox_level,
         arg0: exec_request.arg0.clone(),
-        sandbox_policy_cwd: ctx.turn.cwd.to_path_buf(),
+        sandbox_policy_cwd: ctx.turn.cwd.clone(),
         codex_linux_sandbox_exe: ctx.turn.codex_linux_sandbox_exe.clone(),
         use_legacy_landlock: ctx.turn.features.use_legacy_landlock(),
     };
@@ -386,7 +386,7 @@ impl CoreShellActionProvider {
         additional_permissions: Option<PermissionProfile>,
     ) -> anyhow::Result<PromptDecision> {
         let command = join_program_and_argv(program, argv);
-        let workdir = workdir.to_path_buf();
+        let workdir = workdir.clone();
         let session = self.session.clone();
         let turn = self.turn.clone();
         let call_id = self.call_id.clone();
@@ -405,7 +405,7 @@ impl CoreShellActionProvider {
                             source,
                             program: program.to_string_lossy().into_owned(),
                             argv: argv.to_vec(),
-                            cwd: workdir,
+                            cwd: workdir.clone(),
                             additional_permissions,
                         },
                         /*retry_reason*/ None,
@@ -422,7 +422,7 @@ impl CoreShellActionProvider {
                         call_id,
                         approval_id,
                         command,
-                        workdir,
+                        workdir.clone(),
                         /*reason*/ None,
                         /*network_approval_context*/ None,
                         /*proposed_execpolicy_amendment*/ None,
@@ -696,7 +696,7 @@ struct CoreShellCommandExecutor {
     network: Option<codex_network_proxy::NetworkProxy>,
     windows_sandbox_level: WindowsSandboxLevel,
     arg0: Option<String>,
-    sandbox_policy_cwd: PathBuf,
+    sandbox_policy_cwd: AbsolutePathBuf,
     codex_linux_sandbox_exe: Option<PathBuf>,
     use_legacy_landlock: bool,
 }

codex-rs/core/src/tools/runtimes/unified_exec.rs

@@ -126,7 +126,7 @@ impl Approvable<UnifiedExecRequest> for UnifiedExecRuntime<'_> {
         let turn = ctx.turn;
         let call_id = ctx.call_id.to_string();
         let command = req.command.clone();
-        let cwd = req.cwd.to_path_buf();
+        let cwd = req.cwd.clone();
         let retry_reason = ctx.retry_reason.clone();
         let reason = retry_reason.clone().or_else(|| req.justification.clone());
         let guardian_review_id = ctx.guardian_review_id.clone();
@@ -139,7 +139,7 @@ impl Approvable<UnifiedExecRequest> for UnifiedExecRuntime<'_> {
                     GuardianApprovalRequest::ExecCommand {
                         id: call_id,
                         command,
-                        cwd,
+                        cwd: cwd.clone(),
                         sandbox_permissions: req.sandbox_permissions,
                         additional_permissions: req.additional_permissions.clone(),
                         justification: req.justification.clone(),
@@ -157,7 +157,7 @@ impl Approvable<UnifiedExecRequest> for UnifiedExecRuntime<'_> {
                         call_id,
                         /*approval_id*/ None,
                         command,
-                        cwd,
+                        cwd.clone(),
                         reason,
                         ctx.network_approval_context.clone(),
                         req.exec_approval_requirement

codex-rs/core/src/tools/sandboxing.rs

@@ -27,13 +27,13 @@ use codex_sandboxing::SandboxTransformError;
 use codex_sandboxing::SandboxTransformRequest;
 use codex_sandboxing::SandboxType;
 use codex_sandboxing::SandboxablePreference;
+use codex_utils_absolute_path::AbsolutePathBuf;
 use futures::Future;
 use futures::future::BoxFuture;
 use serde::Serialize;
 use std::collections::HashMap;
 use std::fmt::Debug;
 use std::hash::Hash;
-use std::path::Path;
 use std::sync::Arc;
 
 #[derive(Clone, Default, Debug)]
@@ -331,7 +331,7 @@ pub(crate) struct SandboxAttempt<'a> {
     pub network_policy: NetworkSandboxPolicy,
     pub enforce_managed_network: bool,
     pub(crate) manager: &'a SandboxManager,
-    pub(crate) sandbox_cwd: &'a Path,
+    pub(crate) sandbox_cwd: &'a AbsolutePathBuf,
     pub codex_linux_sandbox_exe: Option<&'a std::path::PathBuf>,
     pub use_legacy_landlock: bool,
     pub windows_sandbox_level: codex_protocol::config_types::WindowsSandboxLevel,