swarph-cli 0.72.18__tar.gz → 0.72.19__tar.gz

{swarph_cli-0.72.18/src/swarph_cli.egg-info → swarph_cli-0.72.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.18
+Version: 0.72.19
 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.18 → swarph_cli-0.72.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.18"
+version = "0.72.19"
 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.18 → swarph_cli-0.72.19}/src/swarph_cli/__init__.py

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

{swarph_cli-0.72.18 → swarph_cli-0.72.19}/src/swarph_cli/scripts/wake_watchdog.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Iterable
 
 GAP_SECONDS = 60
+WAIT_REARM_GRACE = 600
 
 
 def writer_verdict(*, reader_alive: bool, monitor_rc: int) -> str:
@@ -132,16 +133,33 @@ def _channel_alive(inbox: str, now: float | None = None) -> bool:
     return (time.time() if now is None else now) - ts < 180
 
 
+def _waiter_just_delivered(inbox: str, now: float | None = None) -> bool:
+    """`swarph mesh wait --once` writes wait_cursor.json beside the inbox when it
+    delivers, then exits. The cell re-arms only after acting on the DM, which can
+    take minutes; inside that window no waiter is running but the wake is not dead.
+    """
+    try:
+        mtime = (Path(inbox).parent / "wait_cursor.json").stat().st_mtime
+    except OSError:
+        return False
+    age = (time.time() if now is None else now) - mtime
+    return 0 <= age < WAIT_REARM_GRACE  # a future mtime is not a delivery
+
+
 def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
     """A reader is tail or dm_notify_filter with the inbox path as its own argument,
-    or a channel server whose heartbeat is fresh.
+    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 process that merely mentions the path (a prompt, a log line) is not a reader.
     """
-    if _channel_alive(inbox):
+    if _channel_alive(inbox) or _waiter_just_delivered(inbox):
         return True
+    cell = Path(inbox).parent.parent.name
     for cmd in cmdlines:
         parts = cmd.split()
+        if _waits_on(parts, cell):
+            return True
         if inbox not in parts:
             continue
         if any(os.path.basename(p) == "tail" for p in parts):
@@ -151,6 +169,27 @@ def _watching(inbox: str, cmdlines: Iterable[str]) -> bool:
     return False
 
 
+def _waits_on(parts: list[str], cell: str) -> bool:
+    """`swarph mesh wait --once --as <cell>` names the cell, not the inbox path.
+
+    copilot wakes on this waiter's exit (card #387). The process must BE swarph
+    (argv[0], or argv[1] after an interpreter), so a prompt that quotes the
+    command is not a reader.
+    """
+    for i in (0, 1):
+        if len(parts) < i + 3 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] != ["mesh", "wait"]:
+            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:]))
+        return "--once" in rest and named
+    return False
+
+
 def _cron_watched(name: str, crontab: str) -> bool:
     """An active crontab line that runs dm_wake.py for this cell is its poller."""
     for line in crontab.splitlines():

{swarph_cli-0.72.18 → swarph_cli-0.72.19/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.18
+Version: 0.72.19
 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.18 → swarph_cli-0.72.19}/tests/test_729_wake_watchdog.py

@@ -240,3 +240,54 @@ def test_a_channel_cell_with_a_fresh_heartbeat_is_watched(tmp_path):
     hb.write_text(json.dumps({"pid": 1, "ts": _t.time() - 600}))  # server died 10 min ago
     assert scan(cells, channel_ps, state, now=130) == []
     assert scan(cells, channel_ps, state, now=200) == ["drop"]
+
+
+def test_a_one_shot_mesh_wait_for_the_cell_is_a_watcher(tmp_path):
+    """Live 2026-10-12 23:34Z: copilot wakes on `swarph mesh wait --once` exiting (card #387,
+    probe 69717), and that command line names the cell, not the inbox path, so the watchdog
+    paged copilot 'DM wake is dead' (msgs 69720/69721). Fails on main.
+    tmp_path, not the live path: a live wait_cursor.json would count as watched."""
+    inbox = str(tmp_path / "copilot" / "mesh-sidecar" / "inbox.log")
+    cells = {"copilot": inbox}
+    waiter = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph mesh wait --once --as copilot --max-wait-s 1500"]
+    state = {}
+    assert scan(cells, waiter, state, now=0) == []
+    assert scan(cells, waiter, state, now=120) == []
+    assert scan(cells, ["swarph mesh wait --once --as=copilot"], {}, now=120) == []
+    other = ["/usr/bin/python3 /home/ubuntu/.local/bin/swarph mesh wait --once --as lab-ovh"]
+    quoted = ["claude -p run swarph mesh wait --once --as copilot then reply"]
+    no_once = ["/home/ubuntu/.local/bin/swarph mesh wait --as copilot"]
+    # drop-on-meta-edge #1682: argv[1] counted without checking argv[0] is an interpreter.
+    echo = ["echo swarph mesh wait --once --as copilot"]
+    grep = ["grep swarph mesh wait --once --as copilot notes.txt"]
+    claude = ["claude swarph mesh wait --once --as copilot and report"]
+    for listing in (other, quoted, no_once, echo, grep, claude):
+        st = {}
+        assert scan(cells, listing, st, now=0) == []
+        assert scan(cells, listing, st, now=120) == ["copilot"], listing
+
+
+def test_the_re_arm_gap_after_a_one_shot_delivery_is_not_an_outage(tmp_path):
+    """The waiter exits on delivery and copilot re-arms only after acting on the DM;
+    a turn longer than GAP_SECONDS paged copilot under the waiter-only fix. A cursor
+    written 30 s ago covers the gap; one written 700 s ago does not."""
+    import os, time
+    inbox = tmp_path / "copilot" / "mesh-sidecar" / "inbox.log"
+    inbox.parent.mkdir(parents=True)
+    inbox.write_text("")
+    cursor = inbox.parent / "wait_cursor.json"
+    cursor.write_text('{"last_delivered_id": 69717}')
+    cells = {"copilot": str(inbox)}
+    t = time.time()
+    os.utime(cursor, (t - 30, t - 30))
+    st = {}
+    assert scan(cells, [], st, now=0) == []
+    assert scan(cells, [], st, now=120) == []
+    os.utime(cursor, (t - 700, t - 700))
+    st = {}
+    assert scan(cells, [], st, now=0) == []
+    assert scan(cells, [], st, now=120) == ["copilot"]
+    os.utime(cursor, (t + 3600, t + 3600))  # #1682: a future mtime hid the outage unboundedly
+    st = {}
+    assert scan(cells, [], st, now=0) == []
+    assert scan(cells, [], st, now=120) == ["copilot"]