swarph-cli 0.9.1__tar.gz → 0.9.2__tar.gz

{swarph_cli-0.9.1/src/swarph_cli.egg-info → swarph_cli-0.9.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.1
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.1 hardens the membrane billing-scrub + import path-traversal + watchdog session-scoping (adversarial-sweep).
+Version: 0.9.2
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.2 makes the watchdog deploy-safe: no false A2 when no tmux server is reachable (root-cron), and F3 uses window/session activity so active sessions are correctly detected.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.1 → swarph_cli-0.9.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.9.1"
-description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.1 hardens the membrane billing-scrub + import path-traversal + watchdog session-scoping (adversarial-sweep)."
+version = "0.9.2"
+description = "The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.2 makes the watchdog deploy-safe: no false A2 when no tmux server is reachable (root-cron), and F3 uses window/session activity so active sessions are correctly detected."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"

{swarph_cli-0.9.1 → swarph_cli-0.9.2}/src/swarph_cli/__init__.py

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

{swarph_cli-0.9.1 → swarph_cli-0.9.2}/src/swarph_cli/commands/watchdog.py

@@ -393,10 +393,24 @@ def _process_alive(tmux_session: str) -> bool:
             capture_output=True, text=True, timeout=5,
         )
         if panes.returncode != 0:
-            return False  # session has no panes / doesn't exist → not alive
+            # list-panes fails for TWO very different reasons:
+            #   (a) the tmux server is reachable but this session is genuinely
+            #       gone → really dead → False (let A2 fire).
+            #   (b) there is no tmux server reachable from THIS uid (e.g. the
+            #       watchdog runs as root while sessions live under ubuntu's
+            #       /tmp/tmux-1000 socket) → we simply CAN'T determine liveness
+            #       via tmux → must NOT false-fire A2.
+            # Distinguish by probing the server itself.
+            server = subprocess.run(
+                ["tmux", "list-sessions"],
+                capture_output=True, text=True, timeout=5,
+            )
+            if server.returncode != 0:
+                return True  # no reachable tmux server here → can't tell → assume alive
+            return False     # server reachable, session absent → genuinely dead
         pane_pids = {int(p) for p in panes.stdout.split() if p.strip().isdigit()}
         if not pane_pids:
-            return False
+            return True  # ambiguous (session with no pane pids) → don't false-fire
 
         pg = subprocess.run(
             ["pgrep", "-f", "claude"],
@@ -434,34 +448,39 @@ def _tmux_send_keys(name: str, text: str) -> bool:
 
 
 def _pane_activity_age_sec(name: str) -> Optional[int]:
-    """Age in seconds since the tmux pane's last activity event.
-
-    Reads tmux's `#{pane_activity}` format variable, which returns a unix
-    epoch timestamp of the most recent activity in the active pane of the
-    target session. Returns None if tmux is missing, the session doesn't
-    exist, or tmux's output isn't parseable as an integer epoch.
-
-    Used by F3 (mother #1087 / drop-on-meta-edge proposal) as a third
-    AND-gate input to distinguish (a) session genuinely stalled from (b)
-    session actively working in a long bash block. cursor-mtime alone
-    measures "time since last turn-end" not "time since last activity";
-    pane_activity covers the mid-turn-active case.
-
-    Returns None on detection error so the caller can fall through to
-    the legacy AND-gate behavior — F3 is a strengthening of the gate,
-    not a replacement of it.
+    """Age in seconds since the target session's most recent tmux activity.
+
+    Reads tmux activity-timestamp format vars and uses the MOST RECENT
+    (max epoch) across pane / window / session. ``#{pane_activity}`` is only
+    populated when monitor-activity is on (empty on a default tmux 3.x), so
+    relying on it alone made F3 a no-op — it returned None and never
+    suppressed A1 for a genuinely-active session (adversarial-deploy finding
+    2026-06-02). ``#{window_activity}`` / ``#{session_activity}`` are tracked
+    unconditionally and give the same "is this session alive right now" signal.
+
+    Used by F3 (mother #1087) as a third AND-gate input to distinguish (a) a
+    session genuinely stalled from (b) one actively working in a long bash
+    block where cursor-mtime (last turn-end) is stale but the session is alive.
+
+    Returns None only when NO activity timestamp is parseable (tmux missing /
+    session absent), so the caller falls through to the legacy AND-gate.
     """
     try:
         result = subprocess.run(
-            ["tmux", "display", "-p", "-t", name, "#{pane_activity}"],
+            ["tmux", "display", "-p", "-t", name,
+             "#{pane_activity}|#{window_activity}|#{session_activity}"],
             capture_output=True, text=True, timeout=5,
         )
         if result.returncode != 0:
             return None
-        out = result.stdout.strip()
-        if not out:
+        epochs = []
+        for tok in result.stdout.strip().split("|"):
+            tok = tok.strip()
+            if tok.isdigit():
+                epochs.append(int(tok))
+        if not epochs:
             return None
-        return max(0, _now() - int(out))
+        return max(0, _now() - max(epochs))
     except (subprocess.TimeoutExpired, FileNotFoundError, OSError, ValueError):
         return None
 

{swarph_cli-0.9.1 → swarph_cli-0.9.2/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.9.1
-Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.1 hardens the membrane billing-scrub + import path-traversal + watchdog session-scoping (adversarial-sweep).
+Version: 0.9.2
+Summary: The `swarph` binary — multi-LLM CLI + mesh-gateway integration: multi-provider spawn (claude/codex/antigravity per cell.provider via a ProviderMembrane), cell.yaml, `swarph mesh` (send/inbox/register with per-peer tokens) + inbox sidecar, `assisted_memory` (git-backed durable memory), session import, watchdog. v0.9.2 makes the watchdog deploy-safe: no false A2 when no tmux server is reachable (root-cron), and F3 uses window/session activity so active sessions are correctly detected.
 Author: Pierre Samson, Claude Opus
 License: MIT
 Project-URL: Homepage, https://github.com/darw007d/swarph-cli

{swarph_cli-0.9.1 → swarph_cli-0.9.2}/tests/test_watchdog.py

@@ -132,6 +132,7 @@ def test_stale_cursor_alive_process_unread_dms_fires_a1(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=3), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True) as send_mock:
         rc = run_watchdog(argv=[
             "--check", "--cell", "lab",
@@ -279,6 +280,7 @@ def test_a1_fires_at_most_once_per_stale_window(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=3), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True) as send_mock:
         # First invocation — A1 fires
         rc1 = run_watchdog(argv=[
@@ -322,6 +324,7 @@ def test_a1_rearms_after_cursor_advance(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=2), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True) as send_mock:
         # First A1 fires
         run_watchdog(argv=[
@@ -482,6 +485,7 @@ def test_a2_escalation_clears_a1_marker(
     with patch("swarph_cli.commands.watchdog._process_alive", return_value=True), \
          patch("swarph_cli.commands.watchdog._gateway_unread_count", return_value=5), \
          patch("swarph_cli.commands.watchdog._tmux_session_exists", return_value=True), \
+         patch("swarph_cli.commands.watchdog._pane_activity_age_sec", return_value=None), \
          patch("swarph_cli.commands.watchdog._tmux_send_keys", return_value=True):
         # First fire — record marker
         run_watchdog(argv=[
@@ -728,10 +732,13 @@ class _R:
         self.stdout = stdout
 
 
-def _fake_run_factory(tmux_rc, tmux_out, pgrep_rc, pgrep_out):
+def _fake_run_factory(panes_rc, panes_out, pgrep_rc, pgrep_out, sessions_rc=0):
+    """Mock subprocess.run distinguishing tmux list-panes vs list-sessions."""
     def fake_run(cmd, **kw):
-        if cmd[0] == "tmux":
-            return _R(tmux_rc, tmux_out)
+        if cmd[0] == "tmux" and cmd[1] == "list-panes":
+            return _R(panes_rc, panes_out)
+        if cmd[0] == "tmux" and cmd[1] == "list-sessions":
+            return _R(sessions_rc, "" if sessions_rc else "lab: 1 windows\n")
         if cmd[0] == "pgrep":
             return _R(pgrep_rc, pgrep_out)
         return _R(1, "")
@@ -761,14 +768,56 @@ def test_process_alive_true_when_claude_under_session(monkeypatch):
     assert _wd._process_alive("mysess") is True
 
 
-def test_process_alive_false_when_session_absent(monkeypatch):
-    """tmux has no such session → not alive (don't fall through to host-wide)."""
+def test_process_alive_false_when_session_absent_but_server_up(monkeypatch):
+    """Server reachable + this session genuinely gone → dead (A2 may fire)."""
     monkeypatch.setattr(_wd.subprocess, "run",
-                        _fake_run_factory(1, "", 0, "2000\n"))
+                        _fake_run_factory(1, "", 0, "2000\n", sessions_rc=0))
     assert _wd._process_alive("ghost") is False
 
 
+def test_process_alive_assumes_alive_when_no_tmux_server(monkeypatch):
+    """Regression (deploy 2026-06-02): the watchdog runs as ROOT, whose tmux
+    socket is empty — list-panes AND list-sessions both fail. We CANNOT
+    determine liveness via tmux, so must assume alive, NOT false-fire an A2
+    respawn of a session that's actually alive under ubuntu's tmux."""
+    monkeypatch.setattr(_wd.subprocess, "run",
+                        _fake_run_factory(1, "", 0, "2000\n", sessions_rc=1))
+    assert _wd._process_alive("lab") is True
+
+
 def test_process_alive_false_when_no_claude_anywhere(monkeypatch):
     monkeypatch.setattr(_wd.subprocess, "run",
                         _fake_run_factory(0, "1000\n", 1, ""))
     assert _wd._process_alive("mysess") is False
+
+
+# ---------------------------------------------------------------------------
+# _pane_activity_age_sec — fallback across pane/window/session (F3 fix 2026-06-02)
+# ---------------------------------------------------------------------------
+
+
+def test_pane_activity_age_falls_back_when_pane_empty(monkeypatch):
+    """pane_activity is empty without monitor-activity (tmux 3.x). F3 must fall
+    back to window/session activity, NOT return None — returning None made F3 a
+    no-op and let A1 fire against a genuinely-active session."""
+    recent = _wd._now() - 30
+    monkeypatch.setattr(_wd.subprocess, "run",
+                        lambda cmd, **kw: _R(0, f"|{recent}|{recent - 5}\n"))
+    age = _wd._pane_activity_age_sec("lab")
+    assert age is not None
+    assert 25 <= age <= 40  # ~30s, allowing for execution slack
+
+
+def test_pane_activity_age_none_when_all_blank(monkeypatch):
+    monkeypatch.setattr(_wd.subprocess, "run", lambda cmd, **kw: _R(0, "||\n"))
+    assert _wd._pane_activity_age_sec("lab") is None
+
+
+def test_pane_activity_age_takes_most_recent(monkeypatch):
+    """Uses the MAX (most recent) epoch across the three vars."""
+    now = _wd._now()
+    # pane empty, window 500s ago, session 10s ago → most recent = 10s
+    monkeypatch.setattr(_wd.subprocess, "run",
+                        lambda cmd, **kw: _R(0, f"|{now - 500}|{now - 10}\n"))
+    age = _wd._pane_activity_age_sec("lab")
+    assert age is not None and age <= 20