swarph-cli 0.72.27__tar.gz → 0.72.28__tar.gz

{swarph_cli-0.72.27/src/swarph_cli.egg-info → swarph_cli-0.72.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.27
+Version: 0.72.28
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.27 → swarph_cli-0.72.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.27"
+version = "0.72.28"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.72.27 → swarph_cli-0.72.28}/src/swarph_cli/__init__.py

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

{swarph_cli-0.72.27 → swarph_cli-0.72.28}/src/swarph_cli/scripts/wake_watchdog.py

@@ -148,8 +148,9 @@ def _waiter_just_delivered(inbox: str, now: float | None = None) -> bool:
 
 def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
     """A reader is tail or dm_notify_filter with the inbox path as its own argument,
-    a channel server whose heartbeat is fresh, or a one-shot `swarph mesh wait`
-    for this cell (running, or delivered within WAIT_REARM_GRACE).
+    a channel server whose heartbeat is fresh, a one-shot `swarph mesh wait` for
+    this cell (running, or delivered within WAIT_REARM_GRACE), or the cell's own
+    monitor running with a tmux sink.
 
     A process that merely mentions the path (a prompt, a log line) is not a reader.
     """
@@ -160,6 +161,8 @@ def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
         parts = cmd.split()
         if _waits_on(parts, cell):
             return True
+        if _monitor_sink_pushes(parts, cell):
+            return True
         if inbox not in parts:
             continue
         if any(os.path.basename(p) == "tail" for p in parts):
@@ -169,6 +172,38 @@ def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
     return False
 
 
+def _monitor_sink_pushes(parts: list[str], cell: str) -> bool:
+    """A running `swarph monitor`, started with `--as <cell>` and a tmux sink,
+    is a wake path.
+
+    The monitor's tmux sink injects the wake into the cell's pane; card #961
+    measured that a cell cannot wake its own session, so this sink is the only
+    path that actually STARTS a turn. It names the cell, not the inbox path, so
+    it is checked before the inbox-path gate. Observation only: the watchdog
+    never starts a monitor. A process that merely quotes the command (a prompt,
+    a log line) is not the monitor -- it must BE swarph running the monitor for
+    this cell with a tmux deliver sink.
+    """
+    for i in (0, 1):
+        if len(parts) < i + 4 or os.path.basename(parts[i]) != "swarph":
+            continue
+        if i == 1 and not os.path.basename(parts[0]).startswith("python"):
+            continue
+        if parts[i + 1:i + 3] != ["monitor", "start"]:
+            continue
+        rest = parts[i + 3:]
+        named = f"--as={cell}" in rest or any(
+            a == "--as" and b == cell for a, b in zip(rest, rest[1:]))
+        # Any tmux: pane counts, in either form (`--deliver tmux:<pane>` or
+        # `--deliver=tmux:<pane>`) -- the sink is the cell's wake, whatever pane
+        # it names, so the two spellings must agree.
+        has_tmux = any(p.startswith("--deliver=tmux:") for p in rest) or any(
+            a == "--deliver" and b.startswith("tmux:")
+            for a, b in zip(rest, rest[1:]))
+        return named and has_tmux
+    return False
+
+
 def _waits_on(parts: list[str], cell: str) -> bool:
     """`swarph mesh wait --once --as <cell>` names the cell, not the inbox path.
 

{swarph_cli-0.72.27 → swarph_cli-0.72.28/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.27
+Version: 0.72.28
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT

{swarph_cli-0.72.27 → swarph_cli-0.72.28}/tests/test_729_wake_watchdog.py

@@ -333,3 +333,56 @@ def test_the_re_arm_gap_after_a_one_shot_delivery_is_not_an_outage(tmp_path):
     st = {}
     assert scan(cells, [], st, now=0) == []
     assert scan(cells, [], st, now=120) == ["copilot"]
+
+
+def test_a_monitor_with_a_tmux_sink_is_a_watcher():
+    """Card #961: the tmux sink is the only path that starts a turn, so a cell
+    whose own monitor runs with `--deliver tmux:<pane>` is watched even with no
+    tail -- the commander's one-wake-source rule (drop the tail, keep the sink)."""
+    cells = {"opencode": "/tmp/opencode/mesh-sidecar/inbox.log"}
+    state = {}
+    monitor = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph monitor start "
+               "--as opencode --deliver tmux:opencode --deliver pull --foreground"]
+    assert scan(cells, monitor, state, now=0) == []
+    assert scan(cells, monitor, state, now=120) == []
+    assert state["opencode"].get("outage") is not True
+
+
+def test_a_prompt_quoting_the_monitor_command_is_not_a_watcher():
+    cells = {"opencode": "/tmp/opencode/mesh-sidecar/inbox.log"}
+    state = {}
+    noise = ['claude --append-system-prompt "run swarph monitor start --as opencode '
+             '--deliver tmux:opencode"']
+    assert scan(cells, noise, state, now=0) == []
+    assert scan(cells, noise, state, now=120) == ["opencode"]
+
+
+def test_a_monitor_for_another_cell_is_not_this_cells_watcher():
+    cells = {"opencode": "/tmp/opencode/mesh-sidecar/inbox.log"}
+    state = {}
+    other = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph monitor start "
+             "--as cursor-lin --deliver tmux:cursor-lin --foreground"]
+    assert scan(cells, other, state, now=0) == []
+    assert scan(cells, other, state, now=120) == ["opencode"]
+
+
+def test_a_pull_only_monitor_is_not_a_watcher():
+    """A pull-only monitor writes inbox.log but starts no turn, so the cell is
+    still unwatched (card #1234)."""
+    cells = {"opencode": "/tmp/opencode/mesh-sidecar/inbox.log"}
+    state = {}
+    pull_only = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph monitor start "
+                 "--as opencode --deliver pull --foreground"]
+    assert scan(cells, pull_only, state, now=0) == []
+    assert scan(cells, pull_only, state, now=120) == ["opencode"]
+
+
+def test_the_equals_form_of_the_tmux_sink_counts():
+    """Both spellings agree: any tmux:<pane> counts, not only the cell's own name."""
+    cells = {"opencode": "/tmp/opencode/mesh-sidecar/inbox.log"}
+    state = {}
+    monitor = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph monitor start "
+               "--as opencode --deliver=tmux:some-other-pane --foreground"]
+    assert scan(cells, monitor, state, now=0) == []
+    assert scan(cells, monitor, state, now=120) == []
+    assert state["opencode"].get("outage") is not True