dotnet: reject per-client WorkingDirectory with in-process transport

Mirror the Node/Rust behavior: the in-process (FFI) host spawns the worker
without a working-directory parameter, so a per-client WorkingDirectory can't
be honored. Fail loud (ArgumentException) instead of silently ignoring it,
consistent with the existing Environment/Telemetry in-process guards.

Update the E2E harness to point this process's cwd at the desired directory
for in-process tests (the FFI worker inherits it at spawn) and restore it
after each test via InProcessEnvIsolation, matching sdkTestContext.ts.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: a96d1a82-c80e-40f1-a3df-a9708429b68b

Author: SteveSandersonMS

dotnet/src/Client.cs

@@ -237,6 +237,17 @@ private static void ValidateEnvironmentOptions(CopilotClientOptions options, Run
                     nameof(options));
             }
 
+            if (options.WorkingDirectory is not null)
+            {
+                throw new ArgumentException(
+                    $"{nameof(CopilotClientOptions)}.{nameof(CopilotClientOptions.WorkingDirectory)} is not supported with " +
+                    $"{nameof(RuntimeConnection)}.{nameof(RuntimeConnection.ForInProcess)}(): the in-process transport hosts " +
+                    "the native runtime in the shared host process and spawns the worker without a working-directory " +
+                    "parameter, so a per-client working directory cannot be honored in-process. Use a child-process " +
+                    "transport, or set the process working directory before creating the client.",
+                    nameof(options));
+            }
+
             return;
         }
 

dotnet/test/Harness/E2ETestContext.cs

@@ -244,9 +244,17 @@ public CopilotClient CreateClient(
     {
         options ??= new CopilotClientOptions();
 
-        options.WorkingDirectory ??= WorkDir;
         options.Logger ??= Logger;
 
+        // Resolve the working directory the worker should run in. Child-process and
+        // URI transports take it as a per-client option; the in-process transport
+        // rejects a per-client WorkingDirectory (the native host spawns the worker
+        // without a cwd parameter), so — mirroring the Node/Rust harnesses — we point
+        // THIS process's cwd at the desired directory before the worker spawns and
+        // clear the per-client option. InProcessEnvIsolationAttribute.After restores
+        // the cwd after the test.
+        var desiredWorkingDirectory = options.WorkingDirectory ?? WorkDir;
+
         // Tests must supply environment via the 'environment' parameter, which the
         // harness routes to the right place per transport (the connection for
         // child-process transports, the host process for in-process). Setting
@@ -300,12 +308,24 @@ public CopilotClient CreateClient(
             {
                 InProcessEnvIsolation.Apply(name, value);
             }
+
+            // A per-client WorkingDirectory is rejected in-process; instead point this
+            // process's cwd at the desired directory so the worker inherits it at spawn
+            // (restored after the test by InProcessEnvIsolationAttribute).
+            options.WorkingDirectory = null;
+            InProcessEnvIsolation.SetWorkingDirectory(desiredWorkingDirectory);
         }
         else if (options.Connection is ChildProcessRuntimeConnection child)
         {
             // Child-process transport: hand the environment to the spawned child
             // via the connection, where per-client environment is coherent.
             child.Environment = env;
+            options.WorkingDirectory = desiredWorkingDirectory;
+        }
+        else
+        {
+            // URI / existing-runtime transport: per-client WorkingDirectory applies normally.
+            options.WorkingDirectory = desiredWorkingDirectory;
         }
 
         // Auto-inject auth token unless connecting to an existing runtime via URI.

dotnet/test/Harness/InProcessEnvIsolation.cs

@@ -22,6 +22,11 @@ internal static class InProcessEnvIsolation
     // Captured at load, before any fixture/test mutates env.
     private static readonly Dictionary<string, string?> s_ambient = CaptureEnvironment();
 
+    // The process working directory captured at load, restored after each test so an
+    // in-process test that repoints the cwd (the FFI worker inherits it at spawn)
+    // can't leak that change into the next test.
+    private static readonly string s_ambientCwd = Directory.GetCurrentDirectory();
+
     // Runs at assembly load so the ambient env is snapshotted before the shared
     // fixture mirrors per-test env onto the process. Justifies suppressing CA2255.
 #pragma warning disable CA2255 // ModuleInitializer discouraged in libraries; intentional in this test harness.
@@ -56,8 +61,19 @@ public static void NeutralizeAmbientCredentials()
         }
     }
 
+    // Points the process working directory at the given path so the in-process FFI
+    // worker inherits it at spawn (the native host has no per-client cwd parameter).
+    // RestoreAmbient() returns the process to its load-time cwd after the test.
+    public static void SetWorkingDirectory(string path) =>
+        Directory.SetCurrentDirectory(path);
+
     public static void RestoreAmbient()
     {
+        if (!string.Equals(Directory.GetCurrentDirectory(), s_ambientCwd, StringComparison.Ordinal))
+        {
+            Directory.SetCurrentDirectory(s_ambientCwd);
+        }
+
         foreach (DictionaryEntry entry in Environment.GetEnvironmentVariables())
         {
             var name = (string)entry.Key;