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

{swarph_cli-0.72.26/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.26
+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.26 → swarph_cli-0.72.28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.26"
+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.26 → 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.26"
+__version__ = "0.72.28"
 
 __all__ = ["__version__"]

{swarph_cli-0.72.26 → 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.
 
@@ -398,9 +433,18 @@ def main(argv: list[str] | None = None) -> int:
     rc = 0
     for name in alert:
         print(f"outage {name}", flush=True)
-        dm_rc = mesh_send(
-            swarph, name, sender, "IMMUNE (cell watchdog): your DM wake is dead, re-arm", token_file)
-        dm_ok = dm_rc == 0
+        # Card #1237: the outage cell can be the --as sender itself (the unit
+        # runs --as lab-ovh while watching lab-ovh). mesh_send refuses a
+        # self-send (rc 2), so the outage was never marked and every tick
+        # re-alerted (112 card posts + 112 escalate DMs for one outage).
+        # Skip the self DM and count it as sent, the same shape as the
+        # escalate != name guard below: the card post and the escalate DM
+        # still carry the alert, so the outage is marked once.
+        if name == sender:
+            dm_ok = True
+        else:
+            dm_ok = mesh_send(
+                swarph, name, sender, "IMMUNE (cell watchdog): your DM wake is dead, re-arm", token_file) == 0
         card_argv = [swarph, "board", "cards", "say", "729", "--as", sender,
                      "--to", name, "--content", f"IMMUNE (cell watchdog) — {name}: DM wake is dead, re-arm"]
         if token_file:

{swarph_cli-0.72.26 → 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.26
+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.26 → swarph_cli-0.72.28}/tests/test_729_wake_watchdog.py

@@ -153,6 +153,48 @@ def test_escalation_is_one_dm_to_the_peer_and_not_to_itself(tmp_path):
     assert own.count("mesh send watcher-peer") == 1
 
 
+@pytest.mark.skipif(
+    sys.platform == "win32",
+    reason="Windows cannot execute the POSIX swarph stub as argv0; the self-outage assertions run on Linux",
+)
+def test_outage_of_the_sender_itself_marks_once_and_does_not_realert(tmp_path):
+    """Card #1237: the dead cell IS the --as sender. mesh_send refuses the
+    self-send, which used to leave the outage unmarked, so every tick posted
+    the card and DM'd the escalation peer again (112 of each for one outage).
+    The self DM is skipped and counted as sent: the card post and the
+    escalate DM carry the alert, the outage is marked once, and a second
+    pass sends nothing."""
+    root = tmp_path / "state"
+    _cell(root, "lab-ovh")
+    state_path = tmp_path / "wake.json"
+    log = tmp_path / "stub.log"
+    env = {
+        **os.environ,
+        "PYTHONPATH": os.path.abspath("src"),
+        "SWARPH_STATE_ROOT": str(root),
+        "WAKE_WATCHDOG_STATE": str(state_path),
+        "SWARPH_BIN": str(_stub(tmp_path)),
+        "STUB_LOG": str(log),
+        "STUB_RC": "0",
+    }
+    env.pop("SWARPH_SELF", None)
+    run = [sys.executable, "-m", "swarph_cli.scripts.wake_watchdog",
+           "--as", "lab-ovh", "--escalate", "drop-on-meta-edge"]
+    subprocess.run(run, env=env, check=True)
+    saved = json.loads(state_path.read_text())
+    saved["lab-ovh"]["missing_since"] = 0
+    state_path.write_text(json.dumps(saved))
+    subprocess.run(run, env=env, check=True)
+    text = log.read_text()
+    assert "mesh send lab-ovh" not in text, "no self DM was attempted"
+    assert "cards say 729" in text, "the card post still carries the alert"
+    assert text.count("mesh send drop-on-meta-edge") == 1
+    assert json.loads(state_path.read_text())["lab-ovh"]["outage"] is True
+    log.write_text("")
+    subprocess.run(run, env=env, check=True)
+    assert log.read_text().strip() == "", "a marked outage does not re-alert"
+
+
 def test_sender_equal_to_escalation_peer_saves_nothing(tmp_path):
     root = tmp_path / "state"
     _cell(root, "nobody")
@@ -291,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