code-coordinator 0.5.570__tar.gz → 0.5.572__tar.gz

{code_coordinator-0.5.570 → code_coordinator-0.5.572}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.570
+Version: 0.5.572
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.570 → code_coordinator-0.5.572}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.570
+Version: 0.5.572
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.570 → code_coordinator-0.5.572}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.570",
+  "tag": "0.5.572",
   "distance": 0,
-  "node": "g29bd794d5c1bbedb62f22cdd0bef36e1a1cddd33",
+  "node": "g33ef2d84241ba2583d47d8288838f7d8729dce83",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.570 → code_coordinator-0.5.572}/coord/win_native_driver.py

@@ -51,6 +51,19 @@ operator's own work, not just this driver's child. See
 ``test_no_image_name_kill_path_exists_in_the_module`` — a source-level
 regression guard, not just a behavioral one.
 
+**UNC ``cwd`` (#3543).** A WSL-hosted agent's repo worktree translates
+(``coord.win_native_bridge.translate_to_windows_path``) to a UNC path
+(``\\wsl.localhost\\Ubuntu-24.04\\...``) — the normal case for dell64, this
+fleet's only WSL-hosted ``windows``-capability agent. ``cmd.exe`` (what
+``subprocess.Popen(..., shell=True)`` always launches on Windows)
+categorically refuses a UNC current directory at its own startup and
+silently falls back to ``%windir%`` instead, breaking every relative path
+in ``run_command``. :func:`_popen_command_and_cwd` folds cmd.exe's own
+``pushd`` UNC-to-drive-letter workaround into the launched command for a
+UNC ``cwd`` rather than ever handing cmd.exe one directly; see
+:class:`Win32Calls`'s :meth:`~Win32Calls.launch`/
+:meth:`~Win32Calls.launch_in_terminal`.
+
 **Spec steps** (:func:`parse_native_spec`, YAML — the ``win-native``
 sibling of ``tui-pty``'s smoke spec):
 
@@ -370,11 +383,18 @@ class WinCalls(Protocol):
     def launch_in_terminal(self, command: str, cwd: str, terminal_app: str) -> int: ...
 
     def find_top_window(self, pid: int, timeout_s: float) -> int:
-        """Poll for the launched process's real top-level window, returning
-        its handle once found. Raises :class:`WinNativeRuntimeError` if none
-        appears within *timeout_s* — this is the "launch" step's own
-        confirmation that the process didn't just start, but actually
-        produced a window (#2096)."""
+        """Poll for *pid*'s (or one of its descendant processes') real
+        top-level window, returning its handle once found. Raises
+        :class:`WinNativeRuntimeError` if none appears within *timeout_s* —
+        this is the "launch" step's own confirmation that the process
+        didn't just start, but actually produced a window (#2096).
+
+        *pid* is not always the real app's own pid: ``subprocess.Popen(...,
+        shell=True)`` on Windows spawns ``cmd.exe`` as the immediate child
+        and returns *its* pid, while the real app (e.g. ``vimcode.exe``) is
+        a grandchild with a different pid that ``cmd.exe`` itself never
+        owns a window for (#3542). Implementations must search *pid*'s
+        whole descendant-process tree, not just *pid* itself."""
         ...
 
     def move_window(self, hwnd: int, x: int, y: int, width: int, height: int) -> None: ...
@@ -755,6 +775,41 @@ def _vkey_for(key: str) -> tuple[int, bool]:
     raise WinNativeSpecError(f"unrecognized key {key!r}")
 
 
+def _is_unc_path(path: str) -> bool:
+    """True for a UNC path (``\\\\server\\share\\...``) — the shape
+    :func:`coord.win_native_bridge.translate_to_windows_path` returns for a
+    WSL-hosted repo (``\\\\wsl.localhost\\<distro>\\...``, #3543)."""
+    return path.startswith("\\\\")
+
+
+def _popen_command_and_cwd(command: str, cwd: str) -> tuple[str, str | None]:
+    """Resolve the ``command``/``cwd`` pair to actually hand
+    ``subprocess.Popen(..., shell=True)`` (#3543).
+
+    ``shell=True`` on Windows always runs *command* via ``cmd.exe /c`` —
+    and cmd.exe's own startup categorically refuses a UNC current
+    directory: confirmed directly (``cmd.exe /c "cd \\\\wsl.localhost\\...
+    && dir"`` prints "CMD does not support UNC paths as current
+    directories.") and **silently** falls back to ``%windir%``
+    (``C:\\Windows\\System32``) instead of raising — this is cmd.exe's own
+    initialization check, not a ``CreateProcess``/``lpCurrentDirectory``
+    limitation (that accepts a UNC path fine, which is exactly why the
+    failure is silent: nothing downstream of ``Popen`` ever sees an error,
+    every relative path in *command* just silently resolves against the
+    wrong directory instead).
+
+    For a UNC *cwd* this folds cmd.exe's own standard UNC workaround —
+    ``pushd`` (maps an unused drive letter to the UNC path, cds into it) —
+    into *command* itself, and returns ``cwd=None`` so ``Popen`` never
+    hands cmd.exe a UNC starting directory it cannot use in the first
+    place. A non-UNC (drive-letter) *cwd* is returned unchanged — the
+    common case, where ``Popen``'s own ``cwd=`` already works correctly.
+    """
+    if cwd and _is_unc_path(cwd):
+        return f'pushd "{cwd}" && {command}', None
+    return command, (cwd or None)
+
+
 class Win32Calls:
     """The real :class:`WinCalls` implementation — ``ctypes`` for window
     management, input injection, menu/hit-test probing and ``PrintWindow``;
@@ -782,7 +837,8 @@ class Win32Calls:
     # -- process lifecycle --
 
     def launch(self, command: str, cwd: str) -> int:
-        proc = subprocess.Popen(command, shell=True, cwd=cwd or None)
+        full_command, popen_cwd = _popen_command_and_cwd(command, cwd)
+        proc = subprocess.Popen(full_command, shell=True, cwd=popen_cwd)
         return proc.pid
 
     def launch_in_terminal(self, command: str, cwd: str, terminal_app: str) -> int:
@@ -791,8 +847,9 @@ class Win32Calls:
             full_command = f"wt.exe {command}"
         else:
             full_command = command
+        full_command, popen_cwd = _popen_command_and_cwd(full_command, cwd)
         proc = subprocess.Popen(
-            full_command, shell=True, cwd=cwd or None, creationflags=create_new_console,
+            full_command, shell=True, cwd=popen_cwd, creationflags=create_new_console,
         )
         return proc.pid
 
@@ -857,12 +914,28 @@ class Win32Calls:
 
     def _logonui_running_in_session(self, session_id: int) -> bool:
         """``True`` iff ``LogonUI.exe`` (the Windows lock-screen host
-        process) is running in *session_id* — walked via a
-        ``CreateToolhelp32Snapshot`` process snapshot, the same mechanism
-        Task Manager itself uses, rather than anything that could be
-        confused by a differently-named process (the module docstring's
-        "kill only the PID this driver itself launched" safety note applies
-        equally here: this is read-only enumeration, never a kill)."""
+        process) is running in *session_id* — walked via
+        :meth:`_snapshot_processes`, the same mechanism Task Manager itself
+        uses, rather than anything that could be confused by a differently-
+        named process (the module docstring's "kill only the PID this
+        driver itself launched" safety note applies equally here: this is
+        read-only enumeration, never a kill)."""
+        ctypes = self._ctypes
+        for pid, _ppid, name in self._snapshot_processes():
+            if name.lower() == "logonui.exe":
+                proc_session = ctypes.wintypes.DWORD()
+                self._kernel32.ProcessIdToSessionId(pid, ctypes.byref(proc_session))
+                if proc_session.value == session_id:
+                    return True
+        return False
+
+    def _snapshot_processes(self) -> list[tuple[int, int, str]]:
+        """Every currently running process as ``(pid, parent_pid,
+        exe_name)``, via a single ``CreateToolhelp32Snapshot`` walk — the
+        same mechanism Task Manager itself uses. Read-only enumeration,
+        shared by :meth:`_logonui_running_in_session` (#3510) and
+        :meth:`_descendant_pids` (#3542); never used to kill (see the
+        module docstring's safety note)."""
         ctypes = self._ctypes
         kernel32 = self._kernel32
         TH32CS_SNAPPROCESS = 0x00000002
@@ -880,48 +953,81 @@ class Win32Calls:
 
         snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
         if not snapshot or snapshot == -1:
-            return False
+            return []
+        out: list[tuple[int, int, str]] = []
         try:
             entry = PROCESSENTRY32()
             entry.dwSize = ctypes.sizeof(PROCESSENTRY32)
             if not kernel32.Process32First(snapshot, ctypes.byref(entry)):
-                return False
+                return []
             while True:
                 name = entry.szExeFile.decode("mbcs", errors="ignore")
-                if name.lower() == "logonui.exe":
-                    proc_session = ctypes.wintypes.DWORD()
-                    kernel32.ProcessIdToSessionId(
-                        entry.th32ProcessID, ctypes.byref(proc_session),
-                    )
-                    if proc_session.value == session_id:
-                        return True
+                out.append((entry.th32ProcessID, entry.th32ParentProcessID, name))
                 if not kernel32.Process32Next(snapshot, ctypes.byref(entry)):
-                    return False
+                    break
         finally:
             kernel32.CloseHandle(snapshot)
+        return out
+
+    def _descendant_pids(self, root_pid: int) -> set[int]:
+        """*root_pid* plus every process it transitively spawned (child,
+        grandchild, ...) — a fresh :meth:`_snapshot_processes` walk each
+        call, since the real app may not have started yet the first time
+        this is polled.
+
+        #3542: ``launch``/``launch_in_terminal`` don't always return the
+        real app's own pid — ``subprocess.Popen(..., shell=True)`` returns
+        ``cmd.exe``'s pid, with the real app (``vimcode.exe``) a grandchild
+        that ``cmd.exe`` itself never owns a window for. Searching the
+        whole descendant tree finds the real app's window regardless of
+        how many shell/console hosts sit between the returned pid and it.
+        """
+        children: dict[int, list[int]] = {}
+        for pid, ppid, _name in self._snapshot_processes():
+            children.setdefault(ppid, []).append(pid)
+        result = {root_pid}
+        frontier = [root_pid]
+        while frontier:
+            current = frontier.pop()
+            for child in children.get(current, ()):
+                if child not in result:
+                    result.add(child)
+                    frontier.append(child)
+        return result
 
     def find_top_window(self, pid: int, timeout_s: float) -> int:
         ctypes = self._ctypes
         deadline = time.monotonic() + timeout_s
         found: list[int] = []
-
-        @ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+        candidate_pids: set[int] = {pid}
+        # `WINFUNCTYPE` (stdcall) only exists in ctypes on real Windows —
+        # real runs always go through it (Win32Calls.__init__ guards
+        # off-Windows construction), but falling back to `CFUNCTYPE` off-
+        # Windows is what lets this method's descendant-walk logic be
+        # exercised by a scripted fake on Linux/macOS too (#3542), the same
+        # "unit-testable on any platform" seam the module docstring
+        # describes for the rest of this class.
+        win_functype = getattr(ctypes, "WINFUNCTYPE", ctypes.CFUNCTYPE)
+
+        @win_functype(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
         def _enum_proc(hwnd, _lparam):
             owner_pid = ctypes.wintypes.DWORD()
             self._user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner_pid))
-            if owner_pid.value == pid and self._user32.IsWindowVisible(hwnd):
+            if owner_pid.value in candidate_pids and self._user32.IsWindowVisible(hwnd):
                 found.append(hwnd)
                 return False
             return True
 
         while time.monotonic() < deadline:
+            candidate_pids = self._descendant_pids(pid)
             found.clear()
             self._user32.EnumWindows(_enum_proc, 0)
             if found:
                 return found[0]
             time.sleep(0.1)
         raise WinNativeRuntimeError(
-            f"no visible top-level window appeared for pid={pid} within {timeout_s}s"
+            f"no visible top-level window appeared for pid={pid} or any of "
+            f"its child processes within {timeout_s}s"
         )
 
     def is_window_alive(self, hwnd: int) -> bool:

{code_coordinator-0.5.570 → code_coordinator-0.5.572}/tests/test_win_native_driver.py

@@ -28,6 +28,8 @@ from coord.win_native_driver import (
     WinNativeSpecError,
     Win32Calls,
     _find_a11y_match,
+    _is_unc_path,
+    _popen_command_and_cwd,
     _summarize_elements,
     _vkey_for,
     parse_native_spec,
@@ -888,6 +890,162 @@ def _make_win32_calls(user32, kernel32) -> Win32Calls:
     return calls
 
 
+class _FakeKernel32ProcessTree:
+    """``CreateToolhelp32Snapshot``/``Process32First``/``Process32Next``
+    stand-in that replays a scripted list of ``(pid, parent_pid,
+    exe_name)`` rows — enough for :meth:`Win32Calls._snapshot_processes`
+    and :meth:`Win32Calls._descendant_pids` (#3542) to walk a fake process
+    tree exactly the way they'd walk a real one."""
+
+    def __init__(self, processes: list[tuple[int, int, bytes]]) -> None:
+        self._processes = processes
+        self._iter = iter(())
+
+    def CreateToolhelp32Snapshot(self, *_args, **_kwargs):
+        return 1  # non-zero, non -1 "handle"
+
+    def Process32First(self, _snapshot, entry_ref) -> bool:
+        self._iter = iter(self._processes)
+        return self._advance(entry_ref)
+
+    def Process32Next(self, _snapshot, entry_ref) -> bool:
+        return self._advance(entry_ref)
+
+    def _advance(self, entry_ref) -> bool:
+        try:
+            pid, ppid, name = next(self._iter)
+        except StopIteration:
+            return False
+        entry = ctypes.cast(entry_ref, ctypes.POINTER(_ProcessEntry32Mirror)).contents
+        entry.th32ProcessID = pid
+        entry.th32ParentProcessID = ppid
+        entry.szExeFile = name
+        return True
+
+    def CloseHandle(self, _handle) -> None:
+        pass
+
+
+class _FakeUser32Windows:
+    """``EnumWindows``/``GetWindowThreadProcessId``/``IsWindowVisible``
+    stand-in: *windows* maps a fake ``hwnd`` to ``(owner_pid, visible)``.
+    ``EnumWindows`` replays them in insertion order and stops as soon as
+    the real callback returns ``False`` (a match), exactly like the real
+    Win32 ``EnumWindows`` short-circuiting on its callback's return value.
+    """
+
+    def __init__(self, windows: dict[int, tuple[int, bool]]) -> None:
+        self._windows = windows
+
+    def EnumWindows(self, callback, lparam) -> None:
+        for hwnd, (_owner_pid, _visible) in self._windows.items():
+            if not callback(hwnd, lparam):
+                break
+
+    def GetWindowThreadProcessId(self, hwnd, owner_pid_ref) -> None:
+        owner_pid_ref._obj.value = self._windows[hwnd][0]
+
+    def IsWindowVisible(self, hwnd) -> bool:
+        return self._windows[hwnd][1]
+
+
+class TestFindTopWindowFollowsDescendantProcesses:
+    """#3542: ``Win32Calls.launch()`` is ``subprocess.Popen(command,
+    shell=True)``, which on Windows always spawns ``cmd.exe`` as the
+    immediate child and returns *its* pid — the real GUI app
+    (``vimcode.exe``) is a grandchild with a different pid, and ``cmd.exe``
+    itself never owns a window. These tests reproduce that exact shape with
+    a fake process tree + fake window table and confirm
+    ``find_top_window`` now searches the whole descendant tree rather than
+    matching the returned pid alone."""
+
+    def test_follows_shell_wrapped_launch_to_the_real_apps_window(self) -> None:
+        cmd_pid, vimcode_pid = 4242, 4321
+        kernel32 = _FakeKernel32ProcessTree([
+            (1, 0, b"System"),
+            (cmd_pid, 1, b"cmd.exe"),
+            (vimcode_pid, cmd_pid, b"vimcode.exe"),
+        ])
+        # cmd.exe (cmd_pid) owns no window at all — only its child does.
+        user32 = _FakeUser32Windows({777: (vimcode_pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        assert calls.find_top_window(cmd_pid, timeout_s=1.0) == 777
+
+    def test_follows_a_grandchild_process_two_levels_deep(self) -> None:
+        wt_pid, conhost_pid, app_pid = 10, 20, 30
+        kernel32 = _FakeKernel32ProcessTree([
+            (wt_pid, 1, b"wt.exe"),
+            (conhost_pid, wt_pid, b"OpenConsole.exe"),
+            (app_pid, conhost_pid, b"vimcode.exe"),
+        ])
+        user32 = _FakeUser32Windows({99: (app_pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        assert calls.find_top_window(wt_pid, timeout_s=1.0) == 99
+
+    def test_still_matches_when_the_launched_pid_owns_the_window_directly(
+        self,
+    ) -> None:
+        """Backward-compatible: an exe launched without an intervening
+        shell still has its own pid in its own descendant set (the root is
+        always included), so the pre-#3542 direct-match case keeps
+        working."""
+        pid = 555
+        kernel32 = _FakeKernel32ProcessTree([(pid, 1, b"vimcode.exe")])
+        user32 = _FakeUser32Windows({1: (pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        assert calls.find_top_window(pid, timeout_s=1.0) == 1
+
+    def test_ignores_invisible_windows_even_on_a_matching_descendant(
+        self,
+    ) -> None:
+        cmd_pid, vimcode_pid = 1, 2
+        kernel32 = _FakeKernel32ProcessTree([
+            (cmd_pid, 0, b"cmd.exe"), (vimcode_pid, cmd_pid, b"vimcode.exe"),
+        ])
+        user32 = _FakeUser32Windows({9: (vimcode_pid, False)})
+        calls = _make_win32_calls(user32, kernel32)
+        with pytest.raises(WinNativeRuntimeError, match="no visible top-level window"):
+            calls.find_top_window(cmd_pid, timeout_s=0.05)
+
+    def test_raises_when_no_descendant_owns_any_window(self) -> None:
+        cmd_pid = 1
+        kernel32 = _FakeKernel32ProcessTree([(cmd_pid, 0, b"cmd.exe")])
+        user32 = _FakeUser32Windows({})
+        calls = _make_win32_calls(user32, kernel32)
+        with pytest.raises(WinNativeRuntimeError, match=f"pid={cmd_pid}"):
+            calls.find_top_window(cmd_pid, timeout_s=0.05)
+
+    def test_unrelated_processes_window_is_not_matched(self) -> None:
+        """A visible window owned by some other, unrelated process must
+        never be treated as a match just because it exists."""
+        cmd_pid, vimcode_pid, unrelated_pid = 1, 2, 999
+        kernel32 = _FakeKernel32ProcessTree([
+            (cmd_pid, 0, b"cmd.exe"), (vimcode_pid, cmd_pid, b"vimcode.exe"),
+        ])
+        user32 = _FakeUser32Windows({8: (unrelated_pid, True)})
+        calls = _make_win32_calls(user32, kernel32)
+        with pytest.raises(WinNativeRuntimeError):
+            calls.find_top_window(cmd_pid, timeout_s=0.05)
+
+
+class TestDescendantPids:
+    def test_includes_root_and_all_transitive_children(self) -> None:
+        kernel32 = _FakeKernel32ProcessTree([
+            (1, 0, b"System"),
+            (10, 1, b"cmd.exe"),
+            (20, 10, b"vimcode.exe"),
+            (30, 20, b"helper.exe"),
+            (999, 1, b"unrelated.exe"),
+        ])
+        calls = _make_win32_calls(_FakeUser32Windows({}), kernel32)
+        assert calls._descendant_pids(10) == {10, 20, 30}
+
+    def test_pid_with_no_children_returns_itself_only(self) -> None:
+        kernel32 = _FakeKernel32ProcessTree([(10, 1, b"vimcode.exe")])
+        calls = _make_win32_calls(_FakeUser32Windows({}), kernel32)
+        assert calls._descendant_pids(10) == {10}
+
+
 class TestSessionAvailable:
     """#3521: ``WTSGetActiveConsoleSessionId`` lives on kernel32, not
     wtsapi32 — the old code crashed every win-native run with an
@@ -945,6 +1103,130 @@ class TestSessionAvailable:
         assert "OpenInputDesktop" in reason
 
 
+# ── UNC cwd (#3543) ──────────────────────────────────────────────────────────
+
+
+class TestIsUncPath:
+    def test_unc_path_is_detected(self) -> None:
+        assert _is_unc_path(r"\\wsl.localhost\Ubuntu-24.04\home\me\repo")
+
+    def test_drive_letter_path_is_not_unc(self) -> None:
+        assert not _is_unc_path(r"C:\Users\me\repo")
+
+    def test_empty_string_is_not_unc(self) -> None:
+        assert not _is_unc_path("")
+
+
+class TestPopenCommandAndCwd:
+    """#3543: `translate_to_windows_path` renders a WSL-hosted repo's `cwd`
+    as a UNC path (`\\wsl.localhost\\...`), but `cmd.exe` — what
+    `subprocess.Popen(..., shell=True)` always launches on Windows —
+    categorically refuses a UNC current directory at its own startup and
+    silently falls back to `%windir%`, breaking every relative path in the
+    launched command. These are the "fails first" unit-level reproduction
+    the issue's acceptance bar asks for: without the `pushd` fold-in below,
+    `_popen_command_and_cwd` would hand `Popen` a `cwd=` cmd.exe cannot
+    use."""
+
+    def test_unc_cwd_is_folded_into_a_pushd_prefix_and_cwd_is_cleared(self) -> None:
+        unc = r"\\wsl.localhost\Ubuntu-24.04\home\me\repo"
+        command, cwd = _popen_command_and_cwd("../target/app.exe sample.txt", unc)
+        assert command == f'pushd "{unc}" && ../target/app.exe sample.txt'
+        # Never hand cmd.exe a UNC `cwd=` — it refuses it regardless of
+        # what the command string itself does.
+        assert cwd is None
+
+    def test_drive_letter_cwd_passes_through_unchanged(self) -> None:
+        command, cwd = _popen_command_and_cwd("app.exe", r"C:\Users\me\repo")
+        assert command == "app.exe"
+        assert cwd == r"C:\Users\me\repo"
+
+    def test_empty_cwd_passes_through_as_none(self) -> None:
+        command, cwd = _popen_command_and_cwd("app.exe", "")
+        assert command == "app.exe"
+        assert cwd is None
+
+
+class TestWin32CallsLaunchAvoidsUncCwd:
+    """#3543: `Win32Calls.launch`/`launch_in_terminal` must never hand
+    `subprocess.Popen(..., shell=True)` a UNC `cwd=` — reproduces the exact
+    bridge-to-Windows shape (`run_native_spec_via_bridge` translates this
+    repo's WSL-hosted worktree to a UNC path and hands it to `launch`)
+    against a scripted fake `subprocess.Popen`, since the real cmd.exe
+    UNC-refusal behaviour can only be observed on a real Windows host."""
+
+    def test_launch_never_passes_a_unc_cwd_to_popen(self, monkeypatch) -> None:
+        unc = r"\\wsl.localhost\Ubuntu-24.04\home\me\repo"
+        calls = _make_win32_calls(_FakeUser32(), _FakeKernel32NoSession())
+        captured: dict = {}
+
+        class _FakeProc:
+            pid = 4242
+
+        def fake_popen(command, *, shell, cwd=None, **kwargs):
+            captured["command"] = command
+            captured["cwd"] = cwd
+            captured["shell"] = shell
+            return _FakeProc()
+
+        monkeypatch.setattr(
+            "coord.win_native_driver.subprocess.Popen", fake_popen,
+        )
+        pid = calls.launch("cd .smoke && ../target/app.exe sample.txt", unc)
+        assert pid == 4242
+        assert captured["shell"] is True
+        assert captured["cwd"] is None  # never a UNC cwd handed to Popen
+        assert captured["command"] == (
+            f'pushd "{unc}" && cd .smoke && ../target/app.exe sample.txt'
+        )
+
+    def test_launch_in_terminal_never_passes_a_unc_cwd_to_popen(
+        self, monkeypatch,
+    ) -> None:
+        unc = r"\\wsl.localhost\Ubuntu-24.04\home\me\repo"
+        calls = _make_win32_calls(_FakeUser32(), _FakeKernel32NoSession())
+        captured: dict = {}
+
+        class _FakeProc:
+            pid = 9999
+
+        def fake_popen(command, *, shell, cwd=None, **kwargs):
+            captured["command"] = command
+            captured["cwd"] = cwd
+            return _FakeProc()
+
+        monkeypatch.setattr(
+            "coord.win_native_driver.subprocess.Popen", fake_popen,
+        )
+        pid = calls.launch_in_terminal("app.exe", unc, "windows-terminal")
+        assert pid == 9999
+        assert captured["cwd"] is None
+        assert captured["command"] == f'pushd "{unc}" && wt.exe app.exe'
+
+    def test_launch_with_drive_letter_cwd_still_uses_popens_cwd(
+        self, monkeypatch,
+    ) -> None:
+        """Backward-compatible: the common (non-WSL) case keeps relying on
+        `Popen`'s own `cwd=`, not a `pushd` prefix."""
+        calls = _make_win32_calls(_FakeUser32(), _FakeKernel32NoSession())
+        captured: dict = {}
+
+        class _FakeProc:
+            pid = 1
+
+        def fake_popen(command, *, shell, cwd=None, **kwargs):
+            captured["command"] = command
+            captured["cwd"] = cwd
+            return _FakeProc()
+
+        monkeypatch.setattr(
+            "coord.win_native_driver.subprocess.Popen", fake_popen,
+        )
+        calls.launch("app.exe", r"C:\Users\me\repo")
+        assert captured["command"] == "app.exe"
+        assert captured["cwd"] == r"C:\Users\me\repo"
+
+
 class TestImportUia:
     def test_missing_comtypes_raises_actionable_error(self, monkeypatch) -> None:
         import builtins