feat(busy-route): auto-execute pipeline on a fresh console at the source's cwd

Pre-fix: when invoke_expression's chosen pipe was busy (a user command
typed in the visible terminal between FindReadyPipeAsync and the
proxy's request arrival, or another mcp_command racing), the proxy
spawned a brand-new console at \$HOME, returned `Pipeline NOT executed
- verify location and re-execute` plus the full get_current_location
JSON (system info + every PSDrive), and the AI had to re-send the same
invoke_expression with whatever cwd they wanted. Two MCP round-trips
and a manual Set-Location for every busy race — observed as the
single biggest token-waster in side-by-side comparisons against
ripple, which auto-routes to a same-family standby with the source's
cwd preserved.

Now: the busy response carries the source console's process-level
cwd (DLL: NamedPipeServer.cs adds `cwd` from
Directory.GetCurrentDirectory in three places — get_status/busy,
mcp_command, user_command branches; reading the property does NOT
touch the runspace, so it stays non-blocking). The proxy reads
jsonResponse.Cwd, starts the new console at that path (falls back to
\$HOME when the field is null on older DLLs — fully backward-compatible),
and recursively calls InvokeExpression on the same agent. The new
console is now the active standby, so FindReadyPipeAsync on the
recursive call lands on it and the pipeline runs cleanly. The
recursion is bounded in practice: a back-to-back race against another
user-typed command in the freshly-spawned console would require
sub-millisecond timing at AI tool-call cadence; if it ever happens,
the recursion spawns one more console and runs there — no infinite
loop, just an extra console.

The bulky get_current_location JSON drops out of the response in
this path: the AI no longer needs the OS / PSDrive listing to verify
cwd because the auto-route already preserved it, and the recursive
call's response carries the actual pipeline output the AI was
waiting for. Proxy still surfaces the busy status line ("⧗ Pipeline
is running ...") and a one-line auto-route notice
("ℹ️ Auto-routed to NEW at CWD ... Pipeline executed automatically
— no re-send needed") so the AI sees what happened, but the verbose
JSON is gone. Closed-console messages from the outer call are
prepended too (the recursive call's FindReadyPipeAsync runs fresh
and won't re-report them).

The other two `Pipeline NOT executed` paths (no-pipe auto-start and
consoleSwitched on a claimed unowned console) are left alone for
now: they don't have a source-console cwd to preserve, and forcing
auto-execution there would risk landing the AI's pipeline in an
unrelated cwd. Trim of the bulky JSON in those paths is a separate
concern.

Existing 19 PowerShellTools unit tests still pass — none cover the
busy auto-respawn path (StartConsoleInternal calls a static
PowerShellProcessManager so spawn-mock isn't possible without a
process-manager-injection refactor first; deferred). The change is
safe to ship because the wire format is strictly additive (DLL emits
a new optional field; older proxies ignore it; older DLLs still hit
the null-cwd → \$HOME fallback path = pre-fix behavior).

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

Author: yotsuda

PowerShell.MCP.Proxy/Models/JsonRpcModels.cs

@@ -76,6 +76,18 @@ public class GetStatusResponse
 
     [JsonPropertyName("message")]
     public string? Message { get; set; }
+
+    /// <summary>
+    /// Process-level current working directory of the source console
+    /// at the moment this status was captured. Populated by the DLL
+    /// (see <c>NamedPipeServer.HandleGetStatus</c>) for every status
+    /// 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.
+    /// </summary>
+    [JsonPropertyName("cwd")]
+    public string? Cwd { get; set; }
 }
 
 [JsonSerializable(typeof(GetStatusResponse))]

PowerShell.MCP.Proxy/Tools/PowerShellTools.cs

@@ -344,12 +344,29 @@ public static async Task<string> InvokeExpression(
 
                                 if (jsonResponse.Reason == "user_command" || jsonResponse.Reason == "mcp_command")
                                 {
-                                    // Auto-start new console
-                                    Console.Error.WriteLine($"[INFO] Runspace busy ({jsonResponse.Reason}), auto-starting new console...");
-                                    var (success, locationResult) = await StartConsoleInternal(powerShellService, agentId, null, Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), cancellationToken);
-                                    if (!success)
+                                    // Auto-route: spawn a new console at the source's cwd and
+                                    // re-run the pipeline there in the same tool call. Pre-fix
+                                    // we returned a "Pipeline NOT executed - verify location
+                                    // and re-execute" message and the AI had to re-send the
+                                    // 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
+                                        : Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+
+                                    Console.Error.WriteLine($"[INFO] Runspace busy ({jsonResponse.Reason}), auto-routing to new console at {startLoc}...");
+                                    var (startSuccess, startError) = await StartConsoleInternal(powerShellService, agentId, null, startLoc, cancellationToken);
+                                    if (!startSuccess)
                                     {
-                                        return locationResult; // Error message
+                                        return startError;
                                     }
 
                                     // Set console window title
@@ -359,28 +376,43 @@ public static async Task<string> InvokeExpression(
                                         await SetConsoleTitleAsync(powerShellService, activeAfterBusy, cancellationToken);
                                     }
 
-                                    var newPipeName = sessionManager.GetActivePipeName(agentId);
-                                    var (completedOutputs, busyInfo) = await CollectAllCachedOutputsAsync(pipeDiscoveryService, agentId, newPipeName, cancellationToken);
-
-                                    var newConsoleName = GetConsoleName(newPipeName);
-
+                                    var newConsoleName = GetConsoleName(activeAfterBusy);
+
+                                    // Recurse: the new console is now the active standby,
+                                    // so FindReadyPipeAsync on the recursive call sees it
+                                    // as ready and the pipeline runs cleanly. Recursion
+                                    // depth is bounded in practice — StartConsoleInternal
+                                    // just spawned a fresh console that hasn't been handed
+                                    // out as a user-input target yet, so a second
+                                    // back-to-back busy would require a sub-millisecond
+                                    // race that's effectively impossible at AI tool-call
+                                    // cadence. If it ever happens, the recursion would
+                                    // spawn one more console and run there; no infinite
+                                    // loop, just one extra console.
+                                    var retryResult = await InvokeExpression(
+                                        powerShellService, pipeDiscoveryService, pipeline,
+                                        timeout_seconds, var1, var2, var3, var4,
+                                        agentId, is_subagent: false,
+                                        cancellationToken: cancellationToken);
+
+                                    // Surface the auto-route notice + closed-console
+                                    // messages collected by THIS outer call (the recursive
+                                    // call's FindReadyPipeAsync runs fresh and won't
+                                    // re-report them). Drop the previous bulky
+                                    // get_current_location JSON (system info / drives) — the
+                                    // recursive call delivers the actual pipeline output and
+                                    // the AI no longer needs the OS / drive-list block to
+                                    // verify cwd because we already preserved it.
                                     var busyResponse = new StringBuilder();
-                                    // Busy status at the top (current pipe first, then other pipes)
-                                    busyResponse.AppendLine(FormatBusyStatus(jsonResponse));
-                                    if (busyInfo.Length > 0)
-                                    {
-                                        busyResponse.Append(busyInfo);
-                                    }
-                                    busyResponse.AppendLine();
-                                    busyResponse.AppendLine($"Started new console {newConsoleName} with PowerShell.MCP module imported. Pipeline NOT executed - verify location and re-execute.");
-                                    busyResponse.AppendLine();
-                                    busyResponse.Append(locationResult);
-                                    if (completedOutputs.Length > 0)
+                                    if (closedConsoleMessages.Count > 0)
                                     {
+                                        busyResponse.AppendLine(string.Join("\n", closedConsoleMessages));
                                         busyResponse.AppendLine();
-                                        busyResponse.AppendLine();
-                                        busyResponse.Append(completedOutputs);
                                     }
+                                    busyResponse.AppendLine(FormatBusyStatus(jsonResponse));
+                                    busyResponse.AppendLine($"ℹ️ Auto-routed to {newConsoleName} at {startLoc} (source console busy with {jsonResponse.Reason}). Pipeline executed automatically — no re-send needed.");
+                                    busyResponse.AppendLine();
+                                    busyResponse.Append(retryResult);
                                     return busyResponse.ToString();
                                 }
                                 break;
@@ -536,9 +568,8 @@ public static async Task<string> InvokeExpression(
                                     successResponse.AppendLine();
                                     successResponse.AppendLine(scopeWarning);
                                 }
-                                // One-time hint about MarkdownPointer module
-                                var markdownHint = PipelineHelper.CheckMarkdownFileHint(pipeline, agentId)
-                                    ?? PipelineHelper.CheckMarkdownFileHint(output, agentId);
+                                // One-time hint about MarkdownPointer module (pipeline-only; output checks caused false positives on incidental .md mentions).
+                                var markdownHint = PipelineHelper.CheckMarkdownFileHint(pipeline, agentId);
                                 if (!string.IsNullOrEmpty(markdownHint))
                                 {
                                     successResponse.AppendLine();

PowerShell.MCP/Services/NamedPipeServer.cs

@@ -417,6 +417,21 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
             {
                 var pid = System.Diagnostics.Process.GetCurrentProcess().Id;
                 var status = ExecutionState.Status;
+                // Process-level cwd. PowerShell's `Set-Location` for the
+                // FileSystem provider syncs this with $PWD so P/Invoke
+                // calls see the same directory the user typed `cd` to.
+                // Reading it here is just a property access — does NOT
+                // touch the runspace and is safe to call while a command
+                // is busy. Used by the proxy's busy-auto-route path so a
+                // freshly-spawned console can land at the source's cwd
+                // before re-running the AI's pipeline (otherwise every
+                // contention with a user-typed command would force the
+                // AI to manually re-cd). Non-FileSystem providers
+                // (HKLM:\, Cert:\, etc.) leave this at the last
+                // FileSystem location, which is the right fallback.
+                string? cwd;
+                try { cwd = System.IO.Directory.GetCurrentDirectory(); }
+                catch { cwd = null; }
 
                 string statusResponse;
                 if (status == "busy")
@@ -435,7 +450,8 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
                         status = "busy",
                         pipeline = truncatedPipeline,
                         duration = roundedDuration,
-                        statusLine
+                        statusLine,
+                        cwd
                     });
                 }
                 else if (status == "completed")
@@ -448,7 +464,8 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
                         pid,
                         status = "completed",
                         cachedCount = cachedOutputs.Count,
-                        statusLine
+                        statusLine,
+                        cwd
                     });
                 }
                 else
@@ -457,7 +474,7 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
                     if (ExecutionState.IsRunspaceAvailable)
                     {
                         var statusLine = BuildStatusLine("●", "Console ready", "Standby");
-                        statusResponse = JsonSerializer.Serialize(new { pid, status = "standby", statusLine });
+                        statusResponse = JsonSerializer.Serialize(new { pid, status = "standby", statusLine, cwd });
                     }
                     else
                     {
@@ -470,7 +487,8 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
                             status = "busy",
                             pipeline = "(user command)",
                             duration = userDuration,
-                            statusLine
+                            statusLine,
+                            cwd
                         });
                     }
                 }
@@ -571,13 +589,22 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
                 var pid = System.Diagnostics.Process.GetCurrentProcess().Id;
                 var elapsed = ExecutionState.ElapsedSeconds;
                 var runningPipeline = TruncatePipeline(ExecutionState.CurrentPipeline);
+                // Process-level cwd. The runspace is busy with another
+                // command but Directory.GetCurrentDirectory is just a
+                // property read — non-blocking. Proxy uses this to spawn
+                // the new auto-route console at the source's cwd so the
+                // re-routed pipeline runs where the AI expected it.
+                string? cwd;
+                try { cwd = System.IO.Directory.GetCurrentDirectory(); }
+                catch { cwd = null; }
                 var busyResponse = JsonSerializer.Serialize(new
                 {
                     pid,
                     status = "busy",
                     reason = "mcp_command",
                     pipeline = runningPipeline,
-                    duration = Math.Round(elapsed, 2)
+                    duration = Math.Round(elapsed, 2),
+                    cwd
                 });
 
                 await SendMessageAsync(pipeServer, busyResponse, cancellationToken);
@@ -598,13 +625,20 @@ private static async Task HandleClientAsync(NamedPipeServerStream pipeServer, Ca
                     // Runspace is busy with user command - return JSON response
                     var pid = Process.GetCurrentProcess().Id;
                     var userCmdElapsed = ExecutionState.UserCommandElapsedSeconds;
+                    // Capture the source console's cwd so the proxy can
+                    // spawn the auto-route console at the same location
+                    // (see the mcp_command branch above for the reasoning).
+                    string? cwd;
+                    try { cwd = System.IO.Directory.GetCurrentDirectory(); }
+                    catch { cwd = null; }
                     var busyResponse = JsonSerializer.Serialize(new
                     {
                         pid,
                         status = "busy",
                         reason = "user_command",
                         pipeline = "(user command)",
-                        duration = Math.Round(userCmdElapsed, 2)
+                        duration = Math.Round(userCmdElapsed, 2),
+                        cwd
                     });
                     await SendMessageAsync(pipeServer, busyResponse, cancellationToken);
                     return;