Rust: set in-process runtime worker cwd to the client working directory

The in-process FFI host never set the runtime worker's current directory, so it
inherited the SDK process's cwd instead of the client's working_directory. Unlike
the stdio/tcp transports (build_command sets .current_dir(working_directory)),
workspace-relative file operations therefore resolved against the wrong directory:
the model's tool calls used a relative path (e.g. 'order.txt') that the runtime
rejected as 'not absolute', diverging from the recorded replay snapshot and
surfacing as a proxy 500 / send_and_wait failure — but only in-process.

Mirror the Node in-process host: switch cwd to working_directory for the duration
of the blocking host_start (which spawns the worker), then restore it. Confirmed
locally: the affected event_fidelity + hooks tests pass in-process, and the test
already passed over stdio.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: SteveSandersonMS

rust/src/ffi.rs

@@ -194,6 +194,7 @@ pub(crate) struct FfiHost {
     library_path: PathBuf,
     entrypoint: PathBuf,
     environment: Vec<(String, String)>,
+    working_directory: Option<PathBuf>,
     host_start: HostStartFn,
     host_shutdown: HostShutdownFn,
     connection_open: ConnectionOpenFn,
@@ -215,6 +216,7 @@ impl FfiHost {
     pub(crate) fn create(
         entrypoint: &Path,
         environment: Vec<(String, String)>,
+        working_directory: Option<PathBuf>,
     ) -> Result<Self, Error> {
         let library_path = resolve_library_path(entrypoint)?;
         let lib = load_library(&library_path)?;
@@ -233,6 +235,7 @@ impl FfiHost {
             library_path,
             entrypoint: entrypoint.to_path_buf(),
             environment,
+            working_directory,
             host_start,
             host_shutdown,
             connection_open,
@@ -265,7 +268,28 @@ impl FfiHost {
             Some(bytes) => (bytes.as_ptr(), bytes.len()),
             None => (std::ptr::null(), 0),
         };
+
+        // The native host spawns the CLI worker itself and exposes no cwd
+        // parameter, so the worker inherits this process's current directory.
+        // Mirror the stdio child's `current_dir(working_directory)` by switching
+        // cwd for the duration of the blocking `host_start` (which spawns the
+        // worker), then restoring it. This matches the Node in-process host and
+        // ensures workspace-relative file operations resolve against the
+        // client's working directory rather than the SDK process's cwd.
+        let previous_cwd = std::env::current_dir().ok();
+        let switched_cwd = match &self.working_directory {
+            Some(dir) if previous_cwd.as_deref() != Some(dir.as_path()) => {
+                std::env::set_current_dir(dir).is_ok()
+            }
+            _ => false,
+        };
+
         let server_id = unsafe { (self.host_start)(argv.as_ptr(), argv.len(), env_ptr, env_len) };
+
+        if switched_cwd && let Some(previous) = &previous_cwd {
+            let _ = std::env::set_current_dir(previous);
+        }
+
         if server_id == 0 {
             return Err(Error::with_message(
                 ErrorKind::InvalidConfig,

rust/src/lib.rs

@@ -1169,7 +1169,11 @@ impl Client {
                 // env; configure the runtime via the host process environment instead.
                 // See https://github.com/github/copilot-sdk/issues/1934.
                 info!(entrypoint = %program.display(), "hosting copilot runtime in-process (FFI)");
-                let host = crate::ffi::FfiHost::create(&program, Vec::new())?;
+                let host = crate::ffi::FfiHost::create(
+                    &program,
+                    Vec::new(),
+                    Some(options.working_directory.clone()),
+                )?;
                 let (reader, writer, shared) = host.start().await?;
                 let client = Self::from_transport(
                     reader,