swarph-cli 0.13.1__tar.gz → 0.13.2__tar.gz

{swarph_cli-0.13.1/src/swarph_cli.egg-info → swarph_cli-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.13.1
+Version: 0.13.2
 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

{swarph_cli-0.13.1 → swarph_cli-0.13.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.13.1"
+version = "0.13.2"
 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" }

{swarph_cli-0.13.1 → swarph_cli-0.13.2}/src/swarph_cli/__init__.py

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

{swarph_cli-0.13.1 → swarph_cli-0.13.2}/src/swarph_cli/commands/spawn.py

@@ -28,6 +28,7 @@ import os
 import shutil
 import subprocess
 import sys
+import time
 from pathlib import Path
 from typing import Optional
 from urllib.parse import quote
@@ -914,6 +915,54 @@ def _tmux_has_session(tmux: str, name: str) -> bool:
     return result.returncode == 0
 
 
+def _tmux_create_session(tmux: str, name: str, cwd: Path) -> bool:
+    """Create the durable detached session that runs ``swarph spawn <name>``.
+
+    Robust against a STALE session registration. When a multiplexer server dies
+    uncleanly (operator closed the owning console, ``kill``, a crash) it can leave
+    the session NAME registered with no live server behind it. On the native-Windows
+    psmux build (``marlocarlo.psmux``) this poisons re-creation: ``new-session``
+    becomes a SILENT no-op — it returns rc=0 but creates nothing — so the name can
+    never come back. That is the exact failure that strands a peer's cell ("the
+    session got killed and won't return"; verified on workstation-lc 2026-06-18).
+    Real tmux on Linux/mac does not hit this, and the extra steps are a harmless
+    no-op there (the create succeeds first try and the loop breaks immediately).
+
+    So: clear any stale registration first (``kill-session`` — a no-op if the name
+    is truly absent), then create. Because psmux clears the stale lock
+    ASYNCHRONOUSLY (~1s observed), do NOT trust the create's exit code (rc=0 even on
+    the silent no-op): VERIFY with ``has-session`` and retry until it actually
+    materialises. Returns True once the session exists, False if it never appears.
+    """
+    create_cmd = [
+        tmux, "new-session", "-d", "-s", name,
+        "-c", str(cwd), "-e", "SWARPH_SPAWN=1",
+        "swarph", "spawn", name,
+    ]
+    # Clear a stale (server-less) registration; harmless if the name is truly absent.
+    try:
+        subprocess.run(
+            [tmux, "kill-session", "-t", f"={name}"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except OSError:
+        return False
+    for attempt in range(6):
+        try:
+            subprocess.run(
+                create_cmd,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.PIPE,
+            )
+        except OSError:
+            return False
+        if _tmux_has_session(tmux, name):
+            return True
+        time.sleep(0.4)  # let psmux's async stale-lock clear catch up, then retry
+    return False
+
+
 def _launch_via_tmux(
     binary: str, argv: list[str], cwd: Path, session_name: str,
 ) -> bool:
@@ -978,24 +1027,15 @@ def _launch_via_tmux(
     interactive = sys.stdout.isatty()
 
     if not _tmux_has_session(tmux, session_name):
-        # Create the durable session detached. The command re-enters spawn so
-        # the membrane env-scrub + starter injection apply inside the pane; the
-        # inherited $TMUX (and SWARPH_SPAWN below) stop it from re-deciding.
-        try:
-            subprocess.run(
-                [
-                    tmux, "new-session", "-d", "-s", session_name,
-                    "-c", str(cwd), "-e", "SWARPH_SPAWN=1",
-                    "swarph", "spawn", session_name,
-                ],
-                check=True,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.PIPE,
-            )
-        except (OSError, subprocess.CalledProcessError) as exc:
+        # Create the durable session detached. The command re-enters spawn so the
+        # membrane env-scrub + starter injection apply inside the pane; the inherited
+        # $TMUX (and SWARPH_SPAWN) stop it from re-deciding. _tmux_create_session
+        # also clears a stale (server-less) registration that would otherwise make
+        # psmux's new-session a silent no-op and strand the cell.
+        if not _tmux_create_session(tmux, session_name, cwd):
             print(
-                f"swarph spawn: tmux session create failed ({exc}); falling "
-                "back to the standard launch.",
+                "swarph spawn: tmux session create failed (stale registration "
+                "could not be cleared?); falling back to the standard launch.",
                 file=sys.stderr,
             )
             return False

{swarph_cli-0.13.1 → swarph_cli-0.13.2/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.13.1
+Version: 0.13.2
 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

{swarph_cli-0.13.1 → swarph_cli-0.13.2}/tests/test_spawn_command.py

@@ -1323,6 +1323,13 @@ def test_run_spawn_grok_assisted_memory_no_double_system_prompt(
     monkeypatch.setattr("shutil.which", lambda name: "/bin/fake-grok")
     # neutralize the named-tmux launch so we reach launch()/execve in-test
     monkeypatch.setattr(spawn, "_launch_via_tmux", lambda *a, **k: False)
+    # This asserts on the composed argv (no doubled --system-prompt-override),
+    # which is platform-independent. Pin to a POSIX platform so launch() takes the
+    # os.execve branch we mock below — otherwise on Windows it takes the
+    # subprocess.run branch (v0.12.1 pane-collapse fix), the execve mock never
+    # fires, and the real /bin/fake-grok exec fails (WinError 2). Matches the
+    # platform-pinning convention of the launch tests above.
+    monkeypatch.setattr(spawn.sys, "platform", "linux")
 
     exec_args = []
     monkeypatch.setattr("os.execve", lambda p, a, e: exec_args.append((p, a, e)))

{swarph_cli-0.13.1 → swarph_cli-0.13.2}/tests/test_spawn_tmux_session.py

@@ -59,19 +59,27 @@ class _FakeStdout:
 
 def _drive(monkeypatch, *, platform="win32", tmux=TMUX, wt=WT, in_tmux=None,
            spawn_marker=None, isatty=True, session_exists=False,
-           new_session_exc=None):
+           new_session_exc=None, create_succeeds=True, create_succeeds_after=1):
     """Drive `_launch_via_tmux` with tmux/subprocess/execv mocked.
 
-    `run` dispatches on the subcommand: `has-session` returns rc 0/1 per
-    `session_exists`; `new-session` returns rc 0 (or raises `new_session_exc`);
-    `attach` (Windows path only) returns rc 0. The POSIX attach is os.execv,
-    mocked to raise `_ExecvReplaced` (simulating its never-returns replace).
+    `run` dispatches on the subcommand and is STATEFUL to model reality after the
+    stale-registration fix: `has-session` returns rc 0 once the session exists —
+    either pre-existing (`session_exists`) OR after a `new-session` "takes".
+    `_tmux_create_session` clears a stale reg (`kill-session`, rc 0 here) then
+    creates + VERIFIES via `has-session`, retrying because psmux clears the stale
+    lock asynchronously. `create_succeeds_after` models that delay: the session
+    only materialises on the Nth `new-session` call (1 = first try, the happy
+    path). `create_succeeds=False` models a create that never materialises (e.g. a
+    stale lock that won't clear) → the loop exhausts and returns False.
+    `new-session` raises `new_session_exc` when set. `attach` (Windows) returns rc
+    0; POSIX attach is os.execv, mocked to raise `_ExecvReplaced`.
 
     Returns `(result, run, execv)`. `result` is the function's bool, or the
     `_EXECV` sentinel when the POSIX execv attach took over.
     """
     monkeypatch.setattr(spawn.sys, "platform", platform)
     monkeypatch.setattr(spawn.sys, "stdout", _FakeStdout(isatty))
+    monkeypatch.setattr(spawn.time, "sleep", lambda *_a, **_k: None)  # no real wait
     for var, val in (("TMUX", in_tmux), ("SWARPH_SPAWN", spawn_marker)):
         if val is None:
             monkeypatch.delenv(var, raising=False)
@@ -83,12 +91,20 @@ def _drive(monkeypatch, *, platform="win32", tmux=TMUX, wt=WT, in_tmux=None,
 
     monkeypatch.setattr(spawn.shutil, "which", _which)
 
+    state = {"new_calls": 0, "created": False}
+
     def _run(cmd, **kwargs):
         if "has-session" in cmd:
-            return MagicMock(returncode=0 if session_exists else 1)
-        if "new-session" in cmd and new_session_exc is not None:
-            raise new_session_exc
-        return MagicMock(returncode=0)
+            exists = session_exists or state["created"]
+            return MagicMock(returncode=0 if exists else 1)
+        if "new-session" in cmd:
+            if new_session_exc is not None:
+                raise new_session_exc
+            state["new_calls"] += 1
+            if create_succeeds and state["new_calls"] >= create_succeeds_after:
+                state["created"] = True
+            return MagicMock(returncode=0)
+        return MagicMock(returncode=0)  # kill-session, attach, ...
 
     run = MagicMock(side_effect=_run)
     monkeypatch.setattr(spawn.subprocess, "run", run)
@@ -108,6 +124,11 @@ def _cmds(run):
     return [c.args[0] for c in run.call_args_list]
 
 
+def _killed_stale(run):
+    """True if the stale-registration clear (`kill-session`) was issued."""
+    return any("kill-session" in c for c in _cmds(run))
+
+
 def _attached_via_run(run):
     """True if the Windows blocking-subprocess.run attach fired."""
     return [TMUX, "attach", "-t", SESSION] in _cmds(run)
@@ -239,17 +260,33 @@ def test_existing_session_headless_is_a_noop_handoff(monkeypatch, platform):
 
 
 @pytest.mark.parametrize("platform", ["win32", "linux"])
-def test_create_failure_falls_through(monkeypatch, platform):
-    # tmux new-session errors => return False so the caller drops to the standard
-    # launch; never attach a half-created session.
-    boom = subprocess.CalledProcessError(1, "tmux")
+def test_create_never_materialises_falls_through(monkeypatch, platform):
+    # The session never appears (e.g. a psmux stale registration that won't clear:
+    # new-session returns rc 0 but creates nothing). The verify+retry loop exhausts
+    # => return False so the caller drops to the standard launch; never attach a
+    # phantom session. We also issued the stale-clear kill-session first.
     r, run, execv = _drive(monkeypatch, platform=platform,
-                           session_exists=False, new_session_exc=boom)
+                           session_exists=False, create_succeeds=False)
     assert r is False
+    assert _killed_stale(run)
     assert not _attached_via_run(run)
     execv.assert_not_called()
 
 
+@pytest.mark.parametrize("platform", ["win32", "linux", "darwin"])
+def test_stale_registration_cleared_then_create_retried(monkeypatch, platform):
+    # The poisoned-name recovery path: kill-session clears the stale reg, but psmux
+    # clears the lock async so the FIRST new-session is a silent no-op; the session
+    # only materialises on the 2nd attempt. The verify loop must retry and succeed.
+    r, run, execv = _drive(monkeypatch, platform=platform, session_exists=False,
+                           isatty=False, create_succeeds_after=2)
+    assert r is True                              # headless: created, claimed launch
+    assert _killed_stale(run)                     # stale reg cleared first
+    new_calls = [c for c in _cmds(run) if "new-session" in c]
+    assert len(new_calls) >= 2                    # retried past the silent no-op
+    execv.assert_not_called()
+
+
 @pytest.mark.parametrize("platform", ["win32", "linux"])
 def test_create_oserror_falls_through(monkeypatch, platform):
     r, run, execv = _drive(