refactor(busy-route): drop dead "old DLL null-cwd" fallback

Follow-up to a6ffe85. The version-lockstep connection guard
(NamedPipeServer.cs's \`version_mismatch\` branch) refuses any
proxy/DLL pair whose versions disagree, so a busy response that
reaches PowerShellTools.cs is guaranteed to come from a same-version
DLL — i.e. one that emits the \`cwd\` field. The "leave it null on
older DLLs and we fall back to HOME" branch the prior commit added
was structurally unreachable.

Removed the intermediate \`sourceCwd\` local and the comment about
old-DLL backward compatibility. Kept the \`Directory.Exists\` check
because the cwd path itself can still be unreachable at runtime
(deleted folder between snapshot and spawn, disconnected network
drive) — that's a different class of edge case from version skew
and the HOME fallback there is a real safety net for spawn success.

Updated the \`Cwd\` field's docstring on \`GetStatusResponse\` to
explain the field is nullable solely because \`Directory.GetCurrentDirectory\`
can throw on a disconnected drive (so the DLL emits null), not
because old DLLs might omit it.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: yotsuda

PowerShell.MCP.Proxy/Models/JsonRpcModels.cs

@@ -84,7 +84,10 @@ public class GetStatusResponse
     /// response — busy / user_command / mcp_command / standby /
     /// completed. Used by the busy-auto-route path so a freshly-spawned
     /// console can land at the same cwd before re-running the AI's
-    /// pipeline. Null on older DLLs that predate the field.
+    /// pipeline. Nullable only because <c>Directory.GetCurrentDirectory</c>
+    /// can throw on a disconnected network drive — the version-lockstep
+    /// connection guard rules out the "old DLL didn't send the field"
+    /// case at the wire level.
     /// </summary>
     [JsonPropertyName("cwd")]
     public string? Cwd { get; set; }

PowerShell.MCP.Proxy/Tools/PowerShellTools.cs

@@ -351,15 +351,20 @@ public static async Task<string> InvokeExpression(
                                     // exact same call, with the new console at HOME (= losing
                                     // the cwd the user/AI had been working in). Two
                                     // round-trips and a manual `Set-Location` for every busy
-                                    // race. Now: read the source's cwd from the busy
-                                    // response (DLL emits `cwd` from the get_status path),
-                                    // start the new console there, and run the pipeline as a
-                                    // single recursive call. The DLL has emitted `cwd` since
-                                    // a recent compatible version; older DLLs leave it null
-                                    // and we fall back to HOME (= the old behavior).
-                                    var sourceCwd = jsonResponse.Cwd;
-                                    var startLoc = (!string.IsNullOrEmpty(sourceCwd) && Directory.Exists(sourceCwd))
-                                        ? sourceCwd
+                                    // race.
+                                    //
+                                    // The version-lockstep connection guard (see
+                                    // NamedPipeServer.cs's `version_mismatch` branch) means
+                                    // any DLL that survived the handshake speaks the same
+                                    // protocol as this proxy, so jsonResponse.Cwd is always
+                                    // populated for busy responses — no "null because old
+                                    // DLL" case to handle. Directory.Exists IS still checked
+                                    // because the cwd path itself can be unreachable at
+                                    // runtime (deleted folder, disconnected network drive);
+                                    // in that genuine edge case we fall back to HOME so the
+                                    // spawn can at least succeed.
+                                    var startLoc = (!string.IsNullOrEmpty(jsonResponse.Cwd) && Directory.Exists(jsonResponse.Cwd))
+                                        ? jsonResponse.Cwd
                                         : Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
 
                                     Console.Error.WriteLine($"[INFO] Runspace busy ({jsonResponse.Reason}), auto-routing to new console at {startLoc}...");