swarph-cli 0.9.4__tar.gz → 0.9.5__tar.gz

{swarph_cli-0.9.4/src/swarph_cli.egg-info → swarph_cli-0.9.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.4
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd.
+Version: 0.9.5
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION).
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.4 → swarph_cli-0.9.5}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.9.4"
-description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd."
+version = "0.9.5"
+description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION)."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{swarph_cli-0.9.4 → swarph_cli-0.9.5}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.9.4"
+__version__ = "0.9.5"
 
 __all__ = ["__version__"]

{swarph_cli-0.9.4 → swarph_cli-0.9.5}/src/swarph_cli/commands/spawn.py

@@ -481,6 +481,92 @@ def _print_dry_run(
     print(" ".join(redacted))
 
 
+def _console_is_genuine_wt() -> bool:
+    """True ONLY if the controlling terminal is positively a real Windows Terminal.
+
+    Confirms a genuine Windows Terminal by walking the parent-process chain (via the
+    Win32 toolhelp snapshot API) and checking whether any ancestor process executable
+    is ``WindowsTerminal.exe`` (case-insensitive). This is GROUND TRUTH, unlike the
+    ``WT_SESSION`` environment variable — which is inherited into child ``conhost``
+    consoles on corporate setups, and is set whenever a shell is launched from WT at
+    all, so it cannot distinguish "this console is a real WT" from "an ancestor once
+    was, but I'm now in a broken conhost".
+
+    Returns False on any non-win32 platform (the whole relaunch is win32-gated). The
+    ENTIRE Win32 body is wrapped in ``try/except Exception: return False`` so any
+    error — missing API, weird process state, access denied — fails SAFE toward
+    "not confirmed", which makes the caller RELAUNCH (the foolproof direction).
+
+    This helper is the ONLY piece that touches ctypes/Win32 and cannot be exercised
+    on a non-Windows box; the decision logic around it is fully unit-tested via mocks.
+    """
+    if sys.platform != "win32":
+        return False
+    try:
+        import ctypes
+        from ctypes import wintypes
+
+        TH32CS_SNAPPROCESS = 0x00000002
+        MAX_PATH = 260
+
+        class PROCESSENTRY32(ctypes.Structure):
+            _fields_ = [
+                ("dwSize", wintypes.DWORD),
+                ("cntUsage", wintypes.DWORD),
+                ("th32ProcessID", wintypes.DWORD),
+                ("th32DefaultHeapID", ctypes.POINTER(ctypes.c_ulong)),
+                ("th32ModuleID", wintypes.DWORD),
+                ("cntThreads", wintypes.DWORD),
+                ("th32ParentProcessID", wintypes.DWORD),
+                ("pcPriClassBase", ctypes.c_long),
+                ("dwFlags", wintypes.DWORD),
+                ("szExeFile", ctypes.c_char * MAX_PATH),
+            ]
+
+        kernel32 = ctypes.windll.kernel32  # type: ignore[attr-defined]
+        snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
+        INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
+        if not snapshot or snapshot == INVALID_HANDLE_VALUE:
+            return False
+        try:
+            # Build {pid: (ppid, exe_name_lower)} for every live process.
+            procs: dict[int, tuple[int, str]] = {}
+            entry = PROCESSENTRY32()
+            entry.dwSize = ctypes.sizeof(PROCESSENTRY32)
+            ok = kernel32.Process32First(snapshot, ctypes.byref(entry))
+            while ok:
+                try:
+                    exe = entry.szExeFile.decode("utf-8", "replace").lower()
+                except Exception:
+                    exe = ""
+                procs[int(entry.th32ProcessID)] = (
+                    int(entry.th32ParentProcessID),
+                    exe,
+                )
+                ok = kernel32.Process32Next(snapshot, ctypes.byref(entry))
+        finally:
+            kernel32.CloseHandle(snapshot)
+
+        # Walk from our own pid up through ppids; bounded + cycle-guarded.
+        pid = os.getpid()
+        seen: set[int] = set()
+        for _ in range(12):
+            if pid in seen or pid == 0:
+                break
+            seen.add(pid)
+            info = procs.get(pid)
+            if info is None:
+                break
+            ppid, _exe = info
+            parent = procs.get(ppid)
+            if parent is not None and parent[1] == "windowsterminal.exe":
+                return True
+            pid = ppid
+        return False
+    except Exception:
+        return False
+
+
 def _relaunch_in_windows_terminal(
     claude_bin: str, claude_argv: list[str], cwd: Path,
 ) -> bool:
@@ -489,24 +575,28 @@ def _relaunch_in_windows_terminal(
     On legacy Windows console (``conhost.exe``), Claude Code's Ink TUI breaks: the
     SGR terminator ``m`` leaks from the output stream into stdin, so pressing Enter
     inserts a literal ``m`` instead of submitting (see docs/WINDOWS_KNOWN_ISSUES.md).
-    Windows Terminal handles VT-input correctly. If we're on conhost AND ``wt.exe``
-    is available, relaunch the ``claude`` session inside Windows Terminal and return
-    True (the caller should exit this console). Otherwise return False (caller
-    proceeds in-place and warns).
+    Windows Terminal handles VT-input correctly. The DEFAULT is to relaunch (rescue):
+    unless we can POSITIVELY confirm we're already in a genuine Windows Terminal, we
+    pop a fresh WT window and return True (the caller should exit this console).
+
+    Genuine-WT detection is via process ancestry (``_console_is_genuine_wt``), NOT the
+    inheritable ``WT_SESSION`` env var — which wrongly looked like "already in good WT"
+    on corporate conhosts and on any shell launched from WT, leaving users stuck on a
+    broken console with no new window (live repro 2026-06-03 on workstation-lc).
+
+    Two env overrides:
+      * ``SWARPH_FORCE_WT=1`` — ALWAYS relaunch, even from a genuine Windows Terminal;
+      * ``SWARPH_WIN_ACK=1``  — NEVER relaunch (explicit "run here anyway" opt-out).
 
     No-op (returns False) when:
       * not Windows;
       * stdout is not an interactive TTY (CI / piped / redirected) — there is no
         human console to relaunch from, and a detached WT window would be wrong;
       * we are already inside a session WE spawned (``SWARPH_SPAWN`` set) — the
-        reliable loop-guard: a relaunched session can never re-relaunch, regardless
-        of how ``WT_SESSION`` behaves on this box;
+        reliable loop-guard: a relaunched session can never re-relaunch;
       * operator opted to stay put (``SWARPH_WIN_ACK=1``);
-      * already inside Windows Terminal (``WT_SESSION`` set) AND not force-requested
-        — the TUI works there. NOTE: some corporate setups INHERIT ``WT_SESSION``
-        into child ``conhost`` consoles, so this is a comfort heuristic, not ground
-        truth. Set ``SWARPH_FORCE_WT=1`` to relaunch anyway when you know you are on
-        a broken conhost that carries an inherited ``WT_SESSION``;
+      * we positively confirm a genuine Windows Terminal via ancestry AND not
+        force-requested — the TUI works there, no redundant window;
       * ``wt.exe`` is not installed (e.g. locked-down corporate box) — caller warns.
     """
     if sys.platform != "win32":
@@ -517,7 +607,12 @@ def _relaunch_in_windows_terminal(
         return False
     if os.environ.get("SWARPH_WIN_ACK"):
         return False
-    if os.environ.get("WT_SESSION") and not os.environ.get("SWARPH_FORCE_WT"):
+    # Skip the relaunch ONLY when we can positively confirm we're already in a
+    # genuine Windows Terminal (TUI works there) — verified by process ancestry,
+    # NOT the inheritable WT_SESSION env var. Default is to relaunch (rescue):
+    # if we can't confirm a good WT, we pop a fresh one. SWARPH_FORCE_WT forces
+    # relaunch even from a genuine WT.
+    if not os.environ.get("SWARPH_FORCE_WT") and _console_is_genuine_wt():
         return False
     wt = shutil.which("wt")
     if not wt:
@@ -645,13 +740,14 @@ class ClaudeMembrane(ProviderMembrane):
             return 0
 
         # Still in a broken console (conhost with no wt.exe, or operator acked).
-        # Warn unless suppressed. Inside Windows Terminal (WT_SESSION set) the
-        # TUI works, so no warning fires there.
+        # Warn unless suppressed. Inside a genuine Windows Terminal (confirmed by
+        # ancestry, NOT the inheritable WT_SESSION) the TUI works, so no warning
+        # fires there.
         if (
             sys.platform == "win32"
             and not no_banner
             and not os.environ.get("SWARPH_WIN_ACK")
-            and not os.environ.get("WT_SESSION")
+            and not _console_is_genuine_wt()
         ):
             print(
                 "swarph spawn: WARNING — legacy Windows console (conhost) and Windows "

{swarph_cli-0.9.4 → swarph_cli-0.9.5/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.4
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.4: fixes session-pin resume across a changed cwd.
+Version: 0.9.5
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider `swarph spawn` (claude/codex/antigravity per cell.provider via a ProviderMembrane + subprocess billing-scrub), interactive `swarph init`, `swarph mesh` (send/inbox/register) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.5: foolproof Windows auto-relaunch (genuine-WT detection via process ancestry, not WT_SESSION).
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

swarph_cli-0.9.5/tests/test_spawn_windows_relaunch.py

@@ -0,0 +1,168 @@
+"""Tests for `swarph spawn`'s Windows-Terminal conhost auto-relaunch.
+
+On legacy Windows console (conhost.exe), Claude Code's Ink TUI breaks — the SGR
+terminator 'm' leaks into stdin so Enter inserts a literal 'm'. `_relaunch_in_
+windows_terminal` auto-relaunches the session in Windows Terminal (where the TUI
+works) by DEFAULT, and only stays put when it can POSITIVELY confirm a genuine
+Windows Terminal via process ancestry (`_console_is_genuine_wt`) — no longer the
+inheritable `WT_SESSION` env var, which fooled the old heuristic (live repro
+2026-06-03 on workstation-lc: launching from WT set WT_SESSION → relaunch wrongly
+skipped → no new window).
+
+The ACTUAL wt.exe relaunch + the ctypes ancestry walk need a real native-Windows
+box; these tests pin the DECISION logic (relaunch vs warn vs proceed) by mocking
+`_console_is_genuine_wt` directly, so they run on any platform.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from swarph_cli.commands import spawn
+
+CLAUDE_BIN = "/usr/bin/claude"
+CLAUDE_ARGV = ["claude", "--name", "lab", "--session-id", "abc"]
+CWD = Path("/home/ubuntu/lab")
+WT = "C:\\Windows\\wt.exe"
+
+
+class _FakeStdout:
+    """Minimal stand-in so tests can control sys.stdout.isatty() — the helper
+    only ever calls .isatty() on stdout (its prints go to stderr)."""
+
+    def __init__(self, tty):
+        self._tty = tty
+
+    def isatty(self):
+        return self._tty
+
+
+def _call(monkeypatch, *, platform="win32", genuine_wt=False, wt_session=None,
+          win_ack=None, spawn_marker=None, force_wt=None, isatty=True,
+          wt_path=WT, popen=None):
+    """Drive `_relaunch_in_windows_terminal` with the genuine-WT detector mocked.
+
+    `genuine_wt` patches `_console_is_genuine_wt` directly (True/False) so we test
+    the DECISION matrix without touching ctypes. `wt_session` is still settable in
+    the env to prove the new logic IGNORES it (the headline bug fix).
+    """
+    monkeypatch.setattr(spawn.sys, "platform", platform)
+    monkeypatch.setattr(spawn.sys, "stdout", _FakeStdout(isatty))
+    for var, val in (("WT_SESSION", wt_session), ("SWARPH_WIN_ACK", win_ack),
+                     ("SWARPH_SPAWN", spawn_marker), ("SWARPH_FORCE_WT", force_wt)):
+        if val is None:
+            monkeypatch.delenv(var, raising=False)
+        else:
+            monkeypatch.setenv(var, val)
+    monkeypatch.setattr(spawn, "_console_is_genuine_wt", lambda: genuine_wt)
+    monkeypatch.setattr(spawn.shutil, "which",
+                        lambda name: wt_path if name == "wt" else None)
+    pop = popen or MagicMock()
+    monkeypatch.setattr(spawn.subprocess, "Popen", pop)
+    result = spawn._relaunch_in_windows_terminal(CLAUDE_BIN, CLAUDE_ARGV, CWD)
+    return result, pop
+
+
+# --- the decision matrix -------------------------------------------------
+
+
+def test_non_windows_never_relaunches(monkeypatch):
+    r, pop = _call(monkeypatch, platform="linux")
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_conhost_with_wt_relaunches_in_windows_terminal(monkeypatch):
+    # #1 the rescue: NOT a genuine WT (conhost) + wt.exe present => relaunch.
+    r, pop = _call(monkeypatch, genuine_wt=False)
+    assert r is True
+    pop.assert_called_once()
+    cmd = pop.call_args[0][0]
+    # exact shape: [wt, -d, <cwd>, --, claude_bin, *claude_flags]
+    assert cmd[:5] == [WT, "-d", str(CWD), "--", CLAUDE_BIN]
+    assert cmd[5:] == CLAUDE_ARGV[1:]   # claude_argv[1:] passed through (not argv0)
+    # carries SWARPH_SPAWN=1 so the SessionStart hook doesn't double-inject
+    assert pop.call_args.kwargs["env"]["SWARPH_SPAWN"] == "1"
+
+
+def test_genuine_wt_no_force_skips_relaunch(monkeypatch):
+    # #2 positively confirmed genuine WT (TUI works) + no force => no new window.
+    r, pop = _call(monkeypatch, genuine_wt=True)
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_inherited_wt_session_but_not_genuine_wt_relaunches(monkeypatch):
+    # #3 THE HEADLINE BUG FIX: WT_SESSION is set in the env (inherited into a
+    # broken conhost, OR set because the shell was launched from WT), but process
+    # ancestry says this is NOT a genuine WT. New logic IGNORES WT_SESSION and
+    # relaunches. The old WT_SESSION-keyed code would have wrongly SKIPPED here,
+    # leaving the user stuck on a broken console with no new window.
+    r, pop = _call(monkeypatch, genuine_wt=False, wt_session="inherited-guid")
+    assert r is True
+    pop.assert_called_once()
+
+
+def test_force_wt_overrides_genuine_wt(monkeypatch):
+    # #4 SWARPH_FORCE_WT=1 forces the relaunch even from a confirmed genuine WT.
+    r, pop = _call(monkeypatch, genuine_wt=True, force_wt="1")
+    assert r is True
+    pop.assert_called_once()
+
+
+def test_win_ack_opt_out_skips_even_on_conhost(monkeypatch):
+    # #5 SWARPH_WIN_ACK=1 => operator chose to run here; skip even on a broken
+    # conhost (genuine_wt=False) with wt present.
+    r, pop = _call(monkeypatch, genuine_wt=False, win_ack="1")
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_already_spawned_skips_relaunch(monkeypatch):
+    # #6 SWARPH_SPAWN set => inside a session we already spawned. Reliable
+    # loop-guard, independent of everything else — never re-relaunch.
+    r, pop = _call(monkeypatch, genuine_wt=False, spawn_marker="1")
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_non_interactive_stdout_skips_relaunch(monkeypatch):
+    # #7 CI / piped / redirected: no human console to relaunch from. Must NOT
+    # spawn a detached WT window even on conhost+wt.
+    r, pop = _call(monkeypatch, genuine_wt=False, isatty=False)
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_conhost_without_wt_falls_back_to_warning(monkeypatch):
+    # #8 conhost (not genuine WT) but wt.exe absent (locked-down box) => can't
+    # auto-fix; relaunch returns False and caller warns.
+    r, pop = _call(monkeypatch, genuine_wt=False, wt_path=None)
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_force_wt_still_loop_guarded_by_spawn_marker(monkeypatch):
+    # a persistent SWARPH_FORCE_WT must NOT cause infinite re-relaunch: the
+    # SWARPH_SPAWN marker on the relaunched tree wins over the force flag.
+    r, pop = _call(monkeypatch, genuine_wt=True, force_wt="1", spawn_marker="1")
+    assert r is False
+    pop.assert_not_called()
+
+
+def test_popen_failure_falls_back_gracefully(monkeypatch):
+    # if launching wt.exe itself errors, proceed in-place (don't crash the spawn).
+    boom = MagicMock(side_effect=OSError("wt launch failed"))
+    r, _ = _call(monkeypatch, genuine_wt=False, popen=boom)
+    assert r is False
+
+
+# --- the helper's own non-win32 guard (the one piece that can't be fully
+#     exercised on Linux; here we just confirm the fail-safe + no-raise) ----
+
+
+def test_console_is_genuine_wt_false_off_win32(monkeypatch):
+    # On any non-win32 platform the helper returns False immediately and never
+    # touches ctypes — so it can't raise on this Linux box.
+    monkeypatch.setattr(spawn.sys, "platform", "linux")
+    assert spawn._console_is_genuine_wt() is False

swarph_cli-0.9.4/tests/test_spawn_windows_relaunch.py

@@ -1,129 +0,0 @@
-"""Tests for `swarph spawn`'s Windows-Terminal conhost auto-relaunch.
-
-On legacy Windows console (conhost.exe), Claude Code's Ink TUI breaks — the SGR
-terminator 'm' leaks into stdin so Enter inserts a literal 'm'. `_relaunch_in_
-windows_terminal` auto-relaunches the session in Windows Terminal (where the TUI
-works) when on conhost + wt.exe is present. The ACTUAL wt.exe relaunch needs a real
-native-Windows box (workstation-lc seat-B); these tests pin the DECISION logic
-(relaunch vs warn vs proceed) via mocking, runnable on any platform.
-"""
-from __future__ import annotations
-
-from pathlib import Path
-from unittest.mock import MagicMock
-
-from swarph_cli.commands import spawn
-
-CLAUDE_BIN = "/usr/bin/claude"
-CLAUDE_ARGV = ["claude", "--name", "lab", "--session-id", "abc"]
-CWD = Path("/home/ubuntu/lab")
-WT = "C:\\Windows\\wt.exe"
-
-
-class _FakeStdout:
-    """Minimal stand-in so tests can control sys.stdout.isatty() — the helper
-    only ever calls .isatty() on stdout (its prints go to stderr)."""
-
-    def __init__(self, tty):
-        self._tty = tty
-
-    def isatty(self):
-        return self._tty
-
-
-def _call(monkeypatch, *, platform="win32", wt_session=None, win_ack=None,
-          spawn_marker=None, force_wt=None, isatty=True, wt_path=WT, popen=None):
-    monkeypatch.setattr(spawn.sys, "platform", platform)
-    monkeypatch.setattr(spawn.sys, "stdout", _FakeStdout(isatty))
-    for var, val in (("WT_SESSION", wt_session), ("SWARPH_WIN_ACK", win_ack),
-                     ("SWARPH_SPAWN", spawn_marker), ("SWARPH_FORCE_WT", force_wt)):
-        if val is None:
-            monkeypatch.delenv(var, raising=False)
-        else:
-            monkeypatch.setenv(var, val)
-    monkeypatch.setattr(spawn.shutil, "which",
-                        lambda name: wt_path if name == "wt" else None)
-    pop = popen or MagicMock()
-    monkeypatch.setattr(spawn.subprocess, "Popen", pop)
-    result = spawn._relaunch_in_windows_terminal(CLAUDE_BIN, CLAUDE_ARGV, CWD)
-    return result, pop
-
-
-def test_non_windows_never_relaunches(monkeypatch):
-    r, pop = _call(monkeypatch, platform="linux")
-    assert r is False
-    pop.assert_not_called()
-
-
-def test_already_in_windows_terminal_no_relaunch(monkeypatch):
-    # WT_SESSION set => already in Windows Terminal (TUI works); also the
-    # loop-guard — a relaunched session can never re-relaunch.
-    r, pop = _call(monkeypatch, wt_session="dead-beef-0001")
-    assert r is False
-    pop.assert_not_called()
-
-
-def test_operator_acked_stays_in_conhost(monkeypatch):
-    # SWARPH_WIN_ACK=1 => operator chose conhost; don't interfere.
-    r, pop = _call(monkeypatch, win_ack="1")
-    assert r is False
-    pop.assert_not_called()
-
-
-def test_conhost_without_wt_falls_back_to_warning(monkeypatch):
-    # conhost but wt.exe absent (locked-down box) => can't auto-fix; caller warns.
-    r, pop = _call(monkeypatch, wt_path=None)
-    assert r is False
-    pop.assert_not_called()
-
-
-def test_conhost_with_wt_relaunches_in_windows_terminal(monkeypatch):
-    r, pop = _call(monkeypatch)
-    assert r is True
-    pop.assert_called_once()
-    cmd = pop.call_args[0][0]
-    # exact shape: [wt, -d, <cwd>, --, claude_bin, *claude_flags]
-    assert cmd[:5] == [WT, "-d", str(CWD), "--", CLAUDE_BIN]
-    assert cmd[5:] == CLAUDE_ARGV[1:]   # claude_argv[1:] passed through (not argv0)
-    # carries SWARPH_SPAWN=1 so the SessionStart hook doesn't double-inject
-    assert pop.call_args.kwargs["env"]["SWARPH_SPAWN"] == "1"
-
-
-def test_popen_failure_falls_back_gracefully(monkeypatch):
-    # if launching wt.exe itself errors, proceed in-place (don't crash the spawn).
-    boom = MagicMock(side_effect=OSError("wt launch failed"))
-    r, _ = _call(monkeypatch, popen=boom)
-    assert r is False
-
-
-def test_non_interactive_stdout_skips_relaunch(monkeypatch):
-    # CI / piped / redirected: no human console to relaunch from. Must NOT spawn a
-    # detached WT window even on conhost+wt (workstation-lc's over-broad finding).
-    r, pop = _call(monkeypatch, isatty=False)
-    assert r is False
-    pop.assert_not_called()
-
-
-def test_already_spawned_skips_relaunch(monkeypatch):
-    # SWARPH_SPAWN set => we're inside a session we already spawned. Reliable
-    # loop-guard, independent of WT_SESSION (which proved unreliable on inheriting
-    # boxes) — a relaunched session can never re-relaunch.
-    r, pop = _call(monkeypatch, spawn_marker="1")
-    assert r is False
-    pop.assert_not_called()
-
-
-def test_force_wt_overrides_inherited_wt_session(monkeypatch):
-    # corporate boxes INHERIT WT_SESSION into child conhosts (commander hit this:
-    # had to clear WT_SESSION by hand). SWARPH_FORCE_WT=1 relaunches anyway.
-    r, pop = _call(monkeypatch, wt_session="inherited-guid", force_wt="1")
-    assert r is True
-    pop.assert_called_once()
-
-
-def test_force_wt_still_loop_guarded_by_spawn_marker(monkeypatch):
-    # a persistent SWARPH_FORCE_WT must NOT cause infinite re-relaunch: the
-    # SWARPH_SPAWN marker on the relaunched tree wins over the force flag.
-    r, pop = _call(monkeypatch, wt_session="g", force_wt="1", spawn_marker="1")
-    assert r is False
-    pop.assert_not_called()